To get this branch, use:
bzr branch
http://gegoxaren.bato24.eu/bzr/%2Bjunk/pygooglechart-py3k
« back to all changes in this revision
Viewing changes to pygooglechart.py
- browse files at revision 7
- compare with another revision
- download diff
- download tarball
- view history from revision 7
- Committer: gak
- Date: 2007-12-13 22:35:59 UTC
- Revision ID: git-v1:a7ad1afe3f08b7de8b3a3cbdc7165d4f88ddbe92
version bump, added BadContentTypeException, added a few examples, added COPYING licence, code is more PEP8 friendly, download() checks for content type and raises on bad http codes, add_data returns the index of the dataset, Line doesn't allow being an instance.
added
removed
pygooglechart.py
1
"""
2
PyGoogleChart - A complete Python wrapper for the Google Chart API
3
4
http://pygooglechart.slowchop.com/
5
6
Copyright 2007 Gerald Kaszuba
7
8
This program is free software: you can redistribute it and/or modify
9
it under the terms of the GNU General Public License as published by
10
the Free Software Foundation, either version 3 of the License, or
11
(at your option) any later version.
12
13
This program is distributed in the hope that it will be useful,
14
but WITHOUT ANY WARRANTY; without even the implied warranty of
15
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16
GNU General Public License for more details.
17
18
You should have received a copy of the GNU General Public License
19
along with this program. If not, see <http://www.gnu.org/licenses/>.
20
21
"""
22
23
import os
24
import urllib
25
import urllib2
26
import math
27
import random
28
import re
29
30
# Helper variables and functions
31
# -----------------------------------------------------------------------------
32
33
__version__ = '0.2.0'
34
35
reo_colour = re.compile('^([A-Fa-f0-9]{2,2}){3,4}$')
36
37
38
def _check_colour(colour):
39
if not reo_colour.match(colour):
40
raise InvalidParametersException('Colours need to be in ' \
41
'RRGGBB or RRGGBBAA format. One of your colours has %s' % \
42
colour)
43
44
# Exception Classes
45
# -----------------------------------------------------------------------------
46
47
48
class PyGoogleChartException(Exception):
49
pass
50
51
52
class DataOutOfRangeException(PyGoogleChartException):
53
pass
54
55
56
class UnknownDataTypeException(PyGoogleChartException):
57
pass
58
59
60
class NoDataGivenException(PyGoogleChartException):
61
pass
62
63
64
class InvalidParametersException(PyGoogleChartException):
65
pass
66
67
68
class BadContentTypeException(PyGoogleChartException):
69
pass
70
71
72
# Data Classes
73
# -----------------------------------------------------------------------------
74
75
76
class Data(object):
77
78
def __init__(self, data):
79
assert(type(self) != Data) # This is an abstract class
80
self.data = data
81
82
@classmethod
83
def float_scale_value(cls, value, range):
84
lower, upper = range
85
max_value = cls.max_value()
86
scaled = (value-lower) * (float(max_value)/(upper-lower))
87
return scaled
88
89
@classmethod
90
def clip_value(cls, value):
91
clipped = max(0, min(value, cls.max_value()))
92
return clipped
93
94
@classmethod
95
def int_scale_value(cls, value, range):
96
scaled = int(round(cls.float_scale_value(value, range)))
97
return scaled
98
99
@classmethod
100
def scale_value(cls, value, range):
101
scaled = cls.int_scale_value(value, range)
102
clipped = cls.clip_value(scaled)
103
return clipped
104
105
class SimpleData(Data):
106
enc_map = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
107
108
def __repr__(self):
109
max_value = self.max_value()
110
encoded_data = []
111
for data in self.data:
112
sub_data = []
113
for value in data:
114
if value is None:
115
sub_data.append('_')
116
elif value >= 0 and value <= max_value:
117
sub_data.append(SimpleData.enc_map[value])
118
else:
119
raise DataOutOfRangeException('cannot encode value: %d'
120
% value)
121
encoded_data.append(''.join(sub_data))
122
return 'chd=s:' + ','.join(encoded_data)
123
124
@staticmethod
125
def max_value():
126
return 61
127
128
class TextData(Data):
129
130
def __repr__(self):
131
max_value = self.max_value()
132
encoded_data = []
133
for data in self.data:
134
sub_data = []
135
for value in data:
136
if value is None:
137
sub_data.append(-1)
138
elif value >= 0 and value <= max_value:
139
sub_data.append("%.1f" % float(value))
140
else:
141
raise DataOutOfRangeException()
142
encoded_data.append(','.join(sub_data))
143
return 'chd=t:' + '|'.join(encoded_data)
144
145
@staticmethod
146
def max_value():
147
return 100
148
149
@classmethod
150
def scale_value(cls, value, range):
151
lower, upper = range
152
if upper > lower:
153
max_value = cls.max_value()
154
scaled = (float(value) - lower) * max_value / upper
155
clipped = max(0, min(scaled, max_value))
156
return clipped
157
else:
158
return lower
159
160
@classmethod
161
def scale_value(cls, value, range):
162
# use float values instead of integers because we don't need an encode
163
# map index
164
scaled = cls.float_scale_value(value,range)
165
clipped = cls.clip_value(scaled)
166
return clipped
167
168
class ExtendedData(Data):
169
enc_map = \
170
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-.'
171
172
def __repr__(self):
173
max_value = self.max_value()
174
encoded_data = []
175
enc_size = len(ExtendedData.enc_map)
176
for data in self.data:
177
sub_data = []
178
for value in data:
179
if value is None:
180
sub_data.append('__')
181
elif value >= 0 and value <= max_value:
182
first, second = divmod(int(value), enc_size)
183
sub_data.append('%s%s' % (
184
ExtendedData.enc_map[first],
185
ExtendedData.enc_map[second]))
186
else:
187
raise DataOutOfRangeException( \
188
'Item #%i "%s" is out of range' % (data.index(value), \
189
value))
190
encoded_data.append(''.join(sub_data))
191
return 'chd=e:' + ','.join(encoded_data)
192
193
@staticmethod
194
def max_value():
195
return 4095
196
197
198
# Axis Classes
199
# -----------------------------------------------------------------------------
200
201
202
class Axis(object):
203
BOTTOM = 'x'
204
TOP = 't'
205
LEFT = 'y'
206
RIGHT = 'r'
207
TYPES = (BOTTOM, TOP, LEFT, RIGHT)
208
209
def __init__(self, axis_index, axis_type, **kw):
210
assert(axis_type in Axis.TYPES)
211
self.has_style = False
212
self.axis_index = axis_index
213
self.axis_type = axis_type
214
self.positions = None
215
216
def set_index(self, axis_index):
217
self.axis_index = axis_index
218
219
def set_positions(self, positions):
220
self.positions = positions
221
222
def set_style(self, colour, font_size=None, alignment=None):
223
_check_colour(colour)
224
self.colour = colour
225
self.font_size = font_size
226
self.alignment = alignment
227
self.has_style = True
228
229
def style_to_url(self):
230
bits = []
231
bits.append(str(self.axis_index))
232
bits.append(self.colour)
233
if self.font_size is not None:
234
bits.append(str(self.font_size))
235
if self.alignment is not None:
236
bits.append(str(self.alignment))
237
return ','.join(bits)
238
239
def positions_to_url(self):
240
bits = []
241
bits.append(str(self.axis_index))
242
bits += [str(a) for a in self.positions]
243
return ','.join(bits)
244
245
246
class LabelAxis(Axis):
247
248
def __init__(self, axis_index, axis_type, values, **kwargs):
249
Axis.__init__(self, axis_index, axis_type, **kwargs)
250
self.values = [str(a) for a in values]
251
252
def __repr__(self):
253
return '%i:|%s' % (self.axis_index, '|'.join(self.values))
254
255
256
class RangeAxis(Axis):
257
258
def __init__(self, axis_index, axis_type, low, high, **kwargs):
259
Axis.__init__(self, axis_index, axis_type, **kwargs)
260
self.low = low
261
self.high = high
262
263
def __repr__(self):
264
return '%i,%s,%s' % (self.axis_index, self.low, self.high)
265
266
# Chart Classes
267
# -----------------------------------------------------------------------------
268
269
270
class Chart(object):
271
"""Abstract class for all chart types.
272
273
width are height specify the dimensions of the image. title sets the title
274
of the chart. legend requires a list that corresponds to datasets.
275
"""
276
277
BASE_URL = 'http://chart.apis.google.com/chart?'
278
BACKGROUND = 'bg'
279
CHART = 'c'
280
ALPHA = 'a'
281
VALID_SOLID_FILL_TYPES = (BACKGROUND, CHART, ALPHA)
282
SOLID = 's'
283
LINEAR_GRADIENT = 'lg'
284
LINEAR_STRIPES = 'ls'
285
286
def __init__(self, width, height, title=None, legend=None, colours=None,
287
auto_scale=True, x_range=None, y_range=None):
288
assert(type(self) != Chart) # This is an abstract class
289
assert(isinstance(width, int))
290
assert(isinstance(height, int))
291
self.width = width
292
self.height = height
293
self.data = []
294
self.set_title(title)
295
self.set_legend(legend)
296
self.set_colours(colours)
297
298
# Data for scaling.
299
self.auto_scale = auto_scale # Whether to automatically scale data
300
self.x_range = x_range # (min, max) x-axis range for scaling
301
self.y_range = y_range # (min, max) y-axis range for scaling
302
self.scaled_data_class = None
303
self.scaled_x_range = None
304
self.scaled_y_range = None
305
306
self.fill_types = {
307
Chart.BACKGROUND: None,
308
Chart.CHART: None,
309
Chart.ALPHA: None,
310
}
311
self.fill_area = {
312
Chart.BACKGROUND: None,
313
Chart.CHART: None,
314
Chart.ALPHA: None,
315
}
316
self.axis = []
317
self.markers = []
318
self.line_styles = {}
319
self.grid = None
320
321
# URL generation
322
# -------------------------------------------------------------------------
323
324
def get_url(self, data_class=None):
325
url_bits = self.get_url_bits(data_class=data_class)
326
return self.BASE_URL + '&'.join(url_bits)
327
328
def get_url_bits(self, data_class=None):
329
url_bits = []
330
# required arguments
331
url_bits.append(self.type_to_url())
332
url_bits.append('chs=%ix%i' % (self.width, self.height))
333
url_bits.append(self.data_to_url(data_class=data_class))
334
# optional arguments
335
if self.title:
336
url_bits.append('chtt=%s' % self.title)
337
if self.legend:
338
url_bits.append('chdl=%s' % '|'.join(self.legend))
339
if self.colours:
340
url_bits.append('chco=%s' % ','.join(self.colours))
341
ret = self.fill_to_url()
342
if ret:
343
url_bits.append(ret)
344
ret = self.axis_to_url()
345
if ret:
346
url_bits.append(ret)
347
if self.markers:
348
url_bits.append(self.markers_to_url())
349
if self.line_styles:
350
style = []
351
for index in xrange(max(self.line_styles) + 1):
352
if index in self.line_styles:
353
values = self.line_styles[index]
354
else:
355
values = ('1', )
356
style.append(','.join(values))
357
url_bits.append('chls=%s' % '|'.join(style))
358
if self.grid:
359
url_bits.append('chg=%s' % self.grid)
360
return url_bits
361
362
# Downloading
363
# -------------------------------------------------------------------------
364
365
def download(self, file_name):
366
opener = urllib2.urlopen(self.get_url())
367
368
if opener.headers['content-type'] != 'image/png':
369
raise BadContentTypeException('Server responded with a ' \
370
'content-type of %s' % opener.headers['content-type'])
371
372
open(file_name, 'wb').write(urllib.urlopen(self.get_url()).read())
373
374
# Simple settings
375
# -------------------------------------------------------------------------
376
377
def set_title(self, title):
378
if title:
379
self.title = urllib.quote(title)
380
else:
381
self.title = None
382
383
def set_legend(self, legend):
384
"""legend needs to be a list, tuple or None"""
385
assert(isinstance(legend, list) or isinstance(legend, tuple) or
386
legend is None)
387
if legend:
388
self.legend = [urllib.quote(a) for a in legend]
389
else:
390
self.legend = None
391
392
# Chart colours
393
# -------------------------------------------------------------------------
394
395
def set_colours(self, colours):
396
# colours needs to be a list, tuple or None
397
assert(isinstance(colours, list) or isinstance(colours, tuple) or
398
colours is None)
399
# make sure the colours are in the right format
400
if colours:
401
for col in colours:
402
_check_colour(col)
403
self.colours = colours
404
405
# Background/Chart colours
406
# -------------------------------------------------------------------------
407
408
def fill_solid(self, area, colour):
409
assert(area in Chart.VALID_SOLID_FILL_TYPES)
410
_check_colour(colour)
411
self.fill_area[area] = colour
412
self.fill_types[area] = Chart.SOLID
413
414
def _check_fill_linear(self, angle, *args):
415
assert(isinstance(args, list) or isinstance(args, tuple))
416
assert(angle >= 0 and angle <= 90)
417
assert(len(args) % 2 == 0)
418
args = list(args) # args is probably a tuple and we need to mutate
419
for a in xrange(len(args) / 2):
420
col = args[a * 2]
421
offset = args[a * 2 + 1]
422
_check_colour(col)
423
assert(offset >= 0 and offset <= 1)
424
args[a * 2 + 1] = str(args[a * 2 + 1])
425
return args
426
427
def fill_linear_gradient(self, area, angle, *args):
428
assert(area in Chart.VALID_SOLID_FILL_TYPES)
429
args = self._check_fill_linear(angle, *args)
430
self.fill_types[area] = Chart.LINEAR_GRADIENT
431
self.fill_area[area] = ','.join([str(angle)] + args)
432
433
def fill_linear_stripes(self, area, angle, *args):
434
assert(area in Chart.VALID_SOLID_FILL_TYPES)
435
args = self._check_fill_linear(angle, *args)
436
self.fill_types[area] = Chart.LINEAR_STRIPES
437
self.fill_area[area] = ','.join([str(angle)] + args)
438
439
def fill_to_url(self):
440
areas = []
441
for area in (Chart.BACKGROUND, Chart.CHART, Chart.ALPHA):
442
if self.fill_types[area]:
443
areas.append('%s,%s,%s' % (area, self.fill_types[area], \
444
self.fill_area[area]))
445
if areas:
446
return 'chf=' + '|'.join(areas)
447
448
# Data
449
# -------------------------------------------------------------------------
450
451
def data_class_detection(self, data):
452
"""Determines the appropriate data encoding type to give satisfactory
453
resolution (http://code.google.com/apis/chart/#chart_data).
454
"""
455
assert(isinstance(data, list) or isinstance(data, tuple))
456
if not isinstance(self, (LineChart, BarChart, ScatterChart)):
457
# From the link above:
458
# Simple encoding is suitable for all other types of chart
459
# regardless of size.
460
return SimpleData
461
elif self.height < 100:
462
# The link above indicates that line and bar charts less
463
# than 300px in size can be suitably represented with the
464
# simple encoding. I've found that this isn't sufficient,
465
# e.g. examples/line-xy-circle.png. Let's try 100px.
466
return SimpleData
467
else:
468
return ExtendedData
469
470
def data_x_range(self):
471
"""Return a 2-tuple giving the minimum and maximum x-axis
472
data range.
473
"""
474
try:
475
lower = min([min(s) for type, s in self.annotated_data()
476
if type == 'x'])
477
upper = max([max(s) for type, s in self.annotated_data()
478
if type == 'x'])
479
return (lower, upper)
480
except ValueError:
481
return None # no x-axis datasets
482
483
def data_y_range(self):
484
"""Return a 2-tuple giving the minimum and maximum y-axis
485
data range.
486
"""
487
try:
488
lower = min([min(s) for type, s in self.annotated_data()
489
if type == 'y'])
490
upper = max([max(s) for type, s in self.annotated_data()
491
if type == 'y'])
492
return (lower, upper)
493
except ValueError:
494
return None # no y-axis datasets
495
496
def scaled_data(self, data_class, x_range=None, y_range=None):
497
"""Scale `self.data` as appropriate for the given data encoding
498
(data_class) and return it.
499
500
An optional `y_range` -- a 2-tuple (lower, upper) -- can be
501
given to specify the y-axis bounds. If not given, the range is
502
inferred from the data: (0, <max-value>) presuming no negative
503
values, or (<min-value>, <max-value>) if there are negative
504
values. `self.scaled_y_range` is set to the actual lower and
505
upper scaling range.
506
507
Ditto for `x_range`. Note that some chart types don't have x-axis
508
data.
509
"""
510
self.scaled_data_class = data_class
511
512
# Determine the x-axis range for scaling.
513
if x_range is None:
514
x_range = self.data_x_range()
515
if x_range and x_range[0] > 0:
516
x_range = (0, x_range[1])
517
self.scaled_x_range = x_range
518
519
# Determine the y-axis range for scaling.
520
if y_range is None:
521
y_range = self.data_y_range()
522
if y_range and y_range[0] > 0:
523
y_range = (0, y_range[1])
524
self.scaled_y_range = y_range
525
526
scaled_data = []
527
for type, dataset in self.annotated_data():
528
if type == 'x':
529
scale_range = x_range
530
elif type == 'y':
531
scale_range = y_range
532
elif type == 'marker-size':
533
scale_range = (0, max(dataset))
534
scaled_data.append([data_class.scale_value(v, scale_range)
535
for v in dataset])
536
return scaled_data
537
538
def add_data(self, data):
539
self.data.append(data)
540
return len(self.data) - 1 # return the "index" of the data set
541
542
def data_to_url(self, data_class=None):
543
if not data_class:
544
data_class = self.data_class_detection(self.data)
545
if not issubclass(data_class, Data):
546
raise UnknownDataTypeException()
547
if self.auto_scale:
548
data = self.scaled_data(data_class, self.x_range, self.y_range)
549
else:
550
data = self.data
551
return repr(data_class(data))
552
553
def annotated_data(self):
554
for dataset in self.data:
555
yield ('x', dataset)
556
557
# Axis Labels
558
# -------------------------------------------------------------------------
559
560
def set_axis_labels(self, axis_type, values):
561
assert(axis_type in Axis.TYPES)
562
values = [ urllib.quote(a) for a in values ]
563
axis_index = len(self.axis)
564
axis = LabelAxis(axis_index, axis_type, values)
565
self.axis.append(axis)
566
return axis_index
567
568
def set_axis_range(self, axis_type, low, high):
569
assert(axis_type in Axis.TYPES)
570
axis_index = len(self.axis)
571
axis = RangeAxis(axis_index, axis_type, low, high)
572
self.axis.append(axis)
573
return axis_index
574
575
def set_axis_positions(self, axis_index, positions):
576
try:
577
self.axis[axis_index].set_positions(positions)
578
except IndexError:
579
raise InvalidParametersException('Axis index %i has not been ' \
580
'created' % axis)
581
582
def set_axis_style(self, axis_index, colour, font_size=None, \
583
alignment=None):
584
try:
585
self.axis[axis_index].set_style(colour, font_size, alignment)
586
except IndexError:
587
raise InvalidParametersException('Axis index %i has not been ' \
588
'created' % axis)
589
590
def axis_to_url(self):
591
available_axis = []
592
label_axis = []
593
range_axis = []
594
positions = []
595
styles = []
596
index = -1
597
for axis in self.axis:
598
available_axis.append(axis.axis_type)
599
if isinstance(axis, RangeAxis):
600
range_axis.append(repr(axis))
601
if isinstance(axis, LabelAxis):
602
label_axis.append(repr(axis))
603
if axis.positions:
604
positions.append(axis.positions_to_url())
605
if axis.has_style:
606
styles.append(axis.style_to_url())
607
if not available_axis:
608
return
609
url_bits = []
610
url_bits.append('chxt=%s' % ','.join(available_axis))
611
if label_axis:
612
url_bits.append('chxl=%s' % '|'.join(label_axis))
613
if range_axis:
614
url_bits.append('chxr=%s' % '|'.join(range_axis))
615
if positions:
616
url_bits.append('chxp=%s' % '|'.join(positions))
617
if styles:
618
url_bits.append('chxs=%s' % '|'.join(styles))
619
return '&'.join(url_bits)
620
621
# Markers, Ranges and Fill area (chm)
622
# -------------------------------------------------------------------------
623
624
def markers_to_url(self):
625
return 'chm=%s' % '|'.join([','.join(a) for a in self.markers])
626
627
def add_marker(self, index, point, marker_type, colour, size, priority=0):
628
self.markers.append((marker_type, colour, str(index), str(point), \
629
str(size), str(priority)))
630
631
def add_horizontal_range(self, colour, start, stop):
632
self.markers.append(('r', colour, '1', str(start), str(stop)))
633
634
def add_vertical_range(self, colour, start, stop):
635
self.markers.append(('R', colour, '1', str(start), str(stop)))
636
637
def add_fill_range(self, colour, index_start, index_end):
638
self.markers.append(('b', colour, str(index_start), str(index_end), \
639
'1'))
640
641
def add_fill_simple(self, colour):
642
self.markers.append(('B', colour, '1', '1', '1'))
643
644
# Line styles
645
# -------------------------------------------------------------------------
646
647
def set_line_style(self, index, thickness=1, line_segment=None, \
648
blank_segment=None):
649
value = []
650
value.append(str(thickness))
651
if line_segment:
652
value.append(str(line_segment))
653
value.append(str(blank_segment))
654
self.line_styles[index] = value
655
656
# Grid
657
# -------------------------------------------------------------------------
658
659
def set_grid(self, x_step, y_step, line_segment=1, \
660
blank_segment=0):
661
self.grid = '%s,%s,%s,%s' % (x_step, y_step, line_segment, \
662
blank_segment)
663
664
665
class ScatterChart(Chart):
666
667
def type_to_url(self):
668
return 'cht=s'
669
670
def annotated_data(self):
671
yield ('x', self.data[0])
672
yield ('y', self.data[1])
673
if len(self.data) > 2:
674
# The optional third dataset is relative sizing for point
675
# markers.
676
yield ('marker-size', self.data[2])
677
678
class LineChart(Chart):
679
680
def __init__(self, *args, **kwargs):
681
assert(type(self) != LineChart) # This is an abstract class
682
Chart.__init__(self, *args, **kwargs)
683
684
# def get_url_bits(self, data_class=None):
685
# url_bits = Chart.get_url_bits(self, data_class=data_class)
686
# return url_bits
687
688
689
class SimpleLineChart(LineChart):
690
691
def type_to_url(self):
692
return 'cht=lc'
693
694
def annotated_data(self):
695
# All datasets are y-axis data.
696
for dataset in self.data:
697
yield ('y', dataset)
698
699
class SparkLineChart(SimpleLineChart):
700
701
def type_to_url(self):
702
return 'cht=ls'
703
704
class XYLineChart(LineChart):
705
706
def type_to_url(self):
707
return 'cht=lxy'
708
709
def annotated_data(self):
710
# Datasets alternate between x-axis, y-axis.
711
for i, dataset in enumerate(self.data):
712
if i % 2 == 0:
713
yield ('x', dataset)
714
else:
715
yield ('y', dataset)
716
717
class BarChart(Chart):
718
719
def __init__(self, *args, **kwargs):
720
assert(type(self) != BarChart) # This is an abstract class
721
Chart.__init__(self, *args, **kwargs)
722
self.bar_width = None
723
self.zero_lines = {}
724
725
def set_bar_width(self, bar_width):
726
self.bar_width = bar_width
727
728
def set_zero_line(self, index, zero_line):
729
self.zero_lines[index] = zero_line
730
731
def get_url_bits(self, data_class=None, skip_chbh=False):
732
url_bits = Chart.get_url_bits(self, data_class=data_class)
733
if not skip_chbh and self.bar_width is not None:
734
url_bits.append('chbh=%i' % self.bar_width)
735
zero_line = []
736
if self.zero_lines:
737
for index in xrange(max(self.zero_lines) + 1):
738
if index in self.zero_lines:
739
zero_line.append(str(self.zero_lines[index]))
740
else:
741
zero_line.append('0')
742
url_bits.append('chp=%s' % ','.join(zero_line))
743
return url_bits
744
745
746
class StackedHorizontalBarChart(BarChart):
747
748
def type_to_url(self):
749
return 'cht=bhs'
750
751
752
class StackedVerticalBarChart(BarChart):
753
754
def type_to_url(self):
755
return 'cht=bvs'
756
757
def annotated_data(self):
758
for dataset in self.data:
759
yield ('y', dataset)
760
761
762
class GroupedBarChart(BarChart):
763
764
def __init__(self, *args, **kwargs):
765
assert(type(self) != GroupedBarChart) # This is an abstract class
766
BarChart.__init__(self, *args, **kwargs)
767
self.bar_spacing = None
768
self.group_spacing = None
769
770
def set_bar_spacing(self, spacing):
771
"""Set spacing between bars in a group."""
772
self.bar_spacing = spacing
773
774
def set_group_spacing(self, spacing):
775
"""Set spacing between groups of bars."""
776
self.group_spacing = spacing
777
778
def get_url_bits(self, data_class=None):
779
# Skip 'BarChart.get_url_bits' and call Chart directly so the parent
780
# doesn't add "chbh" before we do.
781
url_bits = BarChart.get_url_bits(self, data_class=data_class,
782
skip_chbh=True)
783
if self.group_spacing is not None:
784
if self.bar_spacing is None:
785
raise InvalidParametersException('Bar spacing is required to ' \
786
'be set when setting group spacing')
787
if self.bar_width is None:
788
raise InvalidParametersException('Bar width is required to ' \
789
'be set when setting bar spacing')
790
url_bits.append('chbh=%i,%i,%i'
791
% (self.bar_width, self.bar_spacing, self.group_spacing))
792
elif self.bar_spacing is not None:
793
if self.bar_width is None:
794
raise InvalidParametersException('Bar width is required to ' \
795
'be set when setting bar spacing')
796
url_bits.append('chbh=%i,%i' % (self.bar_width, self.bar_spacing))
797
elif self.bar_width:
798
url_bits.append('chbh=%i' % self.bar_width)
799
return url_bits
800
801
802
class GroupedHorizontalBarChart(GroupedBarChart):
803
804
def type_to_url(self):
805
return 'cht=bhg'
806
807
808
class GroupedVerticalBarChart(GroupedBarChart):
809
810
def type_to_url(self):
811
return 'cht=bvg'
812
813
def annotated_data(self):
814
for dataset in self.data:
815
yield ('y', dataset)
816
817
818
class PieChart(Chart):
819
820
def __init__(self, *args, **kwargs):
821
assert(type(self) != PieChart) # This is an abstract class
822
Chart.__init__(self, *args, **kwargs)
823
self.pie_labels = []
824
825
def set_pie_labels(self, labels):
826
self.pie_labels = [urllib.quote(a) for a in labels]
827
828
def get_url_bits(self, data_class=None):
829
url_bits = Chart.get_url_bits(self, data_class=data_class)
830
if self.pie_labels:
831
url_bits.append('chl=%s' % '|'.join(self.pie_labels))
832
return url_bits
833
834
def annotated_data(self):
835
# Datasets are all y-axis data. However, there should only be
836
# one dataset for pie charts.
837
for dataset in self.data:
838
yield ('y', dataset)
839
840
841
class PieChart2D(PieChart):
842
843
def type_to_url(self):
844
return 'cht=p'
845
846
847
class PieChart3D(PieChart):
848
849
def type_to_url(self):
850
return 'cht=p3'
851
852
853
class VennChart(Chart):
854
855
def type_to_url(self):
856
return 'cht=v'
857
858
def annotated_data(self):
859
for dataset in self.data:
860
yield ('y', dataset)
861
862
863
class RadarChart(Chart):
864
865
def type_to_url(self):
866
return 'cht=r'
867
868
class SplineRadarChart(RadarChart):
869
870
def type_to_url(self):
871
return 'cht=rs'
872
873
874
class MapChart(Chart):
875
876
def __init__(self, *args, **kwargs):
877
Chart.__init__(self, *args, **kwargs)
878
self.geo_area = 'world'
879
self.codes = []
880
881
def type_to_url(self):
882
return 'cht=t'
883
884
def set_codes(self, codes):
885
self.codes = codes
886
887
def get_url_bits(self, data_class=None):
888
url_bits = Chart.get_url_bits(self, data_class=data_class)
889
url_bits.append('chtm=%s' % self.geo_area)
890
if self.codes:
891
url_bits.append('chld=%s' % ''.join(self.codes))
892
return url_bits
893
894
895
class GoogleOMeterChart(PieChart):
896
"""Inheriting from PieChart because of similar labeling"""
897
898
def type_to_url(self):
899
return 'cht=gom'
900
901
902
def test():
903
chart = PieChart2D(320, 200)
904
chart = ScatterChart(320, 200)
905
chart = SimpleLineChart(320, 200)
906
chart = GroupedVerticalBarChart(320, 200)
907
# chart = SplineRadarChart(500, 500)
908
# chart = MapChart(440, 220)
909
# chart = GoogleOMeterChart(440, 220, x_range=(0, 100))
910
sine_data = [math.sin(float(a) / math.pi) * 100 for a in xrange(100)]
911
random_data = [random.random() * 100 for a in xrange(100)]
912
random_data2 = [random.random() * 50 for a in xrange(100)]
913
# chart.set_bar_width(50)
914
# chart.set_bar_spacing(0)
915
chart.add_data(sine_data)
916
chart.add_data(random_data)
917
chart.set_zero_line(1, .5)
918
# chart.add_data(random_data2)
919
# chart.set_line_style(0, thickness=5)
920
# chart.set_line_style(1, thickness=2, line_segment=10, blank_segment=5)
921
# chart.set_title('heloooo weeee')
922
# chart.set_legend(('sine wave', 'random * x'))
923
chart.set_colours(('ee2000', 'DDDDAA', 'fF03f2'))
924
# chart.fill_solid(Chart.ALPHA, '123456')
925
# chart.fill_linear_gradient(Chart.ALPHA, 20, '004070', 1, '300040', 0,
926
# 'aabbcc55', 0.5)
927
# chart.fill_linear_stripes(Chart.CHART, 20, '204070', .2, '300040', .2,
928
# 'aabbcc00', 0.2)
929
# axis_left_index = chart.set_axis_range(Axis.LEFT, 0, 10)
930
# axis_right_index = chart.set_axis_range(Axis.RIGHT, 5, 30)
931
# axis_bottom_index = chart.set_axis_labels(Axis.BOTTOM, [1, 25, 95])
932
# chart.set_axis_positions(axis_bottom_index, [1, 25, 95])
933
# chart.set_axis_style(axis_bottom_index, '003050', 15)
934
935
# chart.set_pie_labels(('apples', 'oranges', 'bananas'))
936
937
# chart.set_grid(10, 10)
938
# for a in xrange(0, 100, 10):
939
# chart.add_marker(1, a, 'a', 'AACA20', 10)
940
941
# chart.add_horizontal_range('00A020', .2, .5)
942
# chart.add_vertical_range('00c030', .2, .4)
943
944
# chart.add_fill_simple('303030A0')
945
946
# chart.set_codes(['AU', 'AT', 'US'])
947
# chart.add_data([1,2,3])
948
# chart.set_colours(('EEEEEE', '000000', '00FF00'))
949
950
# chart.add_data([50,75])
951
# chart.set_pie_labels(('apples', 'oranges'))
952
953
url = chart.get_url()
954
print url
955
956
chart.download('test.png')
957
958
if 1:
959
data = urllib.urlopen(chart.get_url()).read()
960
open('meh.png', 'wb').write(data)
961
os.system('eog meh.png')
962
963
964
if __name__ == '__main__':
965
test()
966
1
"""
2
PyGoogleChart - A complete Python wrapper for the Google Chart API
3
4
http://pygooglechart.slowchop.com/
5
6
Copyright 2007 Gerald Kaszuba
7
8
This program is free software: you can redistribute it and/or modify
9
it under the terms of the GNU General Public License as published by
10
the Free Software Foundation, either version 3 of the License, or
11
(at your option) any later version.
12
13
This program is distributed in the hope that it will be useful,
14
but WITHOUT ANY WARRANTY; without even the implied warranty of
15
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16
GNU General Public License for more details.
17
18
You should have received a copy of the GNU General Public License
19
along with this program. If not, see <http://www.gnu.org/licenses/>.
20
21
"""
22
23
import os
24
import urllib
25
import urllib2
26
import math
27
import random
28
import re
29
30
# Helper variables and functions
31
# -----------------------------------------------------------------------------
32
33
reo_colour = re.compile('^([A-Fa-f0-9]{2,2}){3,4}$')
34
35
36
def _check_colour(colour):
37
if not reo_colour.match(colour):
38
raise InvalidParametersException('Colours need to be in ' \
39
'RRGGBB or RRGGBBAA format. One of your colours has %s' % \
40
colour)
41
42
# Exception Classes
43
# -----------------------------------------------------------------------------
44
45
46
class PyGoogleChartException(Exception):
47
pass
48
49
50
class DataOutOfRangeException(PyGoogleChartException):
51
pass
52
53
54
class UnknownDataTypeException(PyGoogleChartException):
55
pass
56
57
58
class NoDataGivenException(PyGoogleChartException):
59
pass
60
61
62
class InvalidParametersException(PyGoogleChartException):
63
pass
64
65
66
class BadContentTypeException(PyGoogleChartException):
67
pass
68
69
70
# Data Classes
71
# -----------------------------------------------------------------------------
72
73
74
class Data(object):
75
76
def __init__(self, data):
77
assert(type(self) != Data) # This is an abstract class
78
self.data = data
79
80
81
class SimpleData(Data):
82
enc_map = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
83
84
def __repr__(self):
85
encoded_data = []
86
for data in self.data:
87
sub_data = []
88
for value in data:
89
if value is None:
90
sub_data.append('_')
91
elif value >= 0 and value <= SimpleData.max_value:
92
sub_data.append(SimpleData.enc_map[value])
93
else:
94
raise DataOutOfRangeException()
95
encoded_data.append(''.join(sub_data))
96
return 'chd=s:' + ','.join(encoded_data)
97
98
@staticmethod
99
def max_value():
100
return 61
101
102
103
class TextData(Data):
104
105
def __repr__(self):
106
encoded_data = []
107
for data in self.data:
108
sub_data = []
109
for value in data:
110
if value is None:
111
sub_data.append(-1)
112
elif value >= 0 and value <= TextData.max_value:
113
sub_data.append(str(float(value)))
114
else:
115
raise DataOutOfRangeException()
116
encoded_data.append(','.join(sub_data))
117
return 'chd=t:' + '|'.join(encoded_data)
118
119
@staticmethod
120
def max_value():
121
return 100
122
123
124
class ExtendedData(Data):
125
enc_map = \
126
'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-.'
127
128
def __repr__(self):
129
encoded_data = []
130
enc_size = len(ExtendedData.enc_map)
131
for data in self.data:
132
sub_data = []
133
for value in data:
134
if value is None:
135
sub_data.append('__')
136
elif value >= 0 and value <= ExtendedData.max_value:
137
first, second = divmod(int(value), enc_size)
138
sub_data.append('%s%s' % (
139
ExtendedData.enc_map[first],
140
ExtendedData.enc_map[second]))
141
else:
142
raise DataOutOfRangeException( \
143
'Item #%i "%s" is out of range' % (data.index(value), \
144
value))
145
encoded_data.append(''.join(sub_data))
146
return 'chd=e:' + ','.join(encoded_data)
147
148
@staticmethod
149
def max_value():
150
return 4095
151
152
# Axis Classes
153
# -----------------------------------------------------------------------------
154
155
156
class Axis(object):
157
BOTTOM = 'x'
158
TOP = 't'
159
LEFT = 'y'
160
RIGHT = 'r'
161
TYPES = (BOTTOM, TOP, LEFT, RIGHT)
162
163
def __init__(self, axis, **kw):
164
assert(axis in Axis.TYPES)
165
self.has_style = False
166
self.index = None
167
self.positions = None
168
169
def set_index(self, index):
170
self.index = index
171
172
def set_positions(self, positions):
173
self.positions = positions
174
175
def set_style(self, colour, font_size=None, alignment=None):
176
_check_colour(colour)
177
self.colour = colour
178
self.font_size = font_size
179
self.alignment = alignment
180
self.has_style = True
181
182
def style_to_url(self):
183
bits = []
184
bits.append(str(self.index))
185
bits.append(self.colour)
186
if self.font_size is not None:
187
bits.append(str(self.font_size))
188
if self.alignment is not None:
189
bits.append(str(self.alignment))
190
return ','.join(bits)
191
192
def positions_to_url(self):
193
bits = []
194
bits.append(str(self.index))
195
bits += [str(a) for a in self.positions]
196
return ','.join(bits)
197
198
199
class LabelAxis(Axis):
200
201
def __init__(self, axis, values, **kwargs):
202
Axis.__init__(self, axis, **kwargs)
203
self.values = [str(a) for a in values]
204
205
def __repr__(self):
206
return '%i:|%s' % (self.index, '|'.join(self.values))
207
208
209
class RangeAxis(Axis):
210
211
def __init__(self, axis, low, high, **kwargs):
212
Axis.__init__(self, axis, **kwargs)
213
self.low = low
214
self.high = high
215
216
def __repr__(self):
217
return '%i,%s,%s' % (self.index, self.low, self.high)
218
219
# Chart Classes
220
# -----------------------------------------------------------------------------
221
222
223
class Chart(object):
224
"""Abstract class for all chart types.
225
226
width are height specify the dimensions of the image. title sets the title
227
of the chart. legend requires a list that corresponds to datasets.
228
"""
229
230
BASE_URL = 'http://chart.apis.google.com/chart?'
231
BACKGROUND = 'bg'
232
CHART = 'c'
233
SOLID = 's'
234
LINEAR_GRADIENT = 'lg'
235
LINEAR_STRIPES = 'ls'
236
237
def __init__(self, width, height, title=None, legend=None, colours=None):
238
assert(type(self) != Chart) # This is an abstract class
239
assert(isinstance(width, int))
240
assert(isinstance(height, int))
241
self.width = width
242
self.height = height
243
self.data = []
244
self.set_title(title)
245
self.set_legend(legend)
246
self.set_colours(colours)
247
self.fill_types = {
248
Chart.BACKGROUND: None,
249
Chart.CHART: None,
250
}
251
self.fill_area = {
252
Chart.BACKGROUND: None,
253
Chart.CHART: None,
254
}
255
self.axis = {
256
Axis.TOP: None,
257
Axis.BOTTOM: None,
258
Axis.LEFT: None,
259
Axis.RIGHT: None,
260
}
261
self.markers = []
262
263
# URL generation
264
# -------------------------------------------------------------------------
265
266
def get_url(self):
267
url_bits = self.get_url_bits()
268
return self.BASE_URL + '&'.join(url_bits)
269
270
def get_url_bits(self):
271
url_bits = []
272
# required arguments
273
url_bits.append(self.type_to_url())
274
url_bits.append('chs=%ix%i' % (self.width, self.height))
275
url_bits.append(self.data_to_url())
276
# optional arguments
277
if self.title:
278
url_bits.append('chtt=%s' % self.title)
279
if self.legend:
280
url_bits.append('chdl=%s' % '|'.join(self.legend))
281
if self.colours:
282
url_bits.append('chco=%s' % ','.join(self.colours))
283
ret = self.fill_to_url()
284
if ret:
285
url_bits.append(ret)
286
ret = self.axis_to_url()
287
if ret:
288
url_bits.append(ret)
289
if self.markers:
290
url_bits.append(self.markers_to_url())
291
return url_bits
292
293
# Downloading
294
# -------------------------------------------------------------------------
295
296
def download(self, file_name):
297
opener = urllib2.urlopen(self.get_url())
298
299
if opener.headers['content-type'] != 'image/png':
300
raise BadContentTypeException('Server responded with a ' \
301
'content-type of %s' % opener.headers['content-type'])
302
303
open(file_name, 'wb').write(urllib.urlopen(self.get_url()).read())
304
305
# Simple settings
306
# -------------------------------------------------------------------------
307
308
def set_title(self, title):
309
if title:
310
self.title = urllib.quote(title)
311
else:
312
self.title = None
313
314
def set_legend(self, legend):
315
# legend needs to be a list, tuple or None
316
assert(isinstance(legend, list) or isinstance(legend, tuple) or
317
legend is None)
318
if legend:
319
self.legend = [urllib.quote(a) for a in legend]
320
else:
321
self.legend = None
322
323
# Chart colours
324
# -------------------------------------------------------------------------
325
326
def set_colours(self, colours):
327
# colours needs to be a list, tuple or None
328
assert(isinstance(colours, list) or isinstance(colours, tuple) or
329
colours is None)
330
# make sure the colours are in the right format
331
if colours:
332
for col in colours:
333
_check_colour(col)
334
self.colours = colours
335
336
# Background/Chart colours
337
# -------------------------------------------------------------------------
338
339
def fill_solid(self, area, colour):
340
assert(area in (Chart.BACKGROUND, Chart.CHART))
341
_check_colour(colour)
342
self.fill_area[area] = colour
343
self.fill_types[area] = Chart.SOLID
344
345
def _check_fill_linear(self, angle, *args):
346
assert(isinstance(args, list) or isinstance(args, tuple))
347
assert(angle >= 0 and angle <= 90)
348
assert(len(args) % 2 == 0)
349
args = list(args) # args is probably a tuple and we need to mutate
350
for a in xrange(len(args) / 2):
351
col = args[a * 2]
352
offset = args[a * 2 + 1]
353
_check_colour(col)
354
assert(offset >= 0 and offset <= 1)
355
args[a * 2 + 1] = str(args[a * 2 + 1])
356
return args
357
358
def fill_linear_gradient(self, area, angle, *args):
359
assert(area in (Chart.BACKGROUND, Chart.CHART))
360
args = self._check_fill_linear(angle, *args)
361
self.fill_types[area] = Chart.LINEAR_GRADIENT
362
self.fill_area[area] = ','.join([str(angle)] + args)
363
364
def fill_linear_stripes(self, area, angle, *args):
365
assert(area in (Chart.BACKGROUND, Chart.CHART))
366
args = self._check_fill_linear(angle, *args)
367
self.fill_types[area] = Chart.LINEAR_STRIPES
368
self.fill_area[area] = ','.join([str(angle)] + args)
369
370
def fill_to_url(self):
371
areas = []
372
for area in (Chart.BACKGROUND, Chart.CHART):
373
if self.fill_types[area]:
374
areas.append('%s,%s,%s' % (area, self.fill_types[area], \
375
self.fill_area[area]))
376
if areas:
377
return 'chf=' + '|'.join(areas)
378
379
# Data
380
# -------------------------------------------------------------------------
381
382
def data_class_detection(self, data):
383
"""
384
Detects and returns the data type required based on the range of the
385
data given. The data given must be lists of numbers within a list.
386
"""
387
assert(isinstance(data, list) or isinstance(data, tuple))
388
max_value = None
389
for a in data:
390
assert(isinstance(a, list) or isinstance(a, tuple))
391
if max_value is None or max(a) > max_value:
392
max_value = max(a)
393
for data_class in (SimpleData, TextData, ExtendedData):
394
if max_value <= data_class.max_value():
395
return data_class
396
raise DataOutOfRangeException()
397
398
def add_data(self, data):
399
self.data.append(data)
400
return len(self.data) - 1 # return the "index" of the data set
401
402
def data_to_url(self, data_class=None):
403
if not data_class:
404
data_class = self.data_class_detection(self.data)
405
if not issubclass(data_class, Data):
406
raise UnknownDataTypeException()
407
return repr(data_class(self.data))
408
409
# Axis Labels
410
# -------------------------------------------------------------------------
411
412
def set_axis_labels(self, axis, values):
413
assert(axis in Axis.TYPES)
414
self.axis[axis] = LabelAxis(axis, values)
415
416
def set_axis_range(self, axis, low, high):
417
assert(axis in Axis.TYPES)
418
self.axis[axis] = RangeAxis(axis, low, high)
419
420
def set_axis_positions(self, axis, positions):
421
assert(axis in Axis.TYPES)
422
if not self.axis[axis]:
423
raise InvalidParametersException('Please create an axis first')
424
self.axis[axis].set_positions(positions)
425
426
def set_axis_style(self, axis, colour, font_size=None, alignment=None):
427
assert(axis in Axis.TYPES)
428
if not self.axis[axis]:
429
raise InvalidParametersException('Please create an axis first')
430
self.axis[axis].set_style(colour, font_size, alignment)
431
432
def axis_to_url(self):
433
available_axis = []
434
label_axis = []
435
range_axis = []
436
positions = []
437
styles = []
438
index = -1
439
for position, axis in self.axis.items():
440
if not axis:
441
continue
442
index += 1
443
axis.set_index(index)
444
available_axis.append(position)
445
if isinstance(axis, RangeAxis):
446
range_axis.append(repr(axis))
447
if isinstance(axis, LabelAxis):
448
label_axis.append(repr(axis))
449
if axis.positions:
450
positions.append(axis.positions_to_url())
451
if axis.has_style:
452
styles.append(axis.style_to_url())
453
if not available_axis:
454
return
455
url_bits = []
456
url_bits.append('chxt=%s' % ','.join(available_axis))
457
if label_axis:
458
url_bits.append('chxl=%s' % '|'.join(label_axis))
459
if range_axis:
460
url_bits.append('chxr=%s' % '|'.join(range_axis))
461
if positions:
462
url_bits.append('chxp=%s' % '|'.join(positions))
463
if styles:
464
url_bits.append('chxs=%s' % '|'.join(styles))
465
return '&'.join(url_bits)
466
467
# Markers, Ranges and Fill area (chm)
468
# -------------------------------------------------------------------------
469
470
def markers_to_url(self):
471
return 'chm=%s' % '|'.join([','.join(a) for a in self.markers])
472
473
def add_marker(self, index, point, marker_type, colour, size):
474
self.markers.append((marker_type, colour, str(index), str(point), \
475
str(size)))
476
477
def add_horizontal_range(self, colour, start, stop):
478
self.markers.append(('r', colour, '1', str(start), str(stop)))
479
480
def add_vertical_range(self, colour, start, stop):
481
self.markers.append(('R', colour, '1', str(start), str(stop)))
482
483
def add_fill_range(self, colour, index_start, index_end):
484
self.markers.append(('b', colour, str(index_start), str(index_end), \
485
'1'))
486
487
def add_fill_simple(self, colour):
488
self.markers.append(('B', colour, '1', '1', '1'))
489
490
491
class ScatterChart(Chart):
492
493
def __init__(self, *args, **kwargs):
494
Chart.__init__(self, *args, **kwargs)
495
496
def type_to_url(self):
497
return 'cht=s'
498
499
500
class LineChart(Chart):
501
502
def __init__(self, *args, **kwargs):
503
assert(type(self) != LineChart) # This is an abstract class
504
Chart.__init__(self, *args, **kwargs)
505
self.line_styles = {}
506
self.grid = None
507
508
def set_line_style(self, index, thickness=1, line_segment=None, \
509
blank_segment=None):
510
value = []
511
value.append(str(thickness))
512
if line_segment:
513
value.append(str(line_segment))
514
value.append(str(blank_segment))
515
self.line_styles[index] = value
516
517
def set_grid(self, x_step, y_step, line_segment=1, \
518
blank_segment=0):
519
self.grid = '%s,%s,%s,%s' % (x_step, y_step, line_segment, \
520
blank_segment)
521
522
def get_url_bits(self):
523
url_bits = Chart.get_url_bits(self)
524
if self.line_styles:
525
style = []
526
# for index, values in self.line_style.items():
527
for index in xrange(max(self.line_styles) + 1):
528
if index in self.line_styles:
529
values = self.line_styles[index]
530
else:
531
values = ('1', )
532
style.append(','.join(values))
533
url_bits.append('chls=%s' % '|'.join(style))
534
if self.grid:
535
url_bits.append('chg=%s' % self.grid)
536
return url_bits
537
538
539
class SimpleLineChart(LineChart):
540
541
def type_to_url(self):
542
return 'cht=lc'
543
544
545
class XYLineChart(LineChart):
546
547
def type_to_url(self):
548
return 'cht=lxy'
549
550
551
class BarChart(Chart):
552
553
def __init__(self, *args, **kwargs):
554
assert(type(self) != BarChart) # This is an abstract class
555
Chart.__init__(self, *args, **kwargs)
556
self.bar_width = None
557
558
def set_bar_width(self, bar_width):
559
self.bar_width = bar_width
560
561
def get_url_bits(self):
562
url_bits = Chart.get_url_bits(self)
563
url_bits.append('chbh=%i' % self.bar_width)
564
return url_bits
565
566
567
class StackedHorizontalBarChart(BarChart):
568
569
def type_to_url(self):
570
return 'cht=bhs'
571
572
573
class StackedVerticalBarChart(BarChart):
574
575
def type_to_url(self):
576
return 'cht=bvs'
577
578
579
class GroupedBarChart(BarChart):
580
581
def __init__(self, *args, **kwargs):
582
assert(type(self) != GroupedBarChart) # This is an abstract class
583
BarChart.__init__(self, *args, **kwargs)
584
self.bar_spacing = None
585
586
def set_bar_spacing(self, spacing):
587
self.bar_spacing = spacing
588
589
def get_url_bits(self):
590
# Skip 'BarChart.get_url_bits' and call Chart directly so the parent
591
# doesn't add "chbh" before we do.
592
url_bits = Chart.get_url_bits(self)
593
if self.bar_spacing is not None:
594
if self.bar_width is None:
595
raise InvalidParametersException('Bar width is required to ' \
596
'be set when setting spacing')
597
url_bits.append('chbh=%i,%i' % (self.bar_width, self.bar_spacing))
598
else:
599
url_bits.append('chbh=%i' % self.bar_width)
600
return url_bits
601
602
603
class GroupedHorizontalBarChart(GroupedBarChart):
604
605
def type_to_url(self):
606
return 'cht=bhg'
607
608
609
class GroupedVerticalBarChart(GroupedBarChart):
610
611
def type_to_url(self):
612
return 'cht=bvg'
613
614
615
class PieChart(Chart):
616
617
def __init__(self, *args, **kwargs):
618
assert(type(self) != PieChart) # This is an abstract class
619
Chart.__init__(self, *args, **kwargs)
620
self.pie_labels = []
621
622
def set_pie_labels(self, labels):
623
self.pie_labels = labels
624
625
def get_url_bits(self):
626
url_bits = Chart.get_url_bits(self)
627
if self.pie_labels:
628
url_bits.append('chl=%s' % '|'.join(self.pie_labels))
629
return url_bits
630
631
632
class PieChart2D(PieChart):
633
634
def type_to_url(self):
635
return 'cht=p'
636
637
638
class PieChart3D(PieChart):
639
640
def type_to_url(self):
641
return 'cht=p3'
642
643
644
class VennChart(Chart):
645
646
def type_to_url(self):
647
return 'cht=v'
648
649
650
def test():
651
chart = GroupedVerticalBarChart(320, 200)
652
chart = PieChart2D(320, 200)
653
chart = ScatterChart(320, 200)
654
chart = SimpleLineChart(320, 200)
655
sine_data = [math.sin(float(a) / 10) * 2000 + 2000 for a in xrange(100)]
656
random_data = [a * random.random() * 30 for a in xrange(40)]
657
random_data2 = [random.random() * 4000 for a in xrange(10)]
658
# chart.set_bar_width(50)
659
# chart.set_bar_spacing(0)
660
chart.add_data(sine_data)
661
chart.add_data(random_data)
662
chart.add_data(random_data2)
663
# chart.set_line_style(1, thickness=2)
664
# chart.set_line_style(2, line_segment=10, blank_segment=5)
665
# chart.set_title('heloooo')
666
# chart.set_legend(('sine wave', 'random * x'))
667
# chart.set_colours(('ee2000', 'DDDDAA', 'fF03f2'))
668
# chart.fill_solid(Chart.BACKGROUND, '123456')
669
# chart.fill_linear_gradient(Chart.CHART, 20, '004070', 1, '300040', 0,
670
# 'aabbcc00', 0.5)
671
# chart.fill_linear_stripes(Chart.CHART, 20, '204070', .2, '300040', .2,
672
# 'aabbcc00', 0.2)
673
chart.set_axis_range(Axis.LEFT, 0, 10)
674
chart.set_axis_range(Axis.RIGHT, 5, 30)
675
chart.set_axis_labels(Axis.BOTTOM, [1, 25, 95])
676
chart.set_axis_positions(Axis.BOTTOM, [1, 25, 95])
677
chart.set_axis_style(Axis.BOTTOM, 'FFFFFF', 15)
678
679
# chart.set_pie_labels(('apples', 'oranges', 'bananas'))
680
681
# chart.set_grid(10, 10)
682
683
# for a in xrange(0, 100, 10):
684
# chart.add_marker(1, a, 'a', 'AACA20', 10)
685
686
chart.add_horizontal_range('00A020', .2, .5)
687
chart.add_vertical_range('00c030', .2, .4)
688
689
chart.add_fill_simple('303030A0')
690
691
chart.download('test.png')
692
693
url = chart.get_url()
694
print url
695
if 0:
696
data = urllib.urlopen(chart.get_url()).read()
697
open('meh.png', 'wb').write(data)
698
os.system('start meh.png')
699
700
701
if __name__ == '__main__':
702
test()
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0