def report(request):
# data report
if Invoice.objects.all().count() == 0:
return redirect("/openbook")
min_year = Invoice.objects.order_by("date")[0].date.year
max_year = Invoice.objects.order_by("-date")[0].date.year
report = []
for year in range(min_year,max_year+1):
year_report = []
for month in range(1,13):
total = get_total(year, month)
year_report.append(total)
s = sum(year_report)
tax = round((s * (0.13 / 1.13)), 2)
year_report.append(tax)
year_report.append(s)
year_report.insert(0, year)
report.append(year_report)
# graphical data year report
year_total_data = [i[-1] for i in report]
max_y = max(year_total_data)
min_y = min(year_total_data)
gr = SimpleLineChart(800, 300, y_range=[0,max_y])
gr.add_data(year_total_data)
gr.set_grid(0, 25, 5, 5)
left_axis = range(min_y, max_y + 1, (max_y/10))
left_axis[0] = ''
gr.set_axis_labels(Axis.LEFT, left_axis)
gr.set_axis_labels(Axis.BOTTOM, \
[str(i) for i in range(min_year, max_year+1)])
# yearly report
gs = []
months = ["JAN", "FEB", "MAR", "APR", "MAY", "JUN", "JUL", "AUG", "SEP", "OCT", "NOV", "DEC"]
for data in report:
max_y = max(data[1:-2]) # excluding the first and the last 2 entries
g = SimpleLineChart(800, 300, y_range=[0, max_y])
g.add_data(data[1:-2]) # excluding the frist and the last 2 entries
g.set_grid(0, 25, 5, 5)
left_axis = range(0, max_y + 1, (max_y/10))
left_axis[0] = ''
g.set_axis_labels(Axis.LEFT, left_axis)
g.set_axis_labels(Axis.BOTTOM, \
months)
gs.append((data[0], g.get_url()))
gs.reverse()
grurl = gr.get_url()
if max_year == min_year:
grurl = None
return render_to_response(
"admin/invoice/report.html",
{'report' : report, 'gr': grurl, 'gs':gs},
RequestContext(request, {}),
)
def lineGraphFeed(feed):
name = feed.getAttribute("name")
observations = feed.getElementsByTagName("observation")
print " Feed %s has %d observations" % (name,len(observations))
data = []
for obs in observations:
value = int(obs.getAttribute("value"))
#print " val:%s (%s)" % (value, type(value))
data.insert(0,value/10)
#data.reverse # remeber the feed is reversed
print "Max Data: %s" % max(data)
max_y = int(math.ceil(max(data)/100.0))*100
print "Max_y : %s" % max_y
chart = SimpleLineChart(180, 120, y_range=[0, max_y])
chart.add_data(data)
lftAxisMax = max_y/100;
print "lftAxisMax %s"%lftAxisMax
#left_axis = range(0, lftAxisMax,(lftAxisMax/4.0))
left_axis = []
right_axis = []
for i in range(0,4+1):
kw = (i*lftAxisMax/4.0)
left_axis.append(kw)
right_axis.append(kw*24)
left_axis[0] = 'kW' # remove the first label
right_axis[0] = 'kWh/d' # remove the first label
chart.set_axis_labels(Axis.LEFT, left_axis)
#chart.set_axis_labels(Axis.RIGHT, right_axis)
chart.set_title(name)
# facebook colors
chart.set_title_style('7f93bc',16)
#chart.set_colours(['7f93bc'])
chart.set_colours(['3b5998']) #darker blue
#Colors
colors=False
if (colors):
# Set the line colour to ...
chart.set_colours(['FFFFFF'])
# 0 here is the axis index ? 0 works for now
chart.set_title_style('FFFFFF',16)
chart.set_axis_style(0,'FFFFFF')
chart.set_axis_style(1,'FFFFFF')
chart.fill_linear_gradient(Chart.BACKGROUND,90,'000000',0.9,'007700',0.1)
print chart.get_url()
chart.download('%s-line.png'%name)
def velocity_chart(self):
graph_width = 600
graph_height = 300
x_max = self.total_iterations
y_max = max(max(self.estimate_stories_data()),
max(self.estimate_tasks_data()), max(self.work_data()))
chart = SimpleLineChart(graph_width,
graph_height,
x_range=(1, x_max + 1),
y_range=(0, y_max + 1))
chart.add_data(self.estimate_stories_data())
chart.add_data(self.estimate_tasks_data())
chart.add_data(self.work_data())
chart.set_grid(0, 100.0 / y_max + 1, 5, 5)
chart.set_colours(['FF0000', '00FF00', '0000FF'])
chart.set_legend(
[_('rough story estimates'),
_('task estimates'),
_('worked')])
chart.set_legend_position('b')
chart.set_axis_labels(Axis.LEFT, ['', '', _('days')])
chart.set_axis_labels(Axis.BOTTOM, list(range(1, x_max + 1)))
chart.set_axis_range(Axis.LEFT, 0, y_max + 1)
return chart.get_url(data_class=ExtendedData)
def getLineGraph(data,line1color,line2color):
# Set the vertical range based on data values
tweets = [d[0] for d in data]
retweets = [d[1] for d in data]
ratio = [str(int(d[1]/d[0]*100))+'%' for d in data]
hours = [d[2] for d in data]
mx = max(tweets)
mn = min(retweets)
buffer = (mx - mn)/100 # average retweets have consitently been less
min_y = mn - buffer
max_y = mx + buffer
# Chart size of 750x400 pixels and specifying the range for the Y axis
chart = SimpleLineChart(750, 400, y_range=[min_y, max_y])
chart.set_legend(['Tweets','Retweets'])
chart.set_legend_position('t')
# Add the chart data
chart.add_data(tweets)
chart.add_data(retweets)
# Set the line colour to blue
chart.set_colours([line1color,line2color])
# Set the horizontal dotted lines
chart.set_grid(0, 25, 5, 5)
#set left axis to values range
left_axis = range(min_y, max_y, (max_y-min_y)/10)
chart.set_axis_labels(Axis.BOTTOM, hours)
chart.set_axis_labels(Axis.BOTTOM, ratio)
chart.set_axis_labels(Axis.LEFT, left_axis)
return chart.get_url()
def get(self):
list = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep']
list2 = []
for title in list:
list2.append(int(getdata(title, 'funds').custom['amount'].text))
max_y = 10000
chart = SimpleLineChart(200, 125, y_range=[0, max_y])
chart.add_data([2000, 3000, 5000, 1200, 5000, 4000, 1000, 3000, 5900])
# Set the line colour to blue
chart.set_colours(['0000FF'])
# Set the vertical stripes
chart.fill_linear_stripes(Chart.CHART, 0, 'CCCCCC', 0.2, 'FFFFFF', 0.2)
# Set the horizontal dotted lines
chart.set_grid(0, 25, 5, 5)
# The Y axis labels contains 0 to 100 skipping every 25, but remove the
# first number because it's obvious and gets in the way of the first X
# label.
left_axis = range(0, max_y + 1, 25)
left_axis[0] = ''
chart.set_axis_labels(Axis.LEFT, left_axis)
# X axis labels
chart.set_axis_labels(Axis.BOTTOM, list)
url2 = chart.get_url()
self.response.out.write(
template.render('template/donate.html', {
'url2': url2,
}))
def get_pace_chart_url(self, width, height):
if len(self.positions()) == 0:
return ''
pace = []
int_dist = []
s = 0
last_p = None
for p in self.positions():
if last_p != None:
ds = distance.distance((p.latitude, p.longitude), \
(last_p.latitude, last_p.longitude)).kilometers
s = s + int(ds * 1000)
dt = (p.time - last_p.time).seconds
if ds > 0:
pace.append(dt / ds)
int_dist.append(s)
last_p = p
int_pace = [int(p) for p in ema(pace, 20)]
min_pace = int(min(int_pace) * 0.95)
max_pace = int(max(int_pace) / 0.95)
mid_pace = (max_pace + min_pace) / 2
min_pace_str = '%02d:%02d' % (min_pace / 60, min_pace % 60)
mid_pace_str = '%02d:%02d' % (mid_pace / 60, mid_pace % 60)
max_pace_str = '%02d:%02d' % (max_pace / 60, max_pace % 60)
chart = SimpleLineChart(width, height, y_range = (min_pace, max_pace))
chart.add_data(int_pace)
chart.set_axis_labels(Axis.LEFT, [min_pace_str, mid_pace_str, max_pace_str])
return chart.get_url()
def getRollingAverageGraph(cursor, colName, rollingWindowDays, title=""):
sqlCMD = "SELECT pDate, %s from %s" %(colName, N.JOBS_SUMMARY_TABLENAME)
cursor.execute(sqlCMD)
results = cursor.fetchall()
beginWindowIndex = 0
endWindowIndex = 0
xData = []
yData = []
while endWindowIndex < len(results):
while endWindowIndex < len(results) and (results[endWindowIndex][0] - results[beginWindowIndex][0]).days <= rollingWindowDays:
endWindowIndex += 1
yData.append( sum(results[i][1] for i in xrange(beginWindowIndex, endWindowIndex, 1)) / float(endWindowIndex - beginWindowIndex))
xData.append(results[endWindowIndex-1][0])
beginWindowIndex = endWindowIndex
chart = SimpleLineChart(680, 400, y_range = (min(yData)-1, max(yData)+1))
chart.add_data(yData)
yLabels = range(0, int(max(yData)+1), 5)
yLabels[0] = ''
xLabels = [str(xData[-i]) for i in xrange(1, len(xData)-1, int(0.2*len(xData)))]
xLabels.reverse()
chart.set_axis_labels(Axis.LEFT, yLabels)
chart.set_axis_labels(Axis.BOTTOM, xLabels)
chart.set_title("Rolling %i-Day Average %s" % (rollingWindowDays, title))
imgbin = chart.download()
toReturn = cStringIO.StringIO(imgbin)
toReturn.seek(0)
return chart.get_url(), toReturn
def makeChartOfDay(data):
max_user = 150
chart = SimpleLineChart(400, 325, y_range=[0, max_user])
dataChart = []
for ore in range(24):
ore = str(ore)
if len(ore) == 1:
ore = '0'+ore
try:
dataChart.append(userList[data]['stats']['online'][ore])
except:
dataChart.append(0)
chart.add_data(dataChart)
chart.set_colours(['0000FF'])
left_axis = range(0, max_user + 1, 25)
left_axis[0] = ''
chart.set_axis_labels(Axis.LEFT, left_axis)
# chart.set_axis_labels(Axis.BOTTOM, \
# ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun'])
chart.set_axis_labels(Axis.BOTTOM, \
range(0, 24))
return chart.get_url()
def process (name, date):
newdate = date[8:10] + "_" + date[5:7] + "_" + date[0:4]
url = r"http://www.lloydsbankinggroup.com/media/excel/2010/%s_historic_data.xls" % newdate
print url
url = r"http://www.lloydsbankinggroup.com/media/excel/2010/04_06_10_historic_data.xls"
book = xlrd.open_workbook(file_contents=scrape(url))
sheet = book.sheet_by_name (name)
months=['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec']
data = []
i = 1
while i < 500:
try:
month = sheet.cell_value (i, 0)
year = sheet.cell_value (i, 1)
level = sheet.cell_value (i, 2)
except:
break
when= "%04d-%02d-01" % (int(year), months.index (month) + 1)
i = i + 1
data.append (level)
sqlite.save(unique_keys=["Date"], data={"Date":when, "Index":level})
chart = SimpleLineChart(500, 255, y_range=[0, 700])
chart.add_data (data)
metadata.save("chart", chart.get_url())
def group(request, group_id):
group = get_object_or_404(GroupedMessage, pk=group_id)
message_list = group.message_set.all()
obj = message_list.order_by('-id')[0]
if '__sentry__' in obj.data:
module, args, frames = obj.data['__sentry__']['exc']
obj.class_name = str(obj.class_name)
# We fake the exception class due to many issues with imports/builtins/etc
exc_type = type(obj.class_name, (Exception,), {})
exc_value = exc_type(obj.message)
exc_value.args = args
reporter = ImprovedExceptionReporter(obj.request, exc_type, exc_value, frames, obj.data['__sentry__'].get('template'))
traceback = mark_safe(reporter.get_traceback_html())
elif group.traceback:
traceback = mark_safe('<pre>%s</pre>' % (group.traceback,))
unique_urls = message_list.filter(url__isnull=False).values_list('url', 'logger', 'view', 'checksum').annotate(times_seen=Count('url')).values('url', 'times_seen').order_by('-times_seen')
unique_servers = message_list.filter(server_name__isnull=False).values_list('server_name', 'logger', 'view', 'checksum').annotate(times_seen=Count('server_name')).values('server_name', 'times_seen').order_by('-times_seen')
def iter_data(obj):
for k, v in obj.data.iteritems():
if k.startswith('_') or k in ['url']:
continue
yield k, v
json_data = iter_data(obj)
# TODO: this should be a template tag
engine = get_db_engine()
if SimpleLineChart and not engine.startswith('sqlite'):
today = datetime.datetime.now()
chart_qs = message_list\
.filter(datetime__gte=today - datetime.timedelta(hours=24))\
.extra(select={'hour': 'extract(hour from datetime)'}).values('hour')\
.annotate(num=Count('id')).values_list('hour', 'num')
rows = dict(chart_qs)
if rows:
max_y = max(rows.values())
else:
max_y = 1
chart = SimpleLineChart(300, 80, y_range=[0, max_y])
chart.add_data([max_y]*30)
chart.add_data([rows.get((today-datetime.timedelta(hours=d)).hour, 0) for d in range(0, 24)][::-1])
chart.add_data([0]*30)
chart.fill_solid(chart.BACKGROUND, 'eeeeee')
chart.add_fill_range('eeeeee', 0, 1)
chart.add_fill_range('e0ebff', 1, 2)
chart.set_colours(['eeeeee', '999999', 'eeeeee'])
chart.set_line_style(1, 1)
chart_url = chart.get_url()
return render_to_response('sentry/group/details.html', locals())
def get(self):
counters = tasks.Counter.all().fetch(10)
rows = [{'name':c.key().name(), 'count':c.count} for c in counters]
chart = SimpleLineChart(1000, 300)
for counter in counters:
query = counter.snapshots
query.order('-date')
snapshots = query.fetch(30)
counts = [s.count for s in snapshots]
dates = [s.date.strftime("%d/%m") for s in snapshots]
for i in xrange(len(counts) - 1):
counts[i] -= counts[i+1]
counts.reverse()
dates.reverse()
chart.add_data(counts[1:])
chart.set_axis_labels(pygooglechart.Axis.BOTTOM, dates[1:])
chart.set_axis_labels(pygooglechart.Axis.LEFT, range(0, chart.data_y_range()[1], 5))
hsv_colours = [(float(x) / 255, 1, 1) for x in range(0, 255, 255 / len(counters))]
rgb_colours = [colorsys.hsv_to_rgb(*x) for x in hsv_colours]
hex_colours = ['%02x%02x%02x' % (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)) for x in rgb_colours]
chart.set_colours(hex_colours)
chart.set_legend([c.key().name() for c in counters])
path = os.path.join(os.path.dirname(__file__), self.TEMPLATE)
self.response.out.write(template.render(path,
{ 'url': chart.get_url(),
'counters': rows }))
def get(self):
list = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep']
list2 = []
for title in list:
list2.append( int(getdata(title,'funds').custom['amount'].text))
max_y = 10000
chart = SimpleLineChart(200, 125, y_range=[0, max_y])
chart.add_data([2000,3000,5000,1200,5000,4000,1000,3000,5900])
# Set the line colour to blue
chart.set_colours(['0000FF'])
# Set the vertical stripes
chart.fill_linear_stripes(Chart.CHART, 0, 'CCCCCC', 0.2, 'FFFFFF', 0.2)
# Set the horizontal dotted lines
chart.set_grid(0, 25, 5, 5)
# The Y axis labels contains 0 to 100 skipping every 25, but remove the
# first number because it's obvious and gets in the way of the first X
# label.
left_axis = range(0, max_y + 1, 25)
left_axis[0] = ''
chart.set_axis_labels(Axis.LEFT, left_axis)
# X axis labels
chart.set_axis_labels(Axis.BOTTOM, list)
url2 = chart.get_url()
self.response.out.write(template.render('template/donate.html',{
'url2' :url2, }))
def gchart(data,
node,
check,
metric,
start=datetime.now() - timedelta(days=1),
end=datetime.now()):
d = []
ts = []
for p in data['metrics'][0]['data']:
d.append(float(p['avg']))
ts.append(p['ts'])
# Chart size of 200x125 pixels and specifying the range for the Y axis
max_y = int(max(d))
chart = SimpleLineChart(450, 250, y_range=[0, max_y])
chart.add_data(d)
left_axis = range(0, max_y + 1, max_y / 5)
left_axis[0] = ''
chart.set_axis_labels(Axis.LEFT, left_axis)
min_dt = datetime.fromtimestamp(min(ts))
max_dt = datetime.fromtimestamp(max(ts))
chart.set_axis_labels(Axis.BOTTOM, [str(min_dt), str(max_dt)])
title = '%s.%s.%s' % (node['name'], check['type'], metric)
chart.set_title(title)
return chart.get_url()
def show(request, isa_id):
isa = get_object_or_404(ISA, pk=isa_id)
isafunds = isa.isafund_set.all()
start_date = isa.created
end_date = date.today()
current_date = start_date
data = []
while current_date <= end_date:
value = 0
for isafund in isafunds:
try:
fundprice = isafund.fund.fundprice_set.get(date=current_date)
value += fundprice.price * isafund.quantity
except FundPrice.DoesNotExist:
pass
data.append(value)
current_date += timedelta(1)
chart = SimpleLineChart(500, 200, y_range=[min(data), max(data)])
chart.add_data(data)
chart.add_data([data[0], data[0]])
chart.set_colours(['0000FF', 'AAAAAA'])
chart.fill_solid('bg', 'DDDDFF')
chart.set_axis_labels(Axis.LEFT, [int(min(data)), int(max(data))])
chart.set_axis_labels(Axis.BOTTOM, [start_date, end_date])
url = chart.get_url()
return render_to_response('isas/show.html', {'isa': isa, 'chart_url': url})
def _partyline(self, party_results):
if self.request.GET.get('percentages') == 'true':
key = 'percentage'
else:
key = 'count'
maxcount = 0
allcounts = []
granularity = self.request.GET.get('granularity')
months = []
for party, results in party_results.iteritems():
counts = [x.get(key) for x in results['results']]
allcounts.append(counts)
if max(counts) > maxcount:
maxcount = max(counts)
if granularity == 'month':
months = [x['month'] for x in results['results']]
januaries = [x for x in months if x.endswith('01')]
january_indexes = [months.index(x) for x in januaries]
january_percentages = [int((x / float(len(months))) * 100) for x in january_indexes]
#times = [x.get(granularity) for x in results['results']]
width = int(self.request.GET.get('width', 575))
height = int(self.request.GET.get('height', 318))
chart = SimpleLineChart(width, height, y_range=(0, max(counts)))
chart.fill_solid('bg', '00000000') # Make the background transparent
chart.set_grid(0, 50, 2, 5) # Set gridlines
if granularity == 'month':
index = chart.set_axis_labels(Axis.BOTTOM, [x[:4] for x in januaries[::2]])
chart.set_axis_positions(index, [x for x in january_percentages[::2]])
if key == 'percentage':
label = '%.4f' % maxcount
else:
label = int(maxcount)
index = chart.set_axis_labels(Axis.LEFT, [label, ])
chart.set_axis_positions(index, [100, ])
for n, counts in enumerate(allcounts):
chart.add_data(counts)
chart.set_line_style(n, thickness=2) # Set line thickness
colors = {'R': 'bb3110', 'D': '295e72', }
chart_colors = []
chart_legend = []
for k in party_results.keys():
chart_colors.append(colors.get(k, '000000'))
chart_legend.append(k)
chart.legend_position = 'b'
chart.set_colours(chart_colors)
if self.request.GET.get('legend', 'true') != 'false':
chart.set_legend(chart_legend)
return chart.get_url()
def velocity_chart(self):
graph_width = 600
graph_height = 300
x_max = self.total_iterations
y_max = max(max(self.estimate_stories_data()),
max(self.estimate_tasks_data()),
max(self.work_data()))
chart = SimpleLineChart(graph_width, graph_height,
x_range=(1, x_max + 1), y_range=(0, y_max + 1))
chart.add_data(self.estimate_stories_data())
chart.add_data(self.estimate_tasks_data())
chart.add_data(self.work_data())
chart.set_grid(0, 100.0 / y_max + 1, 5, 5)
chart.set_colours(['FF0000', '00FF00', '0000FF'])
chart.set_legend([_('rough story estimates'),
_('task estimates'), _('worked')])
chart.set_legend_position('b')
chart.set_axis_labels(Axis.LEFT, ['', '', _('days')])
chart.set_axis_labels(Axis.BOTTOM, range(1, x_max + 1))
chart.set_axis_range(Axis.LEFT, 0, y_max + 1)
return chart.get_url(data_class=ExtendedData)
def printGoogleCharts(X, Y, title, min_y, max_y, output):
# Create a chart object of 750x400 pixels
chart = SimpleLineChart(750, 400)
# Add some data
chart.add_data(Y)
# Assign the labels to the pie data
# chart.set_axis_labels(Axis.BOTTOM, X)
chart.set_axis_labels(Axis.LEFT, range(int(min_y)-1, int(max_y)+1, 5))
chart.set_title(title)
# Print the chart URL
print chart.get_url()
# Download the chart
chart.download(output+".png")
def get_chart_url(series):
chart = SimpleLineChart(400, 200)
chart.set_legend([name for (name, _) in series])
chart.set_colours_within_series(colors[0:len(series)])
for (_, data) in series:
chart.add_data(data)
return chart.get_url()
def generate_freq_chart_url_from_qset(qset, sizex, sizey):
''' returns url for chart from given queryset '''
end_year = qset.order_by('-publication_date')[0].publication_date.year
start_year = qset.order_by('publication_date')[0].publication_date.year
#print "start {0}, end {1}".format(start_year, end_year)
year_range=range(start_year,end_year + 1)
month_range=range(1, 13)
count_rules = []
count_proprules = []
count_notices = []
count_presdocs = []
count_unknown = []
count_total = []
today = datetime.date.today()
for y in year_range:
start_date=datetime.date(y,1,1)
end_date=datetime.date(y,12,31)
year_qset = qset.filter(publication_date__range=(start_date, end_date))
count_rules.append(year_qset.filter(document_type='Rule').count())
count_proprules.append(year_qset.filter(document_type='Proposed Rule').count())
count_notices.append(year_qset.filter(document_type='Notice').count())
count_presdocs.append(year_qset.filter(document_type='Presidential Document').count())
count_unknown.append(year_qset.filter(document_type='Document of Unknown Type').count())
count_total.append(count_unknown[-1] + count_presdocs[-1] + count_rules[-1] + count_proprules[-1] + count_notices[-1])
#for i in [count_rules, count_proprules, count_notices, count_presdocs, count_unknown, count_total]:
#print i
# set up chart axis parameters
largest_y = max(count_total)
left_axis_step = int(pow(10, int(log10(largest_y))))
max_y = (int(largest_y / left_axis_step) * left_axis_step) + (left_axis_step * 2)
left_axis = range(0, max_y + left_axis_step, left_axis_step)
left_axis[0] = ""
bottom_axis = year_range
# generate chart url
chart = SimpleLineChart(sizex, sizey, y_range=[0, max_y])
chart.set_axis_labels(Axis.LEFT, left_axis)
chart.set_axis_labels(Axis.BOTTOM, bottom_axis)
chart.set_grid(0, max(10, int(left_axis_step / 10)), 5, 5)
chart.set_colours(['0000FF', '00FF00', 'FF0000', 'FFFF00', '00FFFF', 'aaaaaa'])
chart.set_legend(['Rules', 'Proposed Rules', 'Notices', 'Presidential Docs', 'Unknown', 'Total'])
chart.add_data(count_rules)
chart.add_data(count_proprules)
chart.add_data(count_notices)
chart.add_data(count_presdocs)
chart.add_data(count_unknown)
chart.add_data(count_total)
chart_url = chart.get_url()
return chart_url
def group_post_activity(request, group_slug):
group = get_object_or_404(BaseGroup, slug=group_slug)
postcount = []
replycount = []
allcount = []
listdate = []
thedate = date(date.today().year - 1, date.today().month, 1)
skip = False
while thedate.year != date.today().year or thedate.month != date.today(
).month:
if thedate.month == 12:
enddate = date(year=thedate.year + 1, month=1, day=1)
else:
enddate = date(year=thedate.year, month=thedate.month + 1, day=1)
posts = GroupTopic.objects.filter(parent_group=group,
created__range=(thedate,
enddate)).count()
#replies = ThreadedComment.objects.filter(content_object__parent_group=group,
# date_submitted__range=(thedate, enddate)).count()
replies = 0
postcount.append(posts)
replycount.append(replies)
allcount.append(posts + replies)
if not skip:
listdate.append(thedate.strftime("%B %y"))
else:
listdate.append("")
skip = not skip
thedate = enddate
postactivity = SimpleLineChart(
600,
450,
y_range=(min(min(postcount), min(replycount)),
max(max(postcount), max(replycount)) + 1))
postactivity.add_data(postcount)
postactivity.add_data(replycount)
postactivity.add_data(allcount)
yaxis = range(min(min(postcount), min(replycount)),
max(max(postcount), max(replycount)) + 1, 1)
if len(yaxis) < 2:
yaxis.append(1)
yaxis[0] = ''
postactivity.set_axis_labels(Axis.LEFT, yaxis)
postactivity.set_axis_labels(Axis.BOTTOM, listdate)
postactivity.set_colours(['ff0000', '0000ff', '00ff00'])
postactivity.set_legend(['posts', 'replies', 'total'])
postactivity.set_legend_position('b')
return postactivity.get_url()
def history(message):
try:
splitted_text = re.search(r'[a-zA-Z]{3}/[a-zA-Z]{3}', message.text).group().split('/')
base = splitted_text[0].upper()
symbols = splitted_text[1].upper()
start = str(date.today() - timedelta(days=7))
end = str(date.today())
data = requests.get(
'https://api.exchangeratesapi.io/history?start_at='+start+'&end_at='+end+'&base='+base+'&symbols='+symbols
)
data = data.json()
chart = SimpleLineChart(700, 400)
chart_data = []
# using collections.OrderedDict to sort incoming data
for i in collections.OrderedDict(sorted(data['rates'].items())):
chart_data.append(round(data['rates'][i][symbols], 2))
chart.add_data(chart_data)
print(collections.OrderedDict(sorted(data['rates'].items())))
# Set the line colour
chart.set_colours(['0000FF'])
left_axis= list(
range(
round(min(chart_data)),
round(max(chart_data)+1),
round(sum(chart_data)/len(chart_data))
)
)
chart.set_axis_labels(Axis.LEFT, left_axis)
x_labels = []
# using collections.OrderedDict to sort incoming data
for i in collections.OrderedDict(sorted(data['rates'].items())):
x_labels.append(i)
chart.set_axis_labels(Axis.BOTTOM, x_labels)
print(chart.get_url())
bot.send_photo(message.chat.id, chart.get_url())
except:
bot.send_message(message.chat.id, 'No exchange rate data is available for the selected currency.')
def group_post_activity(request, group_slug):
group = get_object_or_404(BaseGroup, slug=group_slug)
postcount = []
replycount = []
allcount = []
listdate = []
thedate = date(date.today().year - 1,
date.today().month,
1)
skip = False
while thedate.year != date.today().year or thedate.month != date.today().month:
if thedate.month == 12:
enddate = date(year=thedate.year + 1,
month=1, day=1)
else:
enddate = date(year=thedate.year,
month=thedate.month + 1,
day=1)
posts = GroupTopic.objects.filter(parent_group=group,
created__range=(thedate, enddate)).count()
#replies = ThreadedComment.objects.filter(content_object__parent_group=group,
# date_submitted__range=(thedate, enddate)).count()
replies = 0
postcount.append(posts)
replycount.append(replies)
allcount.append(posts + replies)
if not skip:
listdate.append(thedate.strftime("%B %y"))
else:
listdate.append("")
skip = not skip
thedate = enddate
postactivity = SimpleLineChart(600, 450, y_range=(min(min(postcount), min(replycount)), max(max(postcount), max(replycount)) + 1))
postactivity.add_data(postcount)
postactivity.add_data(replycount)
postactivity.add_data(allcount)
yaxis = range(min(min(postcount), min(replycount)), max(max(postcount), max(replycount)) + 1, 1)
if len(yaxis) < 2:
yaxis.append(1)
yaxis[0] = ''
postactivity.set_axis_labels(Axis.LEFT, yaxis)
postactivity.set_axis_labels(Axis.BOTTOM, listdate)
postactivity.set_colours(['ff0000', '0000ff', '00ff00'])
postactivity.set_legend(['posts', 'replies', 'total'])
postactivity.set_legend_position('b')
return postactivity.get_url()
def _line(self, results):
key = 'count'
if self.request.GET.get('percentages') == 'true':
key = 'percentage'
counts = [x.get(key) for x in results]
maxcount = max(counts)
granularity = self.request.GET.get('granularity')
times = [x.get(granularity) for x in results]
width = int(self.request.GET.get('width', 575))
height = int(self.request.GET.get('height', 300))
chart = SimpleLineChart(width, height, y_range=(0, max(counts)))
chart.add_data(counts)
chart.set_line_style(0, thickness=2) # Set line thickness
chart.set_colours([
'E0B300',
])
chart.fill_solid('bg', '00000000') # Make the background transparent
chart.set_grid(0, 50, 2, 5) # Set gridlines
if self.request.GET.get('granularity') == 'month':
months = [x['month'] for x in results]
januaries = [x for x in months if x.endswith('01')]
january_indexes = [months.index(x) for x in januaries]
january_percentages = [
int((x / float(len(months))) * 100) for x in january_indexes
]
index = chart.set_axis_labels(Axis.BOTTOM,
[x[:4] for x in januaries[::2]])
chart.set_axis_positions(index,
[x for x in january_percentages[::2]])
if key == 'percentage':
label = '%.4f' % maxcount
label += '%'
else:
label = int(maxcount)
index = chart.set_axis_labels(Axis.LEFT, [
label,
])
chart.set_axis_positions(index, [
100,
])
if self.request.GET.get('legend', 'true') != 'false':
chart.set_legend([
self.request.GET.get('phrase'),
])
return chart.get_url()
def group_membership_activity(request, group_slug):
group = get_object_or_404(BaseGroup, slug=group_slug)
listcount = []
listdate = []
currentcount = group.member_users.all().count()
thedate = date.today()
skip = False
while thedate.year != date.today().year - 1 or thedate.month != date.today(
).month:
if thedate.month == 1:
startdate = date(year=thedate.year - 1, month=12, day=1)
else:
startdate = date(year=thedate.year, month=thedate.month - 1, day=1)
joins = GroupMemberRecord.objects.filter(
group=group,
membership_start=True,
datetime__range=(startdate, thedate)).count()
unsubs = GroupMemberRecord.objects.filter(
group=group,
membership_end=True,
datetime__range=(startdate, thedate)).count()
listcount.append(currentcount - joins + unsubs)
if not skip:
listdate.append(thedate.strftime("%B %y"))
else:
listdate.append("")
skip = not skip
thedate = startdate
listcount.reverse()
listdate.reverse()
activity = SimpleLineChart(600,
450,
y_range=(min(listcount), max(listcount)))
activity.add_data(listcount)
yaxis = range(
min(listcount),
max(listcount) + 1,
max(max(listcount) / 10,
1)) # that last number should be 25 or 50. but for testing...
if len(yaxis) < 2: # only for testing...
yaxis.append(1)
yaxis[0] = ''
activity.set_axis_labels(Axis.LEFT, yaxis)
activity.set_axis_labels(Axis.BOTTOM, listdate)
return activity.get_url()
def get_elevation_chart_url(self, width, height):
if len(self.positions) == 0:
return ''
int_elevations = [int(elevation) for elevation in ema([p.altitude for p in self.positions], 30)]
max_elev = int(max(int_elevations) / 0.95)
min_elev = int(min(int_elevations) * 0.95)
chart = SimpleLineChart(width, height, y_range = (min_elev, max_elev))
chart.add_data(int_elevations)
chart.set_axis_range(Axis.LEFT, min_elev, max_elev)
return chart.get_url()
def get(self):
query1 = self.request.get('query1');
query2 = self.request.get('query2');
if query2 == '':
query2 = query1;
self.response.headers['Content-Type'] = 'text/html; charset=UTF-8'
self.response.out.write(HTML_TEMPLATE % {'query1' : query1.replace('"','"'), 'query2' : query2.replace('"','"')})
if query1 != None and query2 != None:
year_07 = '%s publication_year:[2008]' % query1
year_08 = '%s publication_year:[2008]' % query2
results7 = search(year_07)
results8 = search(year_08)
data7 = extract(results7)
data8 = extract(results8)
if sum(data8) == 0:
data8 = [1] * 12
big = max(data7 + data8)
small = min(data7 + data8)
chart = SimpleLineChart(600,400,y_range=[ small, big])
chart.add_data(data7)
chart.add_data(data8)
chart.set_colours(['207000','0077A0'])
chart.set_axis_labels(Axis.LEFT,range(small,big,((big-small+1)/ 12)+1))
chart.set_axis_labels(Axis.BOTTOM,[ x[:3] for x in calendar.month_name ][1:])
chart.set_line_style(0,thickness=6)
chart.set_line_style(1,thickness=6)
self.response.out.write('<div id="container">')
self.response.out.write('<div id="graph">')
self.response.out.write('<h2>Trend <font color="207000">%s</font> vs. <font color="0077A0">%s</font> for 2008</h2>' % (query1,query2))
self.response.out.write('<img src="%s">' % chart.get_url() )
self.response.out.write('<strong>Total: <font color="207000">%s</font> %d</strong> ' %(query1,results7['total']))
self.response.out.write('<strong><font color="0077A0">%s</font> %d</strong>' % (query2,results8['total']))
self.response.out.write('<br>As mentioned in articles from <a href="http://www.nytimes.com">The New York Times</a>')
self.response.out.write('</div')
self.response.out.write('<div id="img"><center>')
self.response.out.write('<h2><font color="207000">%s</font></h2>'% (query1))
for i in results7['results']:
if 'small_image_url' in i:
self.response.out.write('<a href="%s"><img src="%s"></a>' % (i['url'],i['small_image_url']))
self.response.out.write('</center></div>')
self.response.out.write('<div id="img"><center>')
self.response.out.write('<h2><font color="0077A0">%s</font></h2>'% (query2))
for i in results8['results']:
if 'small_image_url' in i:
self.response.out.write('<a href="%s"><img src="%s"></a>' % (i['url'],i['small_image_url']))
self.response.out.write('</center></div>')
self.response.out.write('</div>')
self.response.out.write('<div id="container">brought to you via the search api of <a href="http://developer.nytimes.com">nytimes.com</a> and <a href="http://twitter.com/derekg">derekg</a></div>')
self.response.out.write('</center></body></html>')
def month_graph(data, start, end):
"""Helper for making graphy graph for a month's worth of data on something."""
from pygooglechart import SimpleLineChart, Axis
WIDTH, HEIGHT = 700, 200
y_range = (0, max(max(data), 1)) # todo: have extra room when I figure out how to do labels (set_axis_positions?)
x_range = (0, 30)
chart = SimpleLineChart(WIDTH, HEIGHT, y_range=y_range, x_range=x_range)
chart.add_data(data)
chart.set_axis_labels(Axis.LEFT, y_range)
#chart.left.labels = chart.left.label_positions = [0, max(data)]
chart.set_axis_labels(Axis.BOTTOM, [d.strftime('%D') for d in
date_range(start, end, datetime.timedelta(days=10))])
#chart.bottom.label_positions = [0, 10, 20, 30]
return chart.get_url()
def get_pace_chart_url(self, width, height):
def calc_pace_and_dist_from_previous(acc, p):
last_p = acc[0]
s = acc[1]
pace = acc[2]
int_dist = acc[3]
ds = distance.distance((p.latitude, p.longitude), \
(last_p.latitude, last_p.longitude)).kilometers
s = s + int(ds * 1000)
dt = (p.time - last_p.time).seconds
if ds > 0:
pace.append(dt / ds)
int_dist.append(s)
acc[0] = p
acc[1] = s
return acc
if len(self.positions) == 0:
return ''
pace = []
int_dist = []
s = 0
last_p = None
r = reduce(calc_pace_and_dist_from_previous,
self.positions[1:len(self.positions)],
[self.positions[0], 0, [], []])
pace = r[2]
int_dist = r[3]
int_pace = [int(p) for p in ema(pace, 30)]
min_pace = int(min(int_pace) * 0.95)
max_pace = int(max(int_pace) / 0.95)
mid_pace = (max_pace + min_pace) / 2
min_pace_str = '%02d:%02d' % (min_pace / 60, min_pace % 60)
mid_pace_str = '%02d:%02d' % (mid_pace / 60, mid_pace % 60)
max_pace_str = '%02d:%02d' % (max_pace / 60, max_pace % 60)
chart = SimpleLineChart(width, height, y_range = (min_pace, max_pace))
chart.add_data(int_pace)
chart.set_axis_labels(Axis.LEFT, [min_pace_str, mid_pace_str, max_pace_str])
return chart.get_url()
def taxonLineChart(taxon, site, max_y=None, label_record=None):
min_y = 0
records = taxon.mean_densities.filter(site=site).order_by('year')
years = [ record.year for record in records ]
means = [ record.mean for record in records ]
# Set the vertical range from 0 to 100
max_y = max_y or max(means)
span = max_y - min_y
if span == 0:
max_y = 1
step = pow(10, round(math.log(max_y) / math.log(10)) - 1)
ticks = frange(min_y, max_y + (step * 1), step)
chart = SimpleLineChart(300, 100, y_range=[0, max_y])
# Add the chart data
chart.add_data(means)
# Set the line colour to blue
chart.set_colours(['76A4FB'])
# limit number of ticks to around 4
n = len(ticks) / 3
# The Y axis labels contains 0 to 100 skipping every 25, but remove the
# first number because it's obvious and gets in the way of the first X
# label.
ticks = ticks[::n]
ticks[0] = ''
chart.set_axis_labels(Axis.LEFT, ticks)
# X axis labels
chart.set_axis_labels(Axis.BOTTOM, years[::4])
url = chart.get_url()
url.replace('lc', 'ls')
url += '&chm=B,C3D9FF,0,0,0'
if label_record:
url += ('|@a,3366CC,0,%f:%f,4' % (float(years.index(label_record.year)) / float(len(years)), (label_record.mean+(max_y * 0.05))/max_y))
print url
return url
class SimpleLineTempChart:
def __init__(self,data):
x_size=900
colours=['0000FF']
y_size=200
spacer=10
y_range=[min(data)-spacer, max(data)+spacer]
left_axis=range(y_range[0],y_range[1],5)
self.chart=SimpleLineChart(x_size,y_size,y_range=y_range)
self.chart.set_axis_labels(Axis.LEFT,left_axis)
self.chart.set_colours(colours)
self.chart.add_data(data)
#self.chart.add_data(data)
def get_url(self):
return self.chart.get_url()
def show(request, fund_id):
fund = get_object_or_404(Fund, pk=fund_id)
prices = fund.fundprice_set.order_by('-date')
data = []
for price in prices:
data.append(price.price)
data.reverse()
chart = SimpleLineChart(500, 200, y_range=[min(data), max(data)])
chart.add_data(data)
chart.set_colours(['0000FF'])
chart.fill_solid('bg', 'DDDDFF')
chart.set_axis_labels(Axis.LEFT, [min(data), max(data)])
start_date = prices[len(prices) - 1].date.isoformat()
end_date = prices[0].date.isoformat()
chart.set_axis_labels(Axis.BOTTOM, [start_date, end_date])
url = chart.get_url()
return render_to_response('funds/show.html',
{'fund': fund, 'prices': prices, 'graph_url': url})
def ShowChartByGoogle(handler, data, book, ups):
oneday = datetime.timedelta(days=1)
date = ups[0].date
xlabel = [str(date.day)]
ylabel = range(0, book.pages + 1, ((book.pages / 8) / 50 + 1) * 50)
for (i, up) in enumerate(ups):
if i == 0: continue
days = (up.date - ups[i-1].date).days
for j in range(days):
date += oneday
if date.weekday() == 0: # only records sunday
if date.day < 7:
xlabel.append(str(date.month))
else:
xlabel.append('.')
chart = SimpleLineChart(600, 320, y_range=[0, ylabel[-1]])
chart.add_data(data)
# Set the line colour to blue
chart.set_colours(['0000FF'])
# Set the vertical stripes
chart.fill_linear_stripes(Chart.CHART, 0, 'CCCCCC', 0.2, 'FFFFFF', 0.2)
# Set the horizontal dotted lines
chart.set_grid(0, 25, 5, 5)
# The Y axis labels contains 0 to 100 skipping every 25, but remove the
# first number because it's obvious and gets in the way of the first X
# label.
left_axis = ylabel
left_axis[0] = ''
chart.set_axis_labels(Axis.LEFT, left_axis)
# X axis labels
chart.set_axis_labels(Axis.BOTTOM, xlabel)
doRender(handler, 'progress.html', {
'book': book,
'imgurl': chart.get_url(),
'method': 'google'})
def group_membership_activity(request, group_slug):
group = get_object_or_404(BaseGroup, slug=group_slug)
listcount = []
listdate = []
currentcount = group.member_users.all().count()
thedate = date.today()
skip = False
while thedate.year != date.today().year - 1 or thedate.month != date.today().month:
if thedate.month == 1:
startdate = date(year=thedate.year - 1,
month=12, day=1)
else:
startdate = date(year=thedate.year,
month=thedate.month - 1,
day=1)
joins = GroupMemberRecord.objects.filter(group=group,
membership_start=True,
datetime__range=(startdate, thedate)).count()
unsubs = GroupMemberRecord.objects.filter(group=group,
membership_end=True,
datetime__range=(startdate, thedate)).count()
listcount.append(currentcount - joins + unsubs)
if not skip:
listdate.append(thedate.strftime("%B %y"))
else:
listdate.append("")
skip = not skip
thedate = startdate
listcount.reverse()
listdate.reverse()
activity = SimpleLineChart(600, 450, y_range=(min(listcount), max(listcount)))
activity.add_data(listcount)
yaxis = range(min(listcount), max(listcount) + 1, max(max(listcount)/10, 1)) # that last number should be 25 or 50. but for testing...
if len(yaxis) < 2: # only for testing...
yaxis.append(1)
yaxis[0] = ''
activity.set_axis_labels(Axis.LEFT, yaxis)
activity.set_axis_labels(Axis.BOTTOM, listdate)
return activity.get_url()
def get_chart(self, data, date_start, date_end, colours=None):
# Set the vertical range from max_value plus 10
if not data:
return None
max_y = max([max(l) for l in data])
if max_y < 10:
mult = 1
else:
y_scale = max_y
mult = 1
while y_scale/10 > 1:
mult = mult*10
y_scale = y_scale/10
max_y = max_y + mult
# Chart size of 200x125 pixels and specifying the range for the Y axis
chart = SimpleLineChart(600, 300, y_range=[0, max_y])
for i in data:
chart.add_data(i)
if not colours:
chart.set_colours(['0000FF']) # Set the line colour to blue
else:
chart.set_colours(colours)
# Set the vertical stripes
chart.fill_linear_stripes(Chart.CHART, 0, 'F2F2F2', 0.2, 'FFFFFF', 0.2)
# Set the horizontal dotted lines
chart.set_grid(0, 25, 5, 5)
left_axis = range(0, max_y + 1, mult)
left_axis[0] = ''
chart.set_axis_labels(Axis.LEFT, left_axis)
# X axis labels
chart.set_axis_labels(Axis.BOTTOM, \
self.get_chart_x_axis_label(date_start, date_end))
return chart.get_url()
def gchart(data, node, check, metric, start=datetime.now()-timedelta(days=1), end=datetime.now()):
d = []
ts = []
for p in data['metrics'][0]['data']:
d.append(float(p['avg']))
ts.append(p['ts'])
# Chart size of 200x125 pixels and specifying the range for the Y axis
max_y = int(max(d))
chart = SimpleLineChart(450, 250, y_range=[0,max_y])
chart.add_data(d)
left_axis = range(0, max_y + 1, max_y/5)
left_axis[0] = ''
chart.set_axis_labels(Axis.LEFT, left_axis)
min_dt = datetime.fromtimestamp(min(ts))
max_dt = datetime.fromtimestamp(max(ts))
chart.set_axis_labels(Axis.BOTTOM, [ str(min_dt), str(max_dt) ])
title = '%s.%s.%s' % (node['name'], check['type'], metric)
chart.set_title(title)
return chart.get_url()
def get(self):
counters = tasks.Counter.all().fetch(10)
rows = [{'name': c.key().name(), 'count': c.count} for c in counters]
chart = SimpleLineChart(1000, 300)
for counter in counters:
query = counter.snapshots
query.order('-date')
snapshots = query.fetch(30)
counts = [s.count for s in snapshots]
dates = [s.date.strftime("%d/%m") for s in snapshots]
for i in xrange(len(counts) - 1):
counts[i] -= counts[i + 1]
counts.reverse()
dates.reverse()
chart.add_data(counts[1:])
chart.set_axis_labels(pygooglechart.Axis.BOTTOM, dates[1:])
chart.set_axis_labels(pygooglechart.Axis.LEFT,
range(0,
chart.data_y_range()[1], 5))
hsv_colours = [(float(x) / 255, 1, 1)
for x in range(0, 255, 255 / len(counters))]
rgb_colours = [colorsys.hsv_to_rgb(*x) for x in hsv_colours]
hex_colours = [
'%02x%02x%02x' %
(int(x[0] * 255), int(x[1] * 255), int(x[2] * 255))
for x in rgb_colours
]
chart.set_colours(hex_colours)
chart.set_legend([c.key().name() for c in counters])
path = os.path.join(os.path.dirname(__file__), self.TEMPLATE)
self.response.out.write(
template.render(path, {
'url': chart.get_url(),
'counters': rows
}))
def generate_freq_chart_url_from_fedreg(search_term, start_year, end_year):
''' returns url for chart after querying FR API '''
year_range=range(start_year,end_year + 1)
month_range=range(1, 13)
base_url = "http://api.federalregister.gov/v1/articles.json" # fr api base url
base_url_plus_search_term = base_url + "?conditions[term]=" + search_term
count = []
for y in year_range:
date_conditions = "conditions[publication_date][year]=" + str(y)
url = base_url_plus_search_term + "&" + date_conditions
url = quote(url, safe='/:+=?&"|')
#print "url", url
search_result = fetch_fedreg_results_page(url) # request page
if search_result:
count.append(int(search_result['count']))
#print "count:", search_result['count']
# set up chart to display
if max(count) < 100:
left_axis_step = 10
max_y = 100
else:
left_axis_step = int(pow(10, int(log10(max(count)))) / 10)
max_y = (int(max(count) / left_axis_step) * left_axis_step) + (left_axis_step * 2)
#print "left", left_axis_step, "max_y", max_y
#print "max_y", max_y
left_axis = range(0, max_y + left_axis_step, left_axis_step)
left_axis[0] = ""
bottom_axis = year_range
chart = SimpleLineChart(600, 300, y_range=[0, max_y])
chart.set_colours(['0000FF'])
chart.set_axis_labels(Axis.LEFT, left_axis)
chart.set_axis_labels(Axis.BOTTOM, bottom_axis)
chart.set_grid(0, max(10, int(left_axis_step / 10)), 5, 5)
chart.add_data(count)
chart_url = chart.get_url()
return chart_url
def _line(self, results):
key = 'count'
if self.request.GET.get('percentages') == 'true':
key = 'percentage'
counts = [x.get(key) for x in results]
maxcount = max(counts)
granularity = self.request.GET.get('granularity')
times = [x.get(granularity) for x in results]
width = int(self.request.GET.get('width', 575))
height = int(self.request.GET.get('height', 300))
chart = SimpleLineChart(width, height, y_range=(0, max(counts)))
chart.add_data(counts)
chart.set_line_style(0, thickness=2) # Set line thickness
chart.set_colours(['E0B300', ])
chart.fill_solid('bg', '00000000') # Make the background transparent
chart.set_grid(0, 50, 2, 5) # Set gridlines
if self.request.GET.get('granularity') == 'month':
months = [x['month'] for x in results]
januaries = [x for x in months if x.endswith('01')]
january_indexes = [months.index(x) for x in januaries]
january_percentages = [int((x / float(len(months))) * 100) for x in january_indexes]
index = chart.set_axis_labels(Axis.BOTTOM, [x[:4] for x in januaries[::2]])
chart.set_axis_positions(index, [x for x in january_percentages[::2]])
if key == 'percentage':
label = '%.4f' % maxcount
label += '%'
else:
label = int(maxcount)
index = chart.set_axis_labels(Axis.LEFT, [label, ])
chart.set_axis_positions(index, [100, ])
if self.request.GET.get('legend', 'true') != 'false':
chart.set_legend([self.request.GET.get('phrase'), ])
return chart.get_url()
def group_message_list(request, group_id):
group = get_object_or_404(GroupedMessage, pk=group_id)
message_list = group.message_set.all().order_by('-datetime')
unique_urls = message_list.filter(url__isnull=False).values_list('url', 'logger', 'view', 'checksum').annotate(times_seen=Count('url')).values('url', 'times_seen').order_by('-times_seen')
unique_servers = message_list.filter(server_name__isnull=False).values_list('server_name', 'logger', 'view', 'checksum').annotate(times_seen=Count('server_name')).values('server_name', 'times_seen').order_by('-times_seen')
engine = get_db_engine()
if SimpleLineChart and not engine.startswith('sqlite'):
today = datetime.datetime.now()
chart_qs = message_list\
.filter(datetime__gte=today - datetime.timedelta(hours=24))\
.extra(select={'hour': 'extract(hour from datetime)'}).values('hour')\
.annotate(num=Count('id')).values_list('hour', 'num')
rows = dict(chart_qs)
if rows:
max_y = max(rows.values())
else:
max_y = 1
chart = SimpleLineChart(300, 80, y_range=[0, max_y])
chart.add_data([max_y]*30)
chart.add_data([rows.get((today-datetime.timedelta(hours=d)).hour, 0) for d in range(0, 24)][::-1])
chart.add_data([0]*30)
chart.fill_solid(chart.BACKGROUND, 'eeeeee')
chart.add_fill_range('eeeeee', 0, 1)
chart.add_fill_range('e0ebff', 1, 2)
chart.set_colours(['eeeeee', '999999', 'eeeeee'])
chart.set_line_style(1, 1)
chart_url = chart.get_url()
page = 'messages'
return render_to_response('sentry/group/message_list.html', locals())
def getRollingAverageGraph(cursor, colName, rollingWindowDays, title=""):
sqlCMD = "SELECT pDate, %s from %s" % (colName, N.JOBS_SUMMARY_TABLENAME)
cursor.execute(sqlCMD)
results = cursor.fetchall()
beginWindowIndex = 0
endWindowIndex = 0
xData = []
yData = []
while endWindowIndex < len(results):
while endWindowIndex < len(results) and (
results[endWindowIndex][0] -
results[beginWindowIndex][0]).days <= rollingWindowDays:
endWindowIndex += 1
yData.append(
sum(results[i][1]
for i in xrange(beginWindowIndex, endWindowIndex, 1)) /
float(endWindowIndex - beginWindowIndex))
xData.append(results[endWindowIndex - 1][0])
beginWindowIndex = endWindowIndex
chart = SimpleLineChart(680, 400, y_range=(min(yData) - 1, max(yData) + 1))
chart.add_data(yData)
yLabels = range(0, int(max(yData) + 1), 5)
yLabels[0] = ''
xLabels = [
str(xData[-i]) for i in xrange(1,
len(xData) - 1, int(0.2 * len(xData)))
]
xLabels.reverse()
chart.set_axis_labels(Axis.LEFT, yLabels)
chart.set_axis_labels(Axis.BOTTOM, xLabels)
chart.set_title("Rolling %i-Day Average %s" % (rollingWindowDays, title))
imgbin = chart.download()
toReturn = cStringIO.StringIO(imgbin)
toReturn.seek(0)
return chart.get_url(), toReturn
def main_dashboard(request):
today, created = DailyStats.objects.get_or_create(day=date.today())
if today.users == 0:
today.users = 1
# ---- Daily usage ----
enddate = date.today()
#startdate = enddate - timedelta(weeks=60)
startdate = enddate - timedelta(weeks=4)
averageusage = DailyStats.objects.filter(
day__range=(startdate, enddate)).order_by('day')
days = []
signins = []
posts = []
replies = []
whiteboards = []
signups = []
listsignups = []
listupgrades = []
deletions = []
numUsers = []
numRegularMembers = []
regupgrades = []
renewals = []
regdowngrades = []
for s in averageusage:
days.append(s.day.strftime("%B %y"))
signins.append(s.signins)
posts.append(s.posts)
replies.append(s.replies)
whiteboards.append(s.whiteboardEdits)
signups.append(s.signups)
listsignups.append(s.mailinglistsignups)
listupgrades.append(s.mailinglistupgrades)
deletions.append(s.deletions)
numUsers.append(s.users)
numRegularMembers.append(s.regularmembers)
regupgrades.append(s.regupgrades)
renewals.append(s.renewals)
regdowngrades.append(s.regdowngrades)
xaxis = []
#for i in range(0, len(days), 1): # this will make limited test data look better
for i in range(0, len(days), len(days) / 8):
xaxis.append(days[i])
# ---- Daily usage ----
dailyUsageChart = SimpleLineChart(600, 450, y_range=(0, max(signins)))
#chart.add_data(avgsignins)
dailyUsageChart.add_data(posts)
dailyUsageChart.add_data(replies)
dailyUsageChart.add_data(signins)
dailyUsageChart.add_data(whiteboards)
dailyUsageChart.set_colours(['ff0000', 'ffff00', '00ff00', '0000ff'])
dailyUsageChart.set_legend(['posts', 'replies', 'signins', 'whiteboards'])
dailyUsageChart.set_legend_position('b')
#yaxis = range(0, max_signins + 1, 2) # this will make limited test data look better
yaxis = range(0, max(signins), max(signins) / 10)
yaxis[0] = ''
dailyUsageChart.set_axis_labels(Axis.LEFT, yaxis)
dailyUsageChart.set_axis_labels(Axis.BOTTOM, xaxis)
dailyUsage = dailyUsageChart.get_url()
# ---- Account changes ----
accountChangesChart = SimpleLineChart(600, 450, y_range=(0, 25))
accountChangesChart.add_data(signups)
accountChangesChart.add_data(listsignups)
accountChangesChart.add_data(listupgrades)
accountChangesChart.add_data(deletions)
accountChangesChart.set_colours(['ff0000', 'ffff00', '00ff00', '0000ff'])
accountChangesChart.set_legend(
['account signups', 'email signups', 'email upgrades', 'deletions'])
accountChangesChart.set_legend_position('b')
#yaxis = range(0, 25, 2) # this will make limited test data look better
yaxis = range(0, min(max(listsignups), 10), max(max(listsignups) / 10, 1))
yaxis[0] = ''
accountChangesChart.set_axis_labels(Axis.LEFT, yaxis)
accountChangesChart.set_axis_labels(Axis.BOTTOM, xaxis)
accountChanges = accountChangesChart.get_url()
# ---- Membership ----
membershipChart = SimpleLineChart(600, 450, y_range=(42000, 52000))
membershipChart.add_data(numUsers)
membershipChart.add_data(numRegularMembers)
membershipChart.set_colours(['ff0000', '0000ff'])
membershipChart.set_legend(['total users', 'regular members'])
membershipChart.set_legend_position('b')
yaxis = range(42000, 52000, 1000)
yaxis[0] = ''
yaxis2 = range(0, 1500, 50)
yaxis2[0] = ''
membershipChart.set_axis_labels(Axis.LEFT, yaxis)
membershipChart.set_axis_labels(Axis.RIGHT, yaxis2)
membershipChart.set_axis_labels(Axis.BOTTOM, xaxis)
membershipChart = membershipChart.get_url()
# ---- Account changes ----
membershipChangesChart = SimpleLineChart(600, 450, y_range=(0, 10))
membershipChangesChart.add_data(regupgrades)
membershipChangesChart.add_data(renewals)
membershipChangesChart.add_data(regdowngrades)
membershipChangesChart.set_colours(['ff0000', 'ffff00', '00ff00'])
membershipChangesChart.set_legend(
['regular upgrades', 'renewals', 'regular downgrades'])
membershipChangesChart.set_legend_position('b')
#yaxis = range(0, 25, 2) # the same.
yaxis = range(
0, max(max(regupgrades), max(regdowngrades), max(renewals)),
max(max(max(regupgrades), max(regdowngrades), max(renewals)) / 10, 1))
yaxis[0] = ''
membershipChangesChart.set_axis_labels(Axis.LEFT, yaxis)
membershipChangesChart.set_axis_labels(Axis.BOTTOM, xaxis)
membershipChanges = membershipChangesChart.get_url()
# ---- Status breakdown ----
statusBreakdownChart = PieChart3D(600, 240)
mlistmembers = today.users - today.regularmembers - today.associatemembers
statusBreakdownChart.add_data([
mlistmembers +
1, # FIXME: the +1 is needed so pygoogle doesn't crash (it doesn't handle zeroes well)
today.associatemembers + 1,
today.regularmembers + 1
])
statusBreakdownChart.set_colours(['ff0000', 'ffff00', '00ff00'])
statusBreakdownChart.set_pie_labels(
["mailing list members", "associate members", "regular members"])
statusBreakdown = statusBreakdownChart.get_url()
# ---- Membership breakdown ----
chapters = Network.objects.filter(chapter_info__isnull=False,
is_active=True)
chapternames = []
chaptermembers = []
for chapter in chapters:
chapternames.append(chapter.slug)
chaptermembers.append(chapter.members.all().count())
membershipBreakdownChart = StackedHorizontalBarChart(
500, 500, x_range=(0, max(chaptermembers)))
membershipBreakdownChart.add_data(chaptermembers)
yaxis = range(0, max(chaptermembers), 10)
yaxis[0] = ''
membershipBreakdownChart.set_axis_labels(Axis.BOTTOM, yaxis)
membershipBreakdownChart.set_axis_labels(Axis.LEFT, chapternames)
membershipBreakdownChart.set_bar_width(330 / len(chapternames))
membershipBreakdown = membershipBreakdownChart.get_url()
# ---- Province breakdown ----
profiletype = ContentType.objects.get_for_model(MemberProfile)
addresses = Address.objects.filter(content_type=profiletype)
totalprov = Address.objects.filter(
content_type=profiletype).count() + 1 # FIXME
provinces = []
provincecount = []
provincelist = list(pycountry.subdivisions.get(country_code='CA'))
for p in provincelist:
pcode = p.code.split('-')[1]
provincecount2 = Address.objects.filter(content_type=profiletype,
province=pcode).count()
if provincecount2 == 0:
provincecount2 = 1
provincecount.append(provincecount2)
provinces.append(pcode + " (%d%%)" %
(provincecount2 * 100 / totalprov))
#provinces = sorted(provinces)
provinceBreakdownChart = PieChart3D(600, 240)
provinceBreakdownChart.add_data(provincecount)
#provinceBreakdownChart.set_colours(['ff0000', 'ffff00', '00ff00'])
provinceBreakdownChart.set_pie_labels(provinces)
provinceBreakdown = provinceBreakdownChart.get_url()
# ---- Gender breakdown ----
males = MemberProfile.objects.filter(gender='M').count() + 1
females = MemberProfile.objects.filter(gender='F').count() + 1
genderunknown = MemberProfile.objects.filter(
gender__isnull=True).count() + 1 #FIXME
gendertotal = males + females + genderunknown
genderBreakdownChart = PieChart3D(600, 240)
genderBreakdownChart.add_data([males, females, genderunknown])
genderBreakdownChart.set_colours(['ff0000', 'ffff00', '00ff00'])
genderBreakdownChart.set_pie_labels([
'Male (%d%%)' % (males * 100 / gendertotal),
'Female (%d%%)' % (females * 100 / gendertotal),
'Unspecified (%d%%)' % (genderunknown * 100 / gendertotal)
])
genderBreakdown = genderBreakdownChart.get_url()
# ---- Student breakdown ----
students = User.objects.filter(
studentrecord__graduation_date__isnull=True).count() + 1
nonstudents = User.objects.filter(
workrecord__end_date__isnull=True).count() + 1
# yeah, i know, not 100% accurate since a student can have a part-time job
studentBreakdownChart = PieChart3D(600, 240)
studentBreakdownChart.add_data([students, nonstudents])
studentBreakdownChart.set_colours(['ff0000', '00ff00'])
studentBreakdownChart.set_pie_labels(['Students', 'Non-students'])
studentBreakdown = studentBreakdownChart.get_url()
# ---- Language breakdown ----
preferen = MemberProfile.objects.filter(language='E').count() + 1
preferfr = MemberProfile.objects.filter(language='F').count() + 1
prefernone = MemberProfile.objects.filter(
language__isnull=True).count() + 1
languageBreakdownChart = PieChart3D(600, 240)
languageBreakdownChart.add_data([preferen, preferfr, prefernone])
languageBreakdownChart.set_colours(['ff0000', 'ffff00', '00ff00'])
languageBreakdownChart.set_pie_labels(
['english', 'french', 'not specified'])
languageBreakdown = languageBreakdownChart.get_url()
# ---- Post breakdown ----
postspublic = GroupTopic.objects.filter(
parent_group__visibility='E',
parent_group__parent__isnull=True).count() + 1
postsprivate = GroupTopic.objects.filter(
parent_group__parent__isnull=True).exclude(
parent_group__visibility='E').count() + 1
postspublicchapter = GroupTopic.objects.filter(
parent_group__visibility='E',
parent_group__parent__isnull=False).count() + 1
postsprivatechapter = GroupTopic.objects.filter(
parent_group__parent__isnull=False).exclude(
parent_group__visibility='E').count() + 1
postcount = postspublic + postsprivate + postspublicchapter + postsprivatechapter
postBreakdownChart = PieChart3D(600, 240)
postBreakdownChart.add_data(
[postspublic, postspublicchapter, postsprivatechapter, postsprivate])
#postBreakdownChart.set_colours(['ff0000', 'ffff00', '00ff00'])
postBreakdownChart.set_pie_labels(
['public', 'public chapter', 'private chapter', 'private'])
postBreakdown = postBreakdownChart.get_url()
# ---- Login distribution ----
logincount = []
malelogins = []
femalelogins = []
for i in range(0, 30):
logincount.append(
MemberProfile.objects.filter(login_count__gte=i).count())
malelogins.append(
MemberProfile.objects.filter(login_count__gte=i,
gender='M').count())
femalelogins.append(
MemberProfile.objects.filter(login_count__gte=i,
gender='F').count())
loginDistribution = SimpleLineChart(600, 450, y_range=(0, 9000))
loginDistribution.add_data(logincount)
loginDistribution.add_data(malelogins)
loginDistribution.add_data(femalelogins)
loginDistribution.set_colours(['ff0000', '0000ff', '00ff00'])
loginDistribution.set_legend(['logins', 'male', 'female'])
loginDistribution.set_legend_position('b')
yaxis = range(
0, 9000,
500) # that last number should be 25 or 50. but for testing...
yaxis[0] = ''
loginDistribution.set_axis_labels(Axis.LEFT, yaxis)
loginDistribution.set_axis_labels(Axis.BOTTOM, range(0, 30))
loginDistribution = loginDistribution.get_url()
# ---- Login recency ----
loginrecent = []
loginrecentdate = []
thedate = date(date.today().year - 1, date.today().month, 1)
skip = False
while thedate.year != date.today().year or thedate.month != date.today(
).month:
if thedate.month == 12:
enddate = date(year=thedate.year + 1, month=1, day=1)
else:
enddate = date(year=thedate.year, month=thedate.month + 1, day=1)
loginrecent.append(
MemberProfile.objects.filter(
previous_login__range=(thedate, enddate)).count())
if not skip:
loginrecentdate.append(thedate.strftime("%B %y"))
else:
loginrecentdate.append("")
skip = not skip
thedate = enddate
loginRecency = SimpleLineChart(600, 450, y_range=(0, max(loginrecent) + 1))
loginRecency.add_data(loginrecent)
yaxis = range(0, max(loginrecent), max(
max(loginrecent) / 10,
1)) # that last number should be 25 or 50. but for testing...
if len(yaxis) == 0:
yaxis.append(10)
yaxis.append(10)
yaxis[0] = ''
loginRecency.set_axis_labels(Axis.LEFT, yaxis)
loginRecency.set_axis_labels(Axis.BOTTOM, loginrecentdate)
loginRecency = loginRecency.get_url()
# ---- Age distribution ----
ages = []
for age in range(15, 75):
year = date.today().year - age
ages.append(
MemberProfile.objects.filter(date_of_birth__year=year).count())
ageDistribution = SimpleLineChart(600, 450, y_range=(0, max(ages) + 1))
ageDistribution.add_data(ages)
yaxis = range(0, max(ages) + 1, 50)
yaxis[0] = ''
ageDistribution.set_axis_labels(Axis.LEFT, yaxis)
ageDistribution.set_axis_labels(Axis.BOTTOM, range(15, 75, 5))
ageDistribution = ageDistribution.get_url()
# ---- Finally! ----
return render_to_response(
"stats/dashboard.html", {
"signins": today.signins,
"posts": today.posts,
"replies": today.replies,
"signups": today.signups,
"listsignups": today.mailinglistsignups,
"listupgrades": today.mailinglistupgrades,
"deletions": today.deletions,
"regupgrades": today.regupgrades,
"regdowngrades": today.regdowngrades,
"renewals": today.renewals,
"totalusers": today.users,
"dailyUsage": dailyUsage,
"accountChanges": accountChanges,
"membershipChart": membershipChart,
"membershipChanges": membershipChanges,
"statusBreakdown": statusBreakdown,
"mlistmembers": mlistmembers,
"mlistmemberspercent": mlistmembers * 100 / today.users,
"associatemembers": today.associatemembers,
"associatememberspercent":
today.associatemembers * 100 / today.users,
"regularmembers": today.regularmembers,
"regularmemberspercent": today.regularmembers * 100 / today.users,
"membershipBreakdown": membershipBreakdown,
"provinceBreakdown": provinceBreakdown,
"provincecount": totalprov,
"genderBreakdown": genderBreakdown,
"studentBreakdown": studentBreakdown,
"languageBreakdown": languageBreakdown,
"postBreakdown": postBreakdown,
"loginDistribution": loginDistribution,
"loginRecency": loginRecency,
"ageDistribution": ageDistribution
},
context_instance=RequestContext(request))
def get_chart_url():
cache_key = 'phonedb-chart-url-%s' % settings.LANGUAGE_CODE
url = cache.get(cache_key)
if url is not None:
return url
enddate = datetime.datetime.now()
# This works badly, we will rather render only chart for month after
# it has finished
#+ datetime.timedelta(days=30)
endyear = enddate.year
endmonthlast = enddate.month
endmonth = 12
dates = []
unsupported = []
supported = []
totals = []
alls = []
years = []
for year in range(2006, endyear + 1):
if year == endyear:
endmonth = endmonthlast
for month in range(1, endmonth + 1):
if month == 1:
years.append('%d' % year)
else:
years.append('')
time_range = (datetime.date(1900, 1,
1), datetime.date(year, month, 1))
supported_val = Phone.objects.exclude(state='deleted').filter(
connection__isnull=False).filter(
created__range=time_range).count()
unsupported_val = Phone.objects.exclude(state='deleted').filter(
connection__isnull=True).filter(
created__range=time_range).count()
all_val = Phone.objects.filter(
created__lt=datetime.date(year, month, 1)).count()
supported.append(supported_val)
unsupported.append(unsupported_val)
totals.append(unsupported_val + supported_val)
alls.append(all_val)
dates.append('%d-%02d' % (year, month))
#print dates
#print unsupported
#print supported
#print totals
#print alls
max_y = int(((max(alls) / 100) + 1) * 100)
chart = SimpleLineChart(800, 300, y_range=[0, max_y])
# chart.fill_solid(chart.BACKGROUND, 'ffd480')
# chart.fill_solid(chart.CHART, 'ffd480')
# Chart data
chart.add_data(supported)
chart.add_data(totals)
chart.add_data(alls)
# Lowest value
chart.add_data([0] * 2)
# Set the line colour to blue
chart.set_colours(['00FF00', 'FF0000', '0000FF', '00000000'])
#chart.add_fill_range('76A4FB', 2, 3)
# Set the vertical stripes
month_stripes = 3.0
chart.fill_linear_stripes(Chart.CHART, 0, 'ffffff',
month_stripes / len(alls), 'cccccc',
month_stripes / len(alls))
# Set the horizontal dotted lines
chart.set_grid(0, 10, 5, 5)
chart.set_legend([
_('Supported phones').encode('utf-8'),
_('Approved records').encode('utf-8'),
_('Total records').encode('utf-8')
])
left_axis = ['%d' % x for x in range(0, max_y + 1, int(max_y / 10))]
left_axis[0] = ''
chart.set_axis_labels(Axis.LEFT, left_axis)
chart.set_axis_labels(Axis.BOTTOM, years)
url = chart.get_url().replace('http:', 'https:')
cache.set(cache_key, url, 3600)
return url
chart = SimpleLineChart(300, 325, y_range=[0, max_y])
# Add the chart data
data = []
data.append(tests[0][2])
data.append(tests[1][2])
chart.add_data(data)
# Set the line colour to blue
chart.set_colours(['0000FF'])
# Set the vertical stripes
chart.fill_linear_stripes(Chart.CHART, 0, 'CCCCCC', 0.2, 'FFFFFF', 0.2)
# Set the horizontal dotted lines
chart.set_grid(0, 25, 5, 5)
# The Y axis labels contains 0 to 100 skipping every 25, but remove the
# first number because it's obvious and gets in the way of the first X
# label.
left_axis = range(0, max_y + 1, 25)
left_axis[0] = ''
chart.set_axis_labels(Axis.LEFT, left_axis)
# X axis labels
chart.set_axis_labels(Axis.BOTTOM, \
[1,2])
chart.download(path_to_db + 'line-stripes.png')
print chart.get_url()
def read(self, request, *args, **kwargs):
self.request = request
if kwargs.get('chart_type') == 'timeline':
handler = PhraseOverTimeHandler()
if request.GET.get('split_by_party') == 'true':
resultsets = {}
for party in [
'R',
'D',
]:
kwargs['party'] = party
resultsets[party] = handler.read(request, *args, **kwargs)
return {
'results': {
'url': self._partyline(resultsets),
},
}
elif request.GET.get('compare') == 'true':
phrases = request.GET.get(
'phrases', '').split(',')[:5] # Max of 5 phrases
parties = request.GET.get('parties', '').split(',')
states = request.GET.get('states', '').split(',')
#chambers = request.GET.get('chambers', '').split(',')
colors = [
'8E2844',
'A85B08',
'AF9703',
]
metadata = []
legend_items = []
months = None
key = 'count'
if self.request.GET.get('percentages') == 'true':
key = 'percentage'
granularity = self.request.GET.get('granularity')
width = int(request.GET.get('width', 575))
height = int(request.GET.get('height', 300))
chart = SimpleLineChart(width, height)
chart.set_grid(0, 50, 2, 5) # Set gridlines
chart.fill_solid('bg',
'00000000') # Make the background transparent
chart.set_colours(colors)
maxcount = 0
# Use phrases as a baseline; that is, assume that
# there's a corresponding value for the other filters.
# If a filter doesn't have as many values as the number
# of phrases, the corresponding phrase will not be
# filtered.
# (However, if a value is set for 'party' or 'state'
# in the querystring, that will override any values
# set in 'phrases' or 'parties.')
for n, phrase in enumerate(phrases):
chart.set_line_style(n, thickness=2) # Set line thickness
if not phrase.strip():
continue
kwargs['phrase'] = phrase
legend = phrase
try:
kwargs['party'] = parties[n]
except IndexError:
pass
try:
kwargs['state'] = states[n]
except IndexError:
pass
if kwargs.get('party') and kwargs.get('state'):
legend += ' (%(party)s, %(state)s)' % kwargs
elif kwargs.get('party'):
legend += ' (%(party)s)' % kwargs
elif kwargs.get('state'):
legend += ' (%(state)s)' % kwargs
legend_items.append(legend)
data = handler.read(request, *args, **kwargs)
results = data['results']
counts = [x.get(key) for x in results]
if max(counts) > maxcount:
maxcount = max(counts)
chart.add_data(counts)
metadata.append(kwargs)
# Duplicated code; should move into separate function.
if self.request.GET.get('granularity') == 'month':
if not months:
months = [x['month'] for x in results]
januaries = [x for x in months if x.endswith('01')]
january_indexes = [months.index(x) for x in januaries]
january_percentages = [
int((x / float(len(months))) * 100)
for x in january_indexes
]
index = chart.set_axis_labels(
Axis.BOTTOM, [x[:4] for x in januaries[::2]])
chart.set_axis_positions(
index, [x for x in january_percentages[::2]])
chart.y_range = (0, maxcount)
if key == 'percentage':
label = '%.4f' % maxcount
label += '%'
else:
label = int(maxcount)
index = chart.set_axis_labels(Axis.LEFT, [
label,
])
chart.set_axis_positions(index, [
100,
])
# Always include a legend when comparing.
chart.set_legend(legend_items)
return {
'results': {
'metadata': metadata,
'url': chart.get_url()
}
}
#return resultsets
else:
data = handler.read(request, *args, **kwargs)
return {
'results': {
'url': self._line(data['results']),
},
}
elif kwargs.get('chart_type') == 'pie':
handler = PhraseByCategoryHandler()
kwargs['entity_type'] = request.GET.get('entity_type')
data = handler.read(request, *args, **kwargs)
if request.GET.get('output') == 'data':
return {'data': self._pie(data['results'])}
return {
'results': {
'url': self._pie(data['results']),
},
}
return {
'error': 'Invalid chart type.',
}
def get_chart_url(force=False):
cache_key = "phonedb-chart-url-%s" % settings.LANGUAGE_CODE
url = cache.get(cache_key)
if url is not None and not force:
return url
enddate = datetime.datetime.now()
endyear = enddate.year
endmonthlast = enddate.month
endmonth = 12
dates = []
unsupported = []
supported = []
totals = []
alls = []
years = []
for year in range(2006, endyear + 1):
if year == endyear:
endmonth = endmonthlast
for month in range(1, endmonth + 1):
if month == 1:
years.append("%d" % year)
else:
years.append("")
time_range = (datetime.date(1900, 1,
1), datetime.date(year, month, 1))
supported_val = (Phone.objects.exclude(state="deleted").filter(
connection__isnull=False).filter(
created__range=time_range).count())
unsupported_val = (Phone.objects.exclude(state="deleted").filter(
connection__isnull=True).filter(
created__range=time_range).count())
all_val = Phone.objects.filter(
created__lt=datetime.date(year, month, 1)).count()
supported.append(supported_val)
unsupported.append(unsupported_val)
totals.append(unsupported_val + supported_val)
alls.append(all_val)
dates.append("%d-%02d" % (year, month))
max_y = int(((max(alls) / 100) + 1) * 100)
chart = SimpleLineChart(800, 300, y_range=[0, max_y])
# Chart data
chart.add_data(supported)
chart.add_data(totals)
chart.add_data(alls)
# Lowest value
chart.add_data([0] * 2)
# Set the line colour to blue
chart.set_colours(["00FF00", "FF0000", "0000FF", "00000000"])
# Set the vertical stripes
month_stripes = 3.0
chart.fill_linear_stripes(
Chart.CHART,
0,
"ffffff",
month_stripes / len(alls),
"cccccc",
month_stripes / len(alls),
)
# Set the horizontal dotted lines
chart.set_grid(0, 10, 5, 5)
chart.set_legend([
_("Supported phones").encode("utf-8"),
_("Approved records").encode("utf-8"),
_("Total records").encode("utf-8"),
])
left_axis = ["%d" % x for x in range(0, max_y + 1, int(max_y / 10))]
left_axis[0] = ""
chart.set_axis_labels(Axis.LEFT, left_axis)
chart.set_axis_labels(Axis.BOTTOM, years)
url = chart.get_url().replace("http:", "https:")
cache.set(cache_key, url, 3600 * 24)
return url
def _partyline(self, party_results):
if self.request.GET.get('percentages') == 'true':
key = 'percentage'
else:
key = 'count'
maxcount = 0
allcounts = []
granularity = self.request.GET.get('granularity')
months = []
for party, results in party_results.iteritems():
counts = [x.get(key) for x in results['results']]
allcounts.append(counts)
if max(counts) > maxcount:
maxcount = max(counts)
if granularity == 'month':
months = [x['month'] for x in results['results']]
januaries = [x for x in months if x.endswith('01')]
january_indexes = [months.index(x) for x in januaries]
january_percentages = [
int((x / float(len(months))) * 100)
for x in january_indexes
]
#times = [x.get(granularity) for x in results['results']]
width = int(self.request.GET.get('width', 575))
height = int(self.request.GET.get('height', 318))
chart = SimpleLineChart(width, height, y_range=(0, max(counts)))
chart.fill_solid('bg', '00000000') # Make the background transparent
chart.set_grid(0, 50, 2, 5) # Set gridlines
if granularity == 'month':
index = chart.set_axis_labels(Axis.BOTTOM,
[x[:4] for x in januaries[::2]])
chart.set_axis_positions(index,
[x for x in january_percentages[::2]])
if key == 'percentage':
label = '%.4f' % maxcount
else:
label = int(maxcount)
index = chart.set_axis_labels(Axis.LEFT, [
label,
])
chart.set_axis_positions(index, [
100,
])
for n, counts in enumerate(allcounts):
chart.add_data(counts)
chart.set_line_style(n, thickness=2) # Set line thickness
colors = {
'R': 'bb3110',
'D': '295e72',
}
chart_colors = []
chart_legend = []
for k in party_results.keys():
chart_colors.append(colors.get(k, '000000'))
chart_legend.append(k)
chart.legend_position = 'b'
chart.set_colours(chart_colors)
if self.request.GET.get('legend', 'true') != 'false':
chart.set_legend(chart_legend)
return chart.get_url()
def POST_query(self, args):
form = request()
if not form.validates():
return "Failure. Did you select an option for all the fields?"
sym = form['symbol'].value
start_string = form['startdate'].value
end_string = form['enddate'].value
date_format = "%Y-%m-%d"
start = datetime.strptime(start_string,
date_format).strftime("%Y-%m-%d")
end = datetime.strptime(end_string, date_format).strftime("%Y-%m-%d")
msb = mysqlmodel.MySqlBase()
msb.connect()
start_time = time.time()
records = msb.get_by_sym_range2(sym, start, end)
if len(records) == 0:
message = "Zero records returned. Perhaps the date range is incorrect?"
return render.error(message)
records_unsorted = []
print "number records: %s" % (len(records))
for r in records:
temp = r
temp['date'] = datetime.strptime(str(temp['date']), "%Y-%m-%d")
records_unsorted.append(temp)
records_processed = sorted(records_unsorted, key=lambda k: k['date'])
elapsed_time = (time.time() - start_time)
y_max = 0.0
y_min = 0.0
data = []
for q in records_processed:
temp = float(q['price_adj_close'])
data.append(temp)
if temp > y_max:
y_max = temp
y_min = y_max
for d in records_processed:
temp = float(d['price_adj_close'])
if temp < y_min:
y_min = temp
difference = float(y_max - y_min)
difference = float(difference / 2)
y_min_foo = y_min - difference
y_max_foo = y_max + difference
if y_min_foo < 0:
y_min_foo = 0
chart = SimpleLineChart(1000, 300, y_range=[y_min_foo, y_max_foo])
chart.add_data(data)
chart.set_colours(['0000FF'])
# chart.fill_linear_stripes(Chart.CHART, 0, 'CCCCCC', 0.1, 'FFFFFF', 0.2)
# chart.set_grid(0, 25, 5, 5)
# y_max_output = y_max + difference
# left_axis = range(y_min_foo, y_max_foo, 1.00)
# left_axis[0] = y_min
left_axis = []
label = y_min_foo
delta_y = 1.00
derp = float(y_max_foo - y_min_foo)
# if derp > 15.0:
delta_y = derp / (10.00)
while y_min_foo < y_max_foo:
left_axis.append(y_min_foo)
y_min_foo = y_min_foo + delta_y
if len(left_axis) < 10:
left_axis.append(y_min_foo)
lines = len(left_axis) - 1
chart.set_grid(0, lines, 1, 1)
x_labels = []
for t in records_processed:
label = (self.getMonth(t['date'].month), t['date'].year)
if not label in x_labels:
x_labels.append(label)
chart.set_axis_labels(Axis.LEFT, left_axis)
chart.set_axis_labels(Axis.BOTTOM, x_labels)
list_len = float(len(x_labels))
top = float(1)
stripe_len = float(top / list_len)
chart.fill_linear_stripes(Chart.CHART, 0, 'CCCCCC', stripe_len,
'FFFFFF', stripe_len)
imgURL = chart.get_url()
return render.results(sym, records_processed, elapsed_time, imgURL)
def simple_random():
chart = SimpleLineChart(settings.width, settings.height)
chart.add_data(helper.random_data())
# chart.download('line-simple-random.png')
print chart.get_url()
def render(self, data={}, context={}):
assert self.series is not None, "'chart.series' must be set"
converter = wfcommon.units.Converter(context["units"])
# merge builtin defaults, context and renderer config
config = ChartConfig()
if context.has_key('chart'):
config.__dict__.update(context['chart'])
config.__dict__.update(self.__dict__)
# create the chart
chart = SimpleLineChart(config.width, config.height)
colors = []
legend_set = False
legend = []
chart_min = sys.maxint
chart_max = -sys.maxint
# Prepare series config
ordered_series = []
for key, serie in self.series.iteritems():
serie_config = ChartConfig()
serie_config.__dict__.update(config.__dict__)
serie_config.__dict__.update(serie)
ordered_series.append((serie_config.order, key, serie))
ordered_series.sort(cmp=lambda x, y: cmp(x[0], y[0]))
ordered_keys = []
for order, key, serie in ordered_series:
ordered_keys.append(key)
# Draws for each serie
index = 0
for order, key, serie in ordered_series:
serie_config = ChartConfig()
serie_config.__dict__.update(config.__dict__)
serie_config.__dict__.update(serie)
serie_data = copy.copy(
data[key.split('.')[0]]['series'][key.split('.')[1]])
measure = key.split('.')[0]
if flat(serie_data): # Series with all data = None
continue
if serie_config.accumulate:
serie_data = accumulate(serie_data)
elif serie_config.interpolate:
serie_data = interpolate(serie_data)
# Compute min and max value for the serie and the whole chart
min_data = amin(serie_data)
chart_min = rmin(chart_min, min_data)
if serie_data.__contains__(min_data):
min_index = serie_data.index(min_data)
else:
min_index = None
max_data = max(serie_data)
chart_max = max(chart_max, max_data)
if serie_data.__contains__(max_data):
max_index = serie_data.index(max_data)
else:
max_index = None
(serie_data, min_index,
max_index) = compress_to(serie_data, config.nval, min_index,
max_index)
chart.add_data(serie_data)
colors.append(_valid_color(serie_config.color))
if serie_config.max and not max_index == None:
max_config = ChartConfig()
max_config.__dict__.update(serie_config.__dict__)
max_config.__dict__.update(serie_config.max)
str_max_data = str(
round(converter.convert(measure, max_data), 1))
chart.add_marker(index, max_index, 't' + str_max_data,
_valid_color(max_config.text),
max_config.size)
chart.add_marker(index, max_index, max_config.style,
_valid_color(max_config.color),
max_config.thickness)
if serie_config.min and not min_index == None:
min_config = ChartConfig()
min_config.__dict__.update(serie_config.__dict__)
min_config.__dict__.update(serie_config.min)
str_min_data = str(
round(converter.convert(measure, min_data), 1))
chart.add_marker(index, min_index, 't' + str_min_data,
_valid_color(min_config.text),
min_config.size)
chart.add_marker(index, min_index, min_config.style,
_valid_color(min_config.color),
min_config.thickness)
if serie_config.last:
last_config = ChartConfig()
last_config.__dict__.update(serie_config.__dict__)
last_config.__dict__.update(serie_config.last)
last_index = len(serie_data) - 1
last_data = serie_data[last_index]
if last_data:
str_last_data = str(
round(converter.convert(measure, last_data), 1))
chart.add_marker(index, last_index, 't' + str(last_data),
_valid_color(last_config.text),
last_config.size)
chart.add_marker(index, last_index, last_config.style,
_valid_color(last_config.color),
last_config.thickness)
if serie_config.area:
fill_config = ChartConfig()
fill_config.__dict__.update(serie_config.__dict__)
fill_config.__dict__.update(serie_config.area)
to = ordered_keys.index(fill_config.to)
chart.add_fill_range(_valid_color(fill_config.color), index,
to)
if serie_config.dash:
chart.set_line_style(index, serie_config.thickness,
serie_config.dash, serie_config.dash)
else:
chart.set_line_style(index, serie_config.thickness)
if serie_config.legend:
legend.append(serie_config.legend)
legend_set = True
else:
legend.append('')
if serie_config.marks:
mark_config = ChartConfig()
mark_config.__dict__.update(serie_config.__dict__)
mark_config.__dict__.update(serie_config.marks)
mark_data = copy.copy(data[mark_config.serie.split(
'.')[0]]['series'][mark_config.serie.split('.')[1]])
mark_data = compress_to(mark_data, config.nval, min_index,
max_index)[0]
for i, m in enumerate(mark_data):
if not m:
mark_data[i] = " "
density = max(
1.0, 1.0 * mark_config.space * len("".join(mark_data)) *
mark_config.size / config.width)
for i, v in enumerate(mark_data):
if (i + 1) % round(density) == 0:
if serie_data[i] != 0:
text = str(mark_data[i])
else:
text = " "
chart.add_marker(index, i, 't' + text,
_valid_color(mark_config.color),
mark_config.size)
index = index + 1
# Compute vertical range
if config.axes:
range_min_ref_units = 0
if not chart_min == sys.maxint and not chart_max == -sys.maxint:
range_min = chart_min - config.ymargin[0]
range_max = chart_max + config.ymargin[1]
range_min_target_units = math.floor(
converter.convert(measure, range_min))
range_max_target_units = math.ceil(
converter.convert(measure, range_max))
range_min_ref_units = converter.convert_back(
measure, range_min_target_units)
range_max_ref_units = converter.convert_back(
measure, range_max_target_units)
self.logger.debug("Y range: " + str(range_min_target_units) +
" " + str(range_max_target_units))
chart.set_axis_range(Axis.LEFT, range_min_target_units,
range_max_target_units + 1)
chart.add_data([range_min_ref_units, range_max_ref_units])
colors.append("00000000")
else:
chart.set_axis_range(Axis.LEFT, 0, 100)
chart.set_axis_style(
0, _valid_color(config.text), config.size, 0,
Axis.BOTH if config.ticks else Axis.AXIS_LINES)
else:
chart.set_axis_labels(Axis.LEFT, [])
chart.set_axis_style(0, _valid_color(config.text), config.size, 0,
Axis.TICK_MARKS, _valid_color(config.bgcolor))
if config.zero and config.axes and range_min_ref_units < 0 and range_max_ref_units > 0:
zero_config = ChartConfig()
zero_config.__dict__.update(config.__dict__)
zero_config.__dict__.update(config.zero)
chart.add_data([0] * 2)
colors.append(_valid_color(zero_config.color))
chart.set_line_style(index, zero_config.thickness)
chart.set_colours(colors)
chart.fill_solid(Chart.BACKGROUND, _valid_color(config.bgcolor))
if legend_set:
chart.set_legend(legend)
chart.set_legend_position(config.legend_pos)
if self.labels:
labels_data = copy.copy(data[self.labels.split('.')[0]]['series'][
self.labels.split('.')[1]])
labels_data = compress_to(labels_data, config.nval, None, None)[0]
if config.axes:
density = 1.0 * len(
"".join(labels_data)) * config.size / config.width
if density > LABEL_DENSITY_THRESHOLD:
for i, v in enumerate(labels_data):
if i % round(density) != 0:
labels_data[i] = ' '
chart.set_axis_labels(Axis.BOTTOM, labels_data)
chart.set_axis_style(
1, _valid_color(config.text), config.size, 0,
Axis.BOTH if config.ticks else Axis.AXIS_LINES)
else:
chart.set_axis_labels(Axis.BOTTOM, [])
chart.set_axis_style(1, _valid_color(config.text), config.size,
0, Axis.TICK_MARKS,
_valid_color(config.color))
try:
return chart.get_url() + "&chma=10,10,10,10" # add a margin
except:
self.logger.exception("Could not render chart")
return "http://chart.apis.google.com/chart?cht=lc&chs=" + str(
config.width) + "x" + str(config.height)
