def test_sscs_override_static_name(self):
tile_config = {
'tags': ['ip:192.168.1.1'],
'tw_type': 'Range',
'series_spec_list': [
SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
SeriesSpec(2, 0, dict(op='eq', args=['john'])),
],
'tile_options': {
'seconds_back': 86400,
'tile_title': 'Points by user'
}
}
tile_config['series_spec_list'][0].params['static_name'] = 'monique_points'
self.assertEqual('monique_points', tile_config['series_spec_list'][0].name())
tile_config['tile_options']['sscs'] = tile_config['series_spec_list'][0]
rd = new_report_data('points')
tile = Tile.insert(rd.owner_id, rd.report.report_id, rd.dashboard_id, tile_config)
layouts.place_tile(tile)
d = [OrderedDict([('user_name', 'robert'), ('is_active', True), ('points', 128)]),
OrderedDict([('user_name', 'monique'), ('is_active', True), ('points', 210)])]
res = rd.report.process_input(json.dumps(d), tags=tile_config['tags'])
tile = rd.only_tile_from_layout()
self.assertEqual(3, len(tile.series_specs()))
expected_ss = SeriesSpec(2, 0, dict(op='eq', args=['robert']))
self.assertEqual('robert', expected_ss.name())
self.assertEqual('robert', tile.series_specs()[-1].name())
def test_sscreator_as_mod(self):
owner_id = uuid.uuid4()
dashboard_id = uuid.uuid4()
tile_config = {
'series_spec_list': [
SeriesSpec(1, 0, dict(op='eq', args=['label1'])),
],
'tile_options': {
'sscs': SeriesSpec(1, 0, dict(op='eq', args=['label1']))
}
}
r = Report.insert(owner_id, 'r')
tile = Tile.insert(owner_id, r.report_id, dashboard_id, tile_config)
layouts.place_tile(tile)
ri1 = r.process_input('label1 1',
handle_sscreator=False).report_instance
ri2 = r.process_input('label11 11\nlabel12 12',
handle_sscreator=False).report_instance
ri3 = r.process_input('label21 21\nlabel22 22',
handle_sscreator=False).report_instance
layout_rows = c.dao.LayoutDAO.select_layout_by_report_multi(owner_id, r.report_id,
[], 'sscs', 100)
mods = [sscreator.sscreator_mod(ri1, layout_rows[0]),
sscreator.sscreator_mod(ri2, layout_rows[0]),
sscreator.sscreator_mod(ri3, layout_rows[0])]
layouts.apply_mods(mods, owner_id, dashboard_id, None)
layout = Layout.select(owner_id, dashboard_id)
tile = layout.tile_dict.keys()[0]
def test_sscs_different_tag(self):
rd, tile = self.test_sscs()
tile_config = {
'tags': [],
'tw_type':
'Range',
'series_spec_list': [
SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
SeriesSpec(2, 0, dict(op='eq', args=['john'])),
],
'tile_options': {
'seconds_back': 86400,
'tile_title': 'Points by user'
}
}
tile_config['tile_options']['sscs'] = tile_config['series_spec_list'][
1]
tile2 = Tile.insert(rd.owner_id, rd.report.report_id, rd.dashboard_id,
tile_config)
layouts.place_tile(tile2)
d = [
OrderedDict([('user_name', 'robert'), ('is_active', True),
('points', 128)]),
OrderedDict([('user_name', 'monique2'), ('is_active', True),
('points', 210)]),
OrderedDict([('user_name', 'monique3'), ('is_active', True),
('points', 210)]),
OrderedDict([('user_name', 'monique4'), ('is_active', True),
('points', 210)]),
OrderedDict([('user_name', 'robert2'), ('is_active', True),
('points', 210)]),
]
res = rd.report.process_input(json.dumps(d))
tile2 = rd.tile_from_layout(1, 2)
self.assertEqual(7, len(tile2.series_specs()))
self.assertEqual(SeriesSpec(2, 0, dict(op='eq', args=['robert2'])),
tile2.series_specs()[-1])
d = [
OrderedDict([('user_name', 'monique4'), ('is_active', True),
('points', 128)])
]
res = rd.report.process_input(json.dumps(d), tags=['ip:192.168.1.1'])
tile2 = rd.tile_from_layout(0, 2)
self.assertEqual(7, len(tile2.series_specs()))
tile = rd.tile_from_layout(1, 2)
self.assertEqual(6, len(tile.series_specs()))
self.assertEqual(SeriesSpec(2, 0, dict(op='eq', args=['monique4'])),
tile.series_specs()[-1])
def test_series_def_select_or_insert(self):
ss = SeriesSpec(2, 0, dict(op='eq', args=['monique']))
ss.promote_colnos_to_headers(report_data('points').instances[-1])
sd_id = dataseries.SeriesDef.select_id_or_insert(
report_data('points').report.report_id, [], ss)
sd = dataseries.SeriesDef.select(
report_data('points').report.report_id, [], sd_id)
self.assertEqual([], sd.tags)
sd2_id = dataseries.SeriesDef.select_id_or_insert(
report_data('points').report.report_id, [], ss)
sd2 = dataseries.SeriesDef.select(
report_data('points').report.report_id, [], sd2_id)
self.assertEqual(sd, sd2)
return sd
def test_sscs_virtual_column(self):
owner_id = uuid.uuid1()
od = dashboards.OwnerDashboards(owner_id)
dashboard_id = od.dashboards[0].dashboard_id
r = Report.insert(owner_id, 'r')
tile_config = {
'tw_type': 'Single',
'series_spec_list': [
SeriesSpec(0, -1, dict(op='eq', args=['0'])),
],
'tile_options': {}
}
tile_config['tile_options']['sscs'] = tile_config['series_spec_list'][
0]
tile = Tile.insert(owner_id, r.report_id, dashboard_id, tile_config)
layouts.place_tile(tile)
for inp in ['0', '1', '2\n3', '3\n4\n5\n']:
res = r.process_input(inp)
tile = Tile.select(
dashboard_id,
Layout.select(owner_id, dashboard_id).layout_dict.keys()[0])
self.assertEqual(3, len(tile.series_specs()))
return tile, r
def main():
owner_id = uuid.uuid4()
report = Report.select_or_insert(owner_id, 'simple_report')
res = report.process_input('1 2 3')
assert res.report_instance
owner_dashboards = OwnerDashboards(
owner_id, insert_if_no_dashboards='Default Dashboard')
assert owner_dashboards.dashboards
tile_config = {
'series_spec_list': [SeriesSpec(0, -1, {
'op': 'eq',
'args': ['0']
})],
}
tile = Tile.insert(owner_id, report.report_id,
owner_dashboards.dashboards[0].dashboard_id,
tile_config)
assert tile
assert tile.get_tile_data()
print 'Successfully created a dashboard with a tile'
owner_dashboards.dashboards[0].delete()
def test_hashing_ss(self):
ss_list = [
SeriesSpec(i, 0, {
'op': 'eq',
'args': [str(i)]
}) for i in range(10)
]
for i, ss in enumerate(ss_list):
ss.set_name('name_%d' % i)
d = {ss: i for i, ss in enumerate(ss_list)}
for i, ss in enumerate(ss_list):
self.assertEqual(i, d[ss])
def test_get_cell_nopromote(self):
rd = report_data('points')
ss = SeriesSpec(2, 0, dict(op='eq', args=['monique']))
self.assertEqual(2, ss.actual_data_colno(rd.instances[0]))
self.assertEqual(0, ss.actual_filtering_colno(rd.instances[0]))
self.assertEqual(210, ss.get_cell(rd.instances[0]).value)
self.assertEqual(220, ss.get_cell(rd.instances[1]).value)
self.assertEqual(265, ss.get_cell(rd.instances[2]).value)
self.assertIsNone(ss.get_cell(rd.instances[3]))
def main():
vars = tutorial.main()
owner_id = vars['owner_id']
owner_dashboards = vars['owner_dashboards']
dashboard = vars['dashboard']
SECTION('tags')
cpu_report = Report.select_or_insert(owner_id, 'cpu_usage')
metrics = [
('user', 92.3),
('system', 3.4),
('io', 4.4),
]
cpu_report.process_input(json.dumps(metrics),
tags=['ip:192.168.1.18', 'warning'])
tile_config_1 = {
'tags': ['ip:192.168.1.18'],
'series_spec_list': [
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['user']
}),
],
}
tile_1 = Tile.insert(owner_id, cpu_report.report_id,
dashboard.dashboard_id, tile_config_1)
tile_config_2 = {
'tags': ['ip:192.168.1.18', 'warning'],
'series_spec_list': [
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['user']
}),
],
}
tile_2 = Tile.insert(owner_id, cpu_report.report_id,
dashboard.dashboard_id, tile_config_2)
def test_name_virtual(self):
ri = report_data('points').instances[-1]
ss = SeriesSpec(2, -1, dict(op='eq', args=['1']))
self.assertEqual('col. 2 (1)', ss.name())
ss.promote_colnos_to_headers(ri)
self.assertEqual('points (1)', ss.name())
def test_custom_types(self):
d = {
'id': uuid.uuid1(),
'id2': uuid.uuid4(),
'dt': datetime.datetime.utcnow(),
'da': datetime.datetime.utcnow(),
'ss': SeriesSpec(2, 0, dict(op='eq', args=['monique'])),
}
self.assertEqual(d, serialize.json_loads(serialize.mjson(d)))
dt = datetime.datetime.utcnow()
self.assertEqual(util.datetime_from_date(dt.date()),
serialize.json_loads(serialize.mjson(dt.date())))
ext_d = json.loads(
serialize.json_dumps_external(util.dictwithout(d, 'ss')))
self.assertEqual(d['id2'].hex, ext_d['id2'])
def test_get_cell_promote(self):
rd = report_data('points')
ss = SeriesSpec(2, 0, dict(op='eq', args=['monique']))
ss.promote_colnos_to_headers(rd.instances[0])
self.assertEqual(2, ss.actual_data_colno(rd.instances[0]))
self.assertEqual(0, ss.actual_filtering_colno(rd.instances[0]))
self.assertEqual(210, ss.get_cell(rd.instances[0]).value)
self.assertEqual(220, ss.get_cell(rd.instances[1]).value)
self.assertEqual(265, ss.get_cell(rd.instances[2]).value)
self.assertIsNone(ss.get_cell(rd.instances[3]))
rep2 = reports.Report.insert(
report_data('points').owner_id, 'points_colchange')
res2 = rep2.process_input(
json.dumps([
dict(points=300, user_name='john'),
dict(points=400, user_name='monique'),
]))
self.assertEqual(0, ss.actual_data_colno(res2.report_instance))
self.assertEqual(1, ss.actual_filtering_colno(res2.report_instance))
self.assertEqual(400, ss.get_cell(res2.report_instance).value)
ss = SeriesSpec(2, 0, dict(op='eq', args=['monique']))
self.assertIsNone(ss.get_cell(res2.report_instance))
def test_delete_with_tiles(self):
owner_id = uuid.uuid1()
r1 = Report.insert(owner_id, 'r1')
r1.process_input('1')
r2 = Report.insert(owner_id, 'r2')
r2.process_input('2')
r3 = Report.insert(owner_id, 'r3')
r3.process_input('3')
tile_config = {
'series_spec_list': [SeriesSpec(0, -1, {
'op': 'eq',
'args': '0'
})],
}
od = OwnerDashboards(owner_id)
od.insert_dashboard('Second')
od.insert_dashboard('Third')
tile1_1 = Tile.insert(owner_id, r1.report_id,
od.dashboards[0].dashboard_id, tile_config)
assert tile1_1.get_tile_data()['series_data']
tile2_1 = Tile.insert(owner_id, r2.report_id,
od.dashboards[1].dashboard_id, tile_config)
assert tile2_1.get_tile_data()['series_data']
tile3_1 = Tile.insert(owner_id, r3.report_id,
od.dashboards[2].dashboard_id, tile_config)
assert tile3_1.get_tile_data()['series_data']
layouts.place_tile(tile1_1)
layouts.place_tile(tile2_1)
layouts.place_tile(tile3_1)
r2.delete()
reps = reports.fetch_reports_by_name(owner_id, '')
self.assertEqual([r1, r3], reps)
self.assertEqual(
1,
len(
layouts.Layout.select(
owner_id, od.dashboards[0].dashboard_id).layout_dict))
self.assertEqual(
0,
len(
layouts.Layout.select(
owner_id, od.dashboards[1].dashboard_id).layout_dict))
self.assertEqual(
1,
len(
layouts.Layout.select(
owner_id, od.dashboards[2].dashboard_id).layout_dict))
tile1_2 = Tile.insert(owner_id, r1.report_id,
od.dashboards[0].dashboard_id, tile_config)
tile1_3 = Tile.insert(owner_id, r1.report_id,
od.dashboards[1].dashboard_id, tile_config)
tile1_4 = Tile.insert(owner_id, r1.report_id,
od.dashboards[1].dashboard_id, tile_config)
tile1_5 = Tile.insert(owner_id, r1.report_id,
od.dashboards[2].dashboard_id, tile_config)
layouts.place_tile(tile1_2)
layouts.place_tile(tile1_3)
layouts.place_tile(tile1_4)
layouts.place_tile(tile1_5)
r1.delete()
self.assertEqual(
0,
len(
layouts.Layout.select(
owner_id, od.dashboards[0].dashboard_id).layout_dict))
self.assertEqual(
0,
len(
layouts.Layout.select(
owner_id, od.dashboards[1].dashboard_id).layout_dict))
self.assertEqual(
1,
len(
layouts.Layout.select(
owner_id, od.dashboards[2].dashboard_id).layout_dict))
reps = reports.fetch_reports_by_name(owner_id, '')
self.assertEqual([r3], reps)
def main():
SECTION('Creating a report and report instances')
import uuid
from mqe.reports import Report
owner_id = uuid.uuid4()
simple_report = Report.insert(owner_id, 'simple')
res = simple_report.process_input('10 20')
print res.report_instance.table
points_report = Report.insert(owner_id, 'points')
input = """\
user_name is_active points
john true 128
monique true 210
"""
res = points_report.process_input(input)
print res.report_instance.table
SECTION('Creating a dashboard and a tile')
from mqe.dashboards import OwnerDashboards
owner_dashboards = OwnerDashboards(owner_id)
dashboard = owner_dashboards.insert_dashboard('My Dashboard')
from mqe.dataseries import SeriesSpec
tile_config = {
'tw_type': 'Range',
'series_spec_list': [
SeriesSpec(2, 0, {'op': 'eq', 'args': ['john']}),
SeriesSpec(2, 0, {'op': 'eq', 'args': ['monique']}),
],
'tile_options': {
'seconds_back': 86400,
'tile_title': 'Points by user',
}
}
from mqe.tiles import Tile
tile = Tile.insert(owner_id, points_report.report_id, dashboard.dashboard_id, tile_config)
pprint(tile.get_tile_data())
SECTION('Placing a tile in a dashboard layout')
from mqe.layouts import place_tile
res = place_tile(tile)
if not res:
raise ValueError('Placing the tile unsuccessful')
from mqe.layouts import Layout
layout = Layout.select(owner_id, dashboard.dashboard_id)
pprint(layout.layout_dict)
def render_dashboard(owner_id, dashboard):
print 'Rendering dashboard %r' % dashboard.dashboard_name
layout = Layout.select(owner_id, dashboard.dashboard_id)
for tile, visual_options in layout.tile_dict.items():
tile_data = tile.get_tile_data()
print 'Rendering tile %r at position %s/%s' % (
tile_data['generated_tile_title'], visual_options['x'], visual_options['y'])
# render tile_data['series_data']
render_dashboard(owner_id, dashboard)
return locals()
def test_guess_series_spec(self):
ss = guess_series_spec(
report_data('points').report,
report_data('points').instances[0], 2, 2)
ss_expected = SeriesSpec(2, 0, dict(op='eq', args=['monique']))
ss_expected.promote_colnos_to_headers(
report_data('points').instances[0])
self.series_specs_equal(ss_expected, ss)
ss = guess_series_spec(
report_data('points').report,
report_data('points').instances[0], 2, 0)
ss_expected = SeriesSpec(0, -1, dict(op='eq', args=['2']))
ss_expected.promote_colnos_to_headers(
report_data('points').instances[0])
self.series_specs_equal(ss_expected, ss)
cd = CustomData([10, 20])
ss = guess_series_spec(cd.report, cd.instances[-1], 0, 0)
ss_expected = SeriesSpec(0, -1, dict(op='eq', args=['0']))
ss_expected.promote_colnos_to_headers(cd.instances[-1])
self.series_specs_equal(ss_expected, ss)
cd = CustomData([[1, 2, 3], [4, 5, 6]])
ss = guess_series_spec(cd.report, cd.instances[-1], 2, 0)
ss_expected = SeriesSpec(0, -1, dict(op='eq', args=['2']))
ss_expected.promote_colnos_to_headers(cd.instances[-1])
self.series_specs_equal(ss_expected, ss)
cd = CustomData([[["aaa", 10], ["bbb", 20]]])
ss = guess_series_spec(cd.report, cd.instances[-1], 1, 1)
ss_expected = SeriesSpec(1, 0, dict(op='eq', args=['bbb']))
ss_expected.promote_colnos_to_headers(cd.instances[-1])
self.series_specs_equal(ss_expected, ss)
cd = CustomData([[["aaa", 10]]])
ss = guess_series_spec(cd.report, cd.instances[-1], 0, 1)
ss_expected = SeriesSpec(1, 0, dict(op='eq', args=['aaa']))
ss_expected.promote_colnos_to_headers(cd.instances[-1])
self.series_specs_equal(ss_expected, ss)
def test_tweak_computed_name_single_column(self):
owner_id = uuid.uuid4()
rep = reports.Report.insert(owner_id, 'col_report')
ri = rep.process_input('1\n2').report_instance
ss = SeriesSpec(0, -1, {'op': 'eq', 'args': ['0']})
self.assertEqual('col. 0 (0)', ss.name())
ss.tweak_computed_name(ri)
self.assertEqual('0', ss.name())
ss = SeriesSpec(0, -1, {'op': 'eq', 'args': ['1']})
self.assertEqual('col. 0 (1)', ss.name())
ss.tweak_computed_name(ri)
self.assertEqual('1', ss.name())
def test_tweak_computed_name_headerless(self):
owner_id = uuid.uuid4()
rep = reports.Report.insert(owner_id, 'num_report')
ri = rep.process_input('23').report_instance
ss = SeriesSpec(0, -1, {'op': 'eq', 'args': ['0']})
self.assertEqual('col. 0 (0)', ss.name())
ss.tweak_computed_name(ri)
self.assertEqual('value', ss.name())
ri = rep.process_input('1 2\n3 4\n5 6').report_instance
ss = SeriesSpec(0, -1, {'op': 'eq', 'args': ['0']})
self.assertEqual('col. 0 (0)', ss.name())
ss.tweak_computed_name(ri)
self.assertEqual('col. 0 (0)', ss.name())
ss = SeriesSpec(0, -1, {'op': 'eq', 'args': ['1']})
self.assertEqual('col. 0 (1)', ss.name())
ss.tweak_computed_name(ri)
self.assertEqual('col. 0 (1)', ss.name())
def main():
vars = tutorial.main()
owner_id = vars['owner_id']
owner_dashboards = vars['owner_dashboards']
dashboard = vars['dashboard']
SECTION('Using tags for identifying entities')
from mqe.reports import Report
cpu_report = Report.select_or_insert(owner_id, 'cpu_usage')
metrics = [
('user', 42.3),
('system', 13.4),
('io', 8.4),
]
cpu_report.process_input(json.dumps(metrics), tags=['ip:192.168.1.18'])
SECTION('Creating a master tile')
from mqe.dataseries import SeriesSpec
from mqe.tiles import Tile
from mqe.layouts import place_tile, Layout, replace_tiles
dashboard = owner_dashboards.insert_dashboard('CPU')
master_tile_config = {
'tw_type':
'Range',
'tags': ['ip:192.168.1.18'],
'series_spec_list': [
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['user']
}),
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['system']
}),
],
'tile_options': {
'tile_title': 'CPU usage',
'tpcreator_uispec': [{
'tag': 'ip:192.168.1.18',
'prefix': 'ip:'
}]
}
}
master_tile = Tile.insert(owner_id, cpu_report.report_id,
dashboard.dashboard_id, master_tile_config)
print place_tile(master_tile)
SECTION('Creating tiles from a master tile')
metrics = json.dumps(metrics)
cpu_report.process_input(metrics, tags=['ip:192.168.1.30'])
cpu_report.process_input(metrics, tags=['ip:192.168.2.51'])
cpu_report.process_input(metrics, tags=['ip:192.168.2.51'])
layout = Layout.select(owner_id, dashboard.dashboard_id)
for tile in layout.tile_dict:
print tile.tags
SECTION('Synchronizing options of tpcreated tiles')
new_master_tile_config = {
'tw_type':
'Range',
'tags': ['ip:192.168.1.18'],
'series_spec_list': [
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['user']
}),
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['system']
}),
SeriesSpec(1, 0, {
'op': 'eq',
'args': ['io']
}),
],
'tile_options': {
'tile_title': 'CPU usage',
'tpcreator_uispec': [{
'tag': 'ip:192.168.1.18',
'prefix': 'ip:'
}]
}
}
new_master_tile = Tile.insert(owner_id, cpu_report.report_id,
dashboard.dashboard_id,
new_master_tile_config)
assert replace_tiles({master_tile: new_master_tile}, for_layout_id=None)
layout = Layout.select(owner_id, dashboard.dashboard_id)
for tile in layout.tile_dict:
print len(tile.get_tile_data()['series_data'])
SECTION('Expiring tiles and promoting new masters')
from mqe.tpcreator import make_master_from_tpcreated
old_master = [tile for tile in layout.tile_dict
if tile.is_master_tile()][0]
new_chosen_master = [
tile for tile in layout.tile_dict if tile.tags == ['ip:192.168.2.51']
][0]
assert not new_chosen_master.is_master_tile()
new_master = make_master_from_tpcreated(old_master, new_chosen_master)
res = replace_tiles({
old_master: new_master,
new_chosen_master: None
},
for_layout_id=None)
print 'replaced %d tiles' % len(res.tile_replacement)
layout = Layout.select(owner_id, dashboard.dashboard_id)
tile = [
tile for tile in layout.tile_dict if tile.tags == ['ip:192.168.2.51']
][0]
print tile.is_master_tile()
def main():
vars = tutorial.main()
points_report = vars['points_report']
owner_id = vars['owner_id']
owner_dashboards = vars['owner_dashboards']
dashboard = vars['dashboard']
SECTION('Tile_config and tile_options')
from mqe.dataseries import SeriesSpec
from mqe.tiles import Tile
tile_config = {
'series_spec_list': [
SeriesSpec(2, 0, {
'op': 'eq',
'args': ['john']
}),
SeriesSpec(2, 0, {
'op': 'eq',
'args': ['monique']
}),
],
'tile_options': {
'tile_title': 'Points by user',
}
}
tile = Tile.insert(owner_id, points_report.report_id,
dashboard.dashboard_id, tile_config)
pprint(tile.tile_options)
tile_options2 = tile.tile_options.copy()
tile_options2['owner_id'] = uuid.uuid4()
tile2 = Tile.insert_with_tile_options(dashboard.dashboard_id,
tile_options2)
SECTION('Updating tile\'s config')
from mqe.layouts import Layout, replace_tiles
layout = Layout.select(owner_id, dashboard.dashboard_id)
tile = layout.tile_dict.keys()[0]
tile_config = tile.get_tile_config()
tile_config['tile_options']['seconds_back'] = 3600
repl_tile = tile.insert_similar(tile_config)
replace_tiles({tile: repl_tile}, for_layout_id=layout.layout_id)
SECTION('Formatting tile data - tilewidgets and drawers')
tile_config = {
'tw_type':
'Range',
'series_spec_list': [
SeriesSpec(2, 0, {
'op': 'eq',
'args': ['john']
}),
SeriesSpec(2, 0, {
'op': 'eq',
'args': ['monique']
}),
],
'tile_options': {
'tile_title': 'Points by user',
'drawer_type': 'ChartRangeDrawer',
'colors': ['red', 'blue'],
'seconds_back': 3600,
}
}
SECTION('Updating tile data')
tile_data = tile.get_tile_data()
input = """\
user_name is_active points
john true 144
monique true 241
"""
res = points_report.process_input(input)
last_report_instance_id = tile_data['series_data'][0]['data_points'][
-1].rid
new_tile_data = tile.get_new_tile_data(last_report_instance_id)
SECTION('Managing colors')
from mqe.dataseries import update_default_options
tile_config = {
'series_spec_list': [
SeriesSpec(2, 0, {
'op': 'eq',
'args': ['john']
}),
SeriesSpec(2, 0, {
'op': 'eq',
'args': ['monique']
}),
],
'tile_options': {
'colors': ['blue', 'red'],
}
}
tile = Tile.insert(owner_id, points_report.report_id,
dashboard.dashboard_id, tile_config)
print tile.get_tile_data()['combined_colors']
update_default_options(tile)
tile_config_2 = {
'series_spec_list': [
SeriesSpec(2, 0, {
'op': 'eq',
'args': ['monique']
}),
],
}
tile_2 = Tile.insert(owner_id, points_report.report_id,
dashboard.dashboard_id, tile_config_2)
print tile_2.get_tile_data()['combined_colors']
SECTION('Data series names')
series_spec = SeriesSpec(2, 0, {'op': 'eq', 'args': ['monique']})
series_spec.set_name("monique's points")
tile_config = {'series_spec_list': [series_spec]}
tile = Tile.insert(owner_id, points_report.report_id,
dashboard.dashboard_id, tile_config)
print tile.get_tile_data()['series_data'][0]['name']
SECTION('Creating custom tilewidgets and drawers')
from mqe.tilewidgets import register_drawer_class, Drawer
@register_drawer_class
class MaxNumberDrawer(Drawer):
drawer_type = 'MaxNumberDrawer'
def process_tile_data(self, tile_data):
max_number = 0
for series_data in tile_data['series_data']:
for point in series_data['data_points']:
if int(point.value) > max_number:
max_number = int(point.value)
tile_data['max_number'] = max_number
tile_config = {
'series_spec_list': [
SeriesSpec(2, 0, {
'op': 'eq',
'args': ['john']
}),
SeriesSpec(2, 0, {
'op': 'eq',
'args': ['monique']
}),
],
'tile_options': {
'drawer_type': 'MaxNumberDrawer',
}
}
tile = Tile.insert(owner_id, points_report.report_id,
dashboard.dashboard_id, tile_config)
print tile.get_tile_data()['max_number']
def test_name(self):
ss = SeriesSpec(2, 0, dict(op='eq', args=['monique']))
self.assertEqual('monique', ss.name())
ss.set_name('xxx')
self.assertEqual('xxx', ss.name())
ss.params['static_name'] = 'yyy'
self.assertEqual('xxx', ss.name())
ss = SeriesSpec(2, 0, dict(op='eq', args=['monique']))
ss.params['static_name'] = 'yyy'
self.assertEqual('yyy', ss.name())
ss = SeriesSpec(2, 0, dict(op='eq', args=['monique']))
ss.set_name('xxx')
self.assertEqual('xxx', ss.name(True))
ss.set_name('')
self.assertEqual('monique', ss.name(True))
def main():
vars = tutorial.main()
points_report = vars['points_report']
tile = vars['tile']
owner_id = vars['owner_id']
owner_dashboards = vars['owner_dashboards']
SECTION('Auto-creating new data series')
input = """\
user_name is_active points
john true 128
monique true 210
alex true 12
"""
points_report.process_input(input)
series_names = [
series_data['name']
for series_data in tile.get_tile_data()['series_data']
]
print series_names
new_dashboard = owner_dashboards.insert_dashboard('Points')
tile_config = {
'tw_type':
'Range',
'series_spec_list': [
SeriesSpec(2, 0, {
'op': 'eq',
'args': ['john']
}),
SeriesSpec(2, 0, {
'op': 'eq',
'args': ['monique']
}),
],
'tile_options': {
'seconds_back': 86400,
'tile_title': 'Points by user',
'sscs': SeriesSpec(2, 0, {
'op': 'eq',
'args': ['john']
})
}
}
new_tile = Tile.insert(owner_id, points_report.report_id,
new_dashboard.dashboard_id, tile_config)
place_tile(new_tile)
input = """\
user_name is_active points
john true 133
monique true 220
alex true 18
andrew true 6
"""
points_report.process_input(input)
layout = Layout.select(owner_id, new_dashboard.dashboard_id)
tile_id = layout.layout_dict.keys()[0]
tile = Tile.select(new_dashboard.dashboard_id, tile_id)
series_names = [
series_data['name']
for series_data in tile.get_tile_data()['series_data']
]
print series_names
def test_tweak_computed_name(self):
owner_id = uuid.uuid4()
rep = reports.Report.insert(owner_id, 'json_report')
inst = [OrderedDict([('c1', 10), ('c2', 20)])]
ri = rep.process_input(json.dumps(inst)).report_instance
ss = SeriesSpec(1, -1, {'op': 'eq', 'args': ['1']})
ss.promote_colnos_to_headers(ri)
self.assertEqual('c2 (1)', ss.name())
ss.tweak_computed_name(ri)
self.assertEqual('c2', ss.name())
inst = [
OrderedDict([('c1', 10), ('c2', 20)]),
OrderedDict([('c1', 11), ('c2', 21)])
]
ri = rep.process_input(json.dumps(inst)).report_instance
ss2 = SeriesSpec(1, -1, {'op': 'eq', 'args': ['1']})
ss2.promote_colnos_to_headers(ri)
self.assertEqual('c2 (1)', ss2.name())
ss2.tweak_computed_name(ri)
self.assertEqual('c2 (1)', ss2.name())
inst = [OrderedDict([('c1', 'monique'), ('c2', 20)])]
ri = rep.process_input(json.dumps(inst)).report_instance
ss3 = SeriesSpec(1, 0, {'op': 'eq', 'args': ['monique']})
ss3.promote_colnos_to_headers(ri)
ss3.tweak_computed_name(ri)
self.assertEqual('monique', ss3.name())
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]
