def gchart(context, nodelist, type, dataset, **kwargs):
G = GChart(type, dataset, encoding=kwargs.pop('encoding', 'text'))
for node in nodelist:
if isinstance(node, TextNode):
for part in node.render(context).splitlines():
cmd, value = parse_cmd(part)
if cmd is None: continue
if cmd.startswith('axes'):
cmd = getattr(G.axes, cmd[5:])
else:
cmd = getattr(G, cmd)
cmd(*value.split())
if 'instance' in kwargs:
return G
return G.img(**kwargs)
def gchart(context, nodelist, type, dataset, **kwargs):
G = GChart(type, dataset, encoding=kwargs.pop('encoding','text'))
for node in nodelist:
if isinstance(node, TextNode):
for part in node.render(context).splitlines():
cmd,value = parse_cmd(part)
if cmd is None: continue
if cmd.startswith('axes'):
cmd = getattr(G.axes, cmd[5:])
else:
cmd = getattr(G, cmd)
cmd(*value.split())
if 'instance' in kwargs:
return G
return G.img(**kwargs)
def render_macro(self, req, name, content):
# XXX: This is a big security hole. Need to replace this with something that
# only accepts simple key/value pairs.
options = eval("dict(%s)" % content)
query = options.get('query', None)
ctype = options.get('type', None)
columns = options.get('columns', None)
if query is None or ctype is None:
raise ValueError("Chart 'type' and 'query' parameters are required")
for key in NON_API_KEYS:
if key in options:
del options[key]
datasets = {}
scales = {}
labels = {}
if columns is not None:
for idx, val in enumerate(columns):
if len(val) >= 2:
if val[1] == 'labels':
labels[idx] = []
elif val[1] in ('percentage', 'scaled'):
datasets[idx] = []
scales[idx] = (0,0)
db = self.env.get_db_cnx()
cursor = db.cursor()
cursor.execute(query)
col_count = 0
if columns is not None:
col_count = len(columns)
# Collect label, scale and dataset data
for row in cursor:
if not col_count:
col_count = len(row)
if columns is None:
columns = []
for idx in range(col_count):
columns.append((None, 'percentage'))
datasets[idx] = []
scales[idx] = (0,0)
elif len(columns) != col_count:
raise KeyError("Table has %d columns, but 'columns' parameter has %d items" % \
(col_count, len(columns),))
for idx, col in enumerate(row):
if idx in labels:
labels[idx].append(col)
elif idx in datasets:
try:
col_value = float(col)
except (TypeError, ValueError):
continue
datasets[idx].append(col_value)
scales[idx] = (min(scales[idx][0], col_value),
max(scales[idx][1], col_value),)
dense_dataset = []
dataset_to_idx = {}
idx_to_axis = {}
axis_to_idx = {}
axis_types = [] # x, x, y - in order
scaled_axes = {} # idx -> min/max for that scale
current_dataset = 0
current_axis = 0
for idx, col in enumerate(columns):
if len(col) >= 1 and col[0]:
idx_to_axis[idx] = current_axis
axis_to_idx[current_axis] = idx
axis_types.append(col[0])
current_axis += 1
if len(col) >= 2 and col[1] == 'scaled':
scale_min = len(col) >= 3 and col[2] or scales[idx][0]
scale_max = len(col) >= 4 and col[3] or scales[idx][1]
scaled_axes[idx] = (scale_min, scale_max,)
if idx in datasets:
dataset_to_idx[current_dataset] = idx
dense_dataset.append(datasets[idx])
current_dataset += 1
# Add axes
if 'chxt' not in options:
if axis_types:
options['chxt'] = ','.join(axis_types)
# Add axis labels
if 'chxl' not in options:
label_data = []
for idx, values in sorted(labels.items()):
if idx not in idx_to_axis:
continue
label_data.append('%d:|%s' % (idx_to_axis[idx], '|'.join(values),))
if label_data:
options['chxl'] = '|'.join(label_data)
# Add scale range axes
if 'chxr' not in options:
range_triples = []
for idx, (scale_min, scale_max) in sorted(scaled_axes.items()):
if idx not in idx_to_axis:
continue
range_triples.append('%d,%.1f,%.1f' % (idx_to_axis[idx], scale_min, scale_max,))
if range_triples:
options['chxr'] = '|'.join(range_triples)
# Add data scaling
if 'chds' not in options and scaled_axes:
scale_data = []
for cnt in range(len(dense_dataset)):
idx = dataset_to_idx[cnt]
scale_item = ','
if idx in scaled_axes:
scale_min, scale_max = scaled_axes[idx]
scale_item = '%.1f,%.1f' % (scale_min, scale_max)
scale_data.append(scale_item)
if scale_data:
options['chds'] = ','.join(scale_data)
chart = GoogleChart(ctype=ctype, dataset=dense_dataset, **options)
return Markup(chart.img())
def tarp_subsidies(request):
estimated_subsidies = []
subsidy_rates = []
amounts_received = []
names = []
colors = []
for r in SubsidyRecord.objects.all():
estimated_subsidies.append(r.estimated_subsidy)
subsidy_rates.append(r.subsidy_rate)
amounts_received.append(r.amount_received)
names.append(r.name)
colors.append(r.color)
# reverse names (API wrapper bug?)
names.reverse()
# estimated subsidies chart
estimates_subsidies_normalized = _normalize_chart_range(
estimated_subsidies)
estimated_subsidies_chart = GChart('bhs',
estimates_subsidies_normalized.values())
estimated_subsidies_chart.size((500, 250))
estimated_subsidies_chart.color('|'.join(colors))
estimated_subsidies_chart.bar(18, 2, 0)
estimated_subsidies_chart.axes.type('xy')
estimated_subsidies_chart_xlabels = range(
0, (_get_scale_bound(estimated_subsidies) + 1), 5)
estimated_subsidies_chart_xlabels = map((lambda x: str(x)),
estimated_subsidies_chart_xlabels)
estimated_subsidies_chart.axes.label(
str('|'.join(estimated_subsidies_chart_xlabels)))
estimated_subsidies_chart.axes.label('|'.join(names))
estimated_subsidies_chart.axes.style('000000')
estimated_subsidies_chart.axes.style('000000')
i = 0
for x in estimated_subsidies:
marker_text = 't $%.1f' % x
estimated_subsidies_chart.marker(marker_text, '000000', 0, i, 10, -1)
i = i + 1
# subsidy rates chart
subsidy_rates_normalized = _normalize_chart_range(subsidy_rates)
subsidy_rate_chart = GChart('bhs', subsidy_rates_normalized.values())
subsidy_rate_chart.size((500, 250))
subsidy_rate_chart.color('|'.join(colors))
subsidy_rate_chart.bar(18, 2, 0)
subsidy_rate_chart.axes.type('xy')
subsidy_rate_chart_xlabels = range(0,
(_get_scale_bound(subsidy_rates) + 1),
10)
subsidy_rate_chart_xlabels = map((lambda x: str(x)),
subsidy_rate_chart_xlabels)
subsidy_rate_chart.axes.label(str('|'.join(subsidy_rate_chart_xlabels)))
subsidy_rate_chart.axes.label('|'.join(names))
subsidy_rate_chart.axes.style('000000')
subsidy_rate_chart.axes.style('000000')
i = 0
for x in subsidy_rates:
marker_text = 't %d%%' % x
subsidy_rate_chart.marker(marker_text, '000000', 0, i, 10, -1)
i = i + 1
# amounts received chart
amounts_received_normalized = _normalize_chart_range(amounts_received)
amounts_received_chart = GChart('bhs',
amounts_received_normalized.values())
amounts_received_chart.size((500, 250))
amounts_received_chart.color('|'.join(colors))
amounts_received_chart.bar(18, 2, 0)
amounts_received_chart.axes.type('xy')
amounts_received_chart_xlabels = range(
0, (_get_scale_bound(amounts_received) + 1), 10)
amounts_received_chart_xlabels = map((lambda x: str(x)),
amounts_received_chart_xlabels)
amounts_received_chart.axes.label(
str('|'.join(amounts_received_chart_xlabels)))
amounts_received_chart.axes.label('|'.join(names))
amounts_received_chart.axes.style('000000')
amounts_received_chart.axes.style('000000')
i = 0
for x in amounts_received:
marker_text = 't $%.1f' % x
amounts_received_chart.marker(marker_text, '000000', 0, i, 10, -1)
i = i + 1
return render_to_response(
'bailout/tarp_subsidy_table.html', {
'estimated_subsidies_chart': estimated_subsidies_chart.img(),
'subsidy_rate_chart': subsidy_rate_chart.img(),
'amounts_received_chart': amounts_received_chart.img(),
'estimated_subsidies': estimated_subsidies,
'subsidy_rates': subsidy_rates,
'amounts_received': amounts_received,
'names': ' '.join(names),
'colors': '|'.join(colors)
},
context_instance=RequestContext(request))
