diff options
Diffstat (limited to 'stats')
| -rw-r--r-- | stats/pygooglechart.py | 1066 | ||||
| -rw-r--r-- | stats/stats.py | 50 |
2 files changed, 1116 insertions, 0 deletions
diff --git a/stats/pygooglechart.py b/stats/pygooglechart.py new file mode 100644 index 0000000..0c17973 --- /dev/null +++ b/stats/pygooglechart.py @@ -0,0 +1,1066 @@ +""" +pygooglechart - A complete Python wrapper for the Google Chart API + +http://pygooglechart.slowchop.com/ + +Copyright 2007-2008 Gerald Kaszuba + +This program is free software: you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation, either version 3 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program. If not, see <http://www.gnu.org/licenses/>. + +""" + +import os +import urllib +import urllib2 +import math +import random +import re +import warnings +import copy + +# Helper variables and functions +# ----------------------------------------------------------------------------- + +__version__ = '0.2.1' +__author__ = 'Gerald Kaszuba' + +reo_colour = re.compile('^([A-Fa-f0-9]{2,2}){3,4}$') + +def _check_colour(colour): + if not reo_colour.match(colour): + raise InvalidParametersException('Colours need to be in ' \ + 'RRGGBB or RRGGBBAA format. One of your colours has %s' % \ + colour) + + +def _reset_warnings(): + """Helper function to reset all warnings. Used by the unit tests.""" + globals()['__warningregistry__'] = None + + +# Exception Classes +# ----------------------------------------------------------------------------- + + +class PyGoogleChartException(Exception): + pass + + +class DataOutOfRangeException(PyGoogleChartException): + pass + + +class UnknownDataTypeException(PyGoogleChartException): + pass + + +class NoDataGivenException(PyGoogleChartException): + pass + + +class InvalidParametersException(PyGoogleChartException): + pass + + +class BadContentTypeException(PyGoogleChartException): + pass + + +class AbstractClassException(PyGoogleChartException): + pass + + +class UnknownChartType(PyGoogleChartException): + pass + + +# Data Classes +# ----------------------------------------------------------------------------- + + +class Data(object): + + def __init__(self, data): + if type(self) == Data: + raise AbstractClassException('This is an abstract class') + self.data = data + + @classmethod + def float_scale_value(cls, value, range): + lower, upper = range + assert(upper > lower) + scaled = (value - lower) * (float(cls.max_value) / (upper - lower)) + return scaled + + @classmethod + def clip_value(cls, value): + return max(0, min(value, cls.max_value)) + + @classmethod + def int_scale_value(cls, value, range): + return int(round(cls.float_scale_value(value, range))) + + @classmethod + def scale_value(cls, value, range): + scaled = cls.int_scale_value(value, range) + clipped = cls.clip_value(scaled) + Data.check_clip(scaled, clipped) + return clipped + + @staticmethod + def check_clip(scaled, clipped): + if clipped != scaled: + warnings.warn('One or more of of your data points has been ' + 'clipped because it is out of range.') + + +class SimpleData(Data): + + max_value = 61 + enc_map = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789' + + def __repr__(self): + encoded_data = [] + for data in self.data: + sub_data = [] + for value in data: + if value is None: + sub_data.append('_') + elif value >= 0 and value <= self.max_value: + sub_data.append(SimpleData.enc_map[value]) + else: + raise DataOutOfRangeException('cannot encode value: %d' + % value) + encoded_data.append(''.join(sub_data)) + return 'chd=s:' + ','.join(encoded_data) + + +class TextData(Data): + + max_value = 100 + + def __repr__(self): + encoded_data = [] + for data in self.data: + sub_data = [] + for value in data: + if value is None: + sub_data.append(-1) + elif value >= 0 and value <= self.max_value: + sub_data.append("%.1f" % float(value)) + else: + raise DataOutOfRangeException() + encoded_data.append(','.join(sub_data)) + return 'chd=t:' + '|'.join(encoded_data) + + @classmethod + def scale_value(cls, value, range): + # use float values instead of integers because we don't need an encode + # map index + scaled = cls.float_scale_value(value, range) + clipped = cls.clip_value(scaled) + Data.check_clip(scaled, clipped) + return clipped + + +class ExtendedData(Data): + + max_value = 4095 + enc_map = \ + 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-.' + + def __repr__(self): + encoded_data = [] + enc_size = len(ExtendedData.enc_map) + for data in self.data: + sub_data = [] + for value in data: + if value is None: + sub_data.append('__') + elif value >= 0 and value <= self.max_value: + first, second = divmod(int(value), enc_size) + sub_data.append('%s%s' % ( + ExtendedData.enc_map[first], + ExtendedData.enc_map[second])) + else: + raise DataOutOfRangeException( \ + 'Item #%i "%s" is out of range' % (data.index(value), \ + value)) + encoded_data.append(''.join(sub_data)) + return 'chd=e:' + ','.join(encoded_data) + + +# Axis Classes +# ----------------------------------------------------------------------------- + + +class Axis(object): + + BOTTOM = 'x' + TOP = 't' + LEFT = 'y' + RIGHT = 'r' + TYPES = (BOTTOM, TOP, LEFT, RIGHT) + + def __init__(self, axis_index, axis_type, **kw): + assert(axis_type in Axis.TYPES) + self.has_style = False + self.axis_index = axis_index + self.axis_type = axis_type + self.positions = None + + def set_index(self, axis_index): + self.axis_index = axis_index + + def set_positions(self, positions): + self.positions = positions + + def set_style(self, colour, font_size=None, alignment=None): + _check_colour(colour) + self.colour = colour + self.font_size = font_size + self.alignment = alignment + self.has_style = True + + def style_to_url(self): + bits = [] + bits.append(str(self.axis_index)) + bits.append(self.colour) + if self.font_size is not None: + bits.append(str(self.font_size)) + if self.alignment is not None: + bits.append(str(self.alignment)) + return ','.join(bits) + + def positions_to_url(self): + bits = [] + bits.append(str(self.axis_index)) + bits += [str(a) for a in self.positions] + return ','.join(bits) + + +class LabelAxis(Axis): + + def __init__(self, axis_index, axis_type, values, **kwargs): + Axis.__init__(self, axis_index, axis_type, **kwargs) + self.values = [str(a) for a in values] + + def __repr__(self): + return '%i:|%s' % (self.axis_index, '|'.join(self.values)) + + +class RangeAxis(Axis): + + def __init__(self, axis_index, axis_type, low, high, **kwargs): + Axis.__init__(self, axis_index, axis_type, **kwargs) + self.low = low + self.high = high + + def __repr__(self): + return '%i,%s,%s' % (self.axis_index, self.low, self.high) + +# Chart Classes +# ----------------------------------------------------------------------------- + + +class Chart(object): + """Abstract class for all chart types. + + width are height specify the dimensions of the image. title sets the title + of the chart. legend requires a list that corresponds to datasets. + """ + + BASE_URL = 'http://chart.apis.google.com/chart?' + BACKGROUND = 'bg' + CHART = 'c' + ALPHA = 'a' + VALID_SOLID_FILL_TYPES = (BACKGROUND, CHART, ALPHA) + SOLID = 's' + LINEAR_GRADIENT = 'lg' + LINEAR_STRIPES = 'ls' + + def __init__(self, width, height, title=None, legend=None, colours=None, + auto_scale=True, x_range=None, y_range=None, + colours_within_series=None): + if type(self) == Chart: + raise AbstractClassException('This is an abstract class') + assert(isinstance(width, int)) + assert(isinstance(height, int)) + self.width = width + self.height = height + self.data = [] + self.set_title(title) + self.set_legend(legend) + self.set_legend_position(None) + self.set_colours(colours) + self.set_colours_within_series(colours_within_series) + + # Data for scaling. + self.auto_scale = auto_scale # Whether to automatically scale data + self.x_range = x_range # (min, max) x-axis range for scaling + self.y_range = y_range # (min, max) y-axis range for scaling + self.scaled_data_class = None + self.scaled_x_range = None + self.scaled_y_range = None + + self.fill_types = { + Chart.BACKGROUND: None, + Chart.CHART: None, + Chart.ALPHA: None, + } + self.fill_area = { + Chart.BACKGROUND: None, + Chart.CHART: None, + Chart.ALPHA: None, + } + self.axis = [] + self.markers = [] + self.line_styles = {} + self.grid = None + + # URL generation + # ------------------------------------------------------------------------- + + def get_url(self, data_class=None): + url_bits = self.get_url_bits(data_class=data_class) + return self.BASE_URL + '&'.join(url_bits) + + def get_url_bits(self, data_class=None): + url_bits = [] + # required arguments + url_bits.append(self.type_to_url()) + url_bits.append('chs=%ix%i' % (self.width, self.height)) + url_bits.append(self.data_to_url(data_class=data_class)) + # optional arguments + if self.title: + url_bits.append('chtt=%s' % self.title) + if self.legend: + url_bits.append('chdl=%s' % '|'.join(self.legend)) + if self.legend_position: + url_bits.append('chdlp=%s' % (self.legend_position)) + if self.colours: + url_bits.append('chco=%s' % ','.join(self.colours)) + if self.colours_within_series: + url_bits.append('chco=%s' % '|'.join(self.colours_within_series)) + ret = self.fill_to_url() + if ret: + url_bits.append(ret) + ret = self.axis_to_url() + if ret: + url_bits.append(ret) + if self.markers: + url_bits.append(self.markers_to_url()) + if self.line_styles: + style = [] + for index in xrange(max(self.line_styles) + 1): + if index in self.line_styles: + values = self.line_styles[index] + else: + values = ('1', ) + style.append(','.join(values)) + url_bits.append('chls=%s' % '|'.join(style)) + if self.grid: + url_bits.append('chg=%s' % self.grid) + return url_bits + + # Downloading + # ------------------------------------------------------------------------- + + def download(self, file_name): + opener = urllib2.urlopen(self.get_url()) + + if opener.headers['content-type'] != 'image/png': + raise BadContentTypeException('Server responded with a ' \ + 'content-type of %s' % opener.headers['content-type']) + + open(file_name, 'wb').write(opener.read()) + + # Simple settings + # ------------------------------------------------------------------------- + + def set_title(self, title): + if title: + self.title = urllib.quote(title) + else: + self.title = None + + def set_legend(self, legend): + """legend needs to be a list, tuple or None""" + assert(isinstance(legend, list) or isinstance(legend, tuple) or + legend is None) + if legend: + self.legend = [urllib.quote(a) for a in legend] + else: + self.legend = None + + def set_legend_position(self, legend_position): + if legend_position: + self.legend_position = urllib.quote(legend_position) + else: + self.legend_position = None + + # Chart colours + # ------------------------------------------------------------------------- + + def set_colours(self, colours): + # colours needs to be a list, tuple or None + assert(isinstance(colours, list) or isinstance(colours, tuple) or + colours is None) + # make sure the colours are in the right format + if colours: + for col in colours: + _check_colour(col) + self.colours = colours + + def set_colours_within_series(self, colours): + # colours needs to be a list, tuple or None + assert(isinstance(colours, list) or isinstance(colours, tuple) or + colours is None) + # make sure the colours are in the right format + if colours: + for col in colours: + _check_colour(col) + self.colours_within_series = colours + + # Background/Chart colours + # ------------------------------------------------------------------------- + + def fill_solid(self, area, colour): + assert(area in Chart.VALID_SOLID_FILL_TYPES) + _check_colour(colour) + self.fill_area[area] = colour + self.fill_types[area] = Chart.SOLID + + def _check_fill_linear(self, angle, *args): + assert(isinstance(args, list) or isinstance(args, tuple)) + assert(angle >= 0 and angle <= 90) + assert(len(args) % 2 == 0) + args = list(args) # args is probably a tuple and we need to mutate + for a in xrange(len(args) / 2): + col = args[a * 2] + offset = args[a * 2 + 1] + _check_colour(col) + assert(offset >= 0 and offset <= 1) + args[a * 2 + 1] = str(args[a * 2 + 1]) + return args + + def fill_linear_gradient(self, area, angle, *args): + assert(area in Chart.VALID_SOLID_FILL_TYPES) + args = self._check_fill_linear(angle, *args) + self.fill_types[area] = Chart.LINEAR_GRADIENT + self.fill_area[area] = ','.join([str(angle)] + args) + + def fill_linear_stripes(self, area, angle, *args): + assert(area in Chart.VALID_SOLID_FILL_TYPES) + args = self._check_fill_linear(angle, *args) + self.fill_types[area] = Chart.LINEAR_STRIPES + self.fill_area[area] = ','.join([str(angle)] + args) + + def fill_to_url(self): + areas = [] + for area in (Chart.BACKGROUND, Chart.CHART, Chart.ALPHA): + if self.fill_types[area]: + areas.append('%s,%s,%s' % (area, self.fill_types[area], \ + self.fill_area[area])) + if areas: + return 'chf=' + '|'.join(areas) + + # Data + # ------------------------------------------------------------------------- + + def data_class_detection(self, data): + """Determines the appropriate data encoding type to give satisfactory + resolution (http://code.google.com/apis/chart/#chart_data). + """ + assert(isinstance(data, list) or isinstance(data, tuple)) + if not isinstance(self, (LineChart, BarChart, ScatterChart)): + # From the link above: + # Simple encoding is suitable for all other types of chart + # regardless of size. + return SimpleData + elif self.height < 100: + # The link above indicates that line and bar charts less + # than 300px in size can be suitably represented with the + # simple encoding. I've found that this isn't sufficient, + # e.g. examples/line-xy-circle.png. Let's try 100px. + return SimpleData + else: + return ExtendedData + + def _filter_none(self, data): + return [r for r in data if r is not None] + + def data_x_range(self): + """Return a 2-tuple giving the minimum and maximum x-axis + data range. + """ + try: + lower = min([min(self._filter_none(s)) + for type, s in self.annotated_data() + if type == 'x']) + upper = max([max(self._filter_none(s)) + for type, s in self.annotated_data() + if type == 'x']) + return (lower, upper) + except ValueError: + return None # no x-axis datasets + + def data_y_range(self): + """Return a 2-tuple giving the minimum and maximum y-axis + data range. + """ + try: + lower = min([min(self._filter_none(s)) + for type, s in self.annotated_data() + if type == 'y']) + upper = max([max(self._filter_none(s)) + 1 + for type, s in self.annotated_data() + if type == 'y']) + return (lower, upper) + except ValueError: + return None # no y-axis datasets + + def scaled_data(self, data_class, x_range=None, y_range=None): + """Scale `self.data` as appropriate for the given data encoding + (data_class) and return it. + + An optional `y_range` -- a 2-tuple (lower, upper) -- can be + given to specify the y-axis bounds. If not given, the range is + inferred from the data: (0, <max-value>) presuming no negative + values, or (<min-value>, <max-value>) if there are negative + values. `self.scaled_y_range` is set to the actual lower and + upper scaling range. + + Ditto for `x_range`. Note that some chart types don't have x-axis + data. + """ + self.scaled_data_class = data_class + + # Determine the x-axis range for scaling. + if x_range is None: + x_range = self.data_x_range() + if x_range and x_range[0] > 0: + x_range = (x_range[0], x_range[1]) + self.scaled_x_range = x_range + + # Determine the y-axis range for scaling. + if y_range is None: + y_range = self.data_y_range() + if y_range and y_range[0] > 0: + y_range = (y_range[0], y_range[1]) + self.scaled_y_range = y_range + + scaled_data = [] + for type, dataset in self.annotated_data(): + if type == 'x': + scale_range = x_range + elif type == 'y': + scale_range = y_range + elif type == 'marker-size': + scale_range = (0, max(dataset)) + scaled_dataset = [] + for v in dataset: + if v is None: + scaled_dataset.append(None) + else: + scaled_dataset.append( + data_class.scale_value(v, scale_range)) + scaled_data.append(scaled_dataset) + return scaled_data + + def add_data(self, data): + self.data.append(data) + return len(self.data) - 1 # return the "index" of the data set + + def data_to_url(self, data_class=None): + if not data_class: + data_class = self.data_class_detection(self.data) + if not issubclass(data_class, Data): + raise UnknownDataTypeException() + if self.auto_scale: + data = self.scaled_data(data_class, self.x_range, self.y_range) + else: + data = self.data + return repr(data_class(data)) + + def annotated_data(self): + for dataset in self.data: + yield ('x', dataset) + + # Axis Labels + # ------------------------------------------------------------------------- + + def set_axis_labels(self, axis_type, values): + assert(axis_type in Axis.TYPES) + values = [urllib.quote(str(a)) for a in values] + axis_index = len(self.axis) + axis = LabelAxis(axis_index, axis_type, values) + self.axis.append(axis) + return axis_index + + def set_axis_range(self, axis_type, low, high): + assert(axis_type in Axis.TYPES) + axis_index = len(self.axis) + axis = RangeAxis(axis_index, axis_type, low, high) + self.axis.append(axis) + return axis_index + + def set_axis_positions(self, axis_index, positions): + try: + self.axis[axis_index].set_positions(positions) + except IndexError: + raise InvalidParametersException('Axis index %i has not been ' \ + 'created' % axis) + + def set_axis_style(self, axis_index, colour, font_size=None, \ + alignment=None): + try: + self.axis[axis_index].set_style(colour, font_size, alignment) + except IndexError: + raise InvalidParametersException('Axis index %i has not been ' \ + 'created' % axis) + + def axis_to_url(self): + available_axis = [] + label_axis = [] + range_axis = [] + positions = [] + styles = [] + index = -1 + for axis in self.axis: + available_axis.append(axis.axis_type) + if isinstance(axis, RangeAxis): + range_axis.append(repr(axis)) + if isinstance(axis, LabelAxis): + label_axis.append(repr(axis)) + if axis.positions: + positions.append(axis.positions_to_url()) + if axis.has_style: + styles.append(axis.style_to_url()) + if not available_axis: + return + url_bits = [] + url_bits.append('chxt=%s' % ','.join(available_axis)) + if label_axis: + url_bits.append('chxl=%s' % '|'.join(label_axis)) + if range_axis: + url_bits.append('chxr=%s' % '|'.join(range_axis)) + if positions: + url_bits.append('chxp=%s' % '|'.join(positions)) + if styles: + url_bits.append('chxs=%s' % '|'.join(styles)) + return '&'.join(url_bits) + + # Markers, Ranges and Fill area (chm) + # ------------------------------------------------------------------------- + + def markers_to_url(self): + return 'chm=%s' % '|'.join([','.join(a) for a in self.markers]) + + def add_marker(self, index, point, marker_type, colour, size, priority=0): + self.markers.append((marker_type, colour, str(index), str(point), \ + str(size), str(priority))) + + def add_horizontal_range(self, colour, start, stop): + self.markers.append(('r', colour, '0', str(start), str(stop))) + + def add_data_line(self, colour, data_set, size, priority=0): + self.markers.append(('D', colour, str(data_set), '0', str(size), str(priority))) + + def add_marker_text(self, string, colour, data_set, data_point, size, priority=0): + self.markers.append((str(string), colour, str(data_set), str(data_point), str(size), str(priority))) + + def add_vertical_range(self, colour, start, stop): + self.markers.append(('R', colour, '0', str(start), str(stop))) + + def add_fill_range(self, colour, index_start, index_end): + self.markers.append(('b', colour, str(index_start), str(index_end), \ + '1')) + + def add_fill_simple(self, colour): + self.markers.append(('B', colour, '1', '1', '1')) + + # Line styles + # ------------------------------------------------------------------------- + + def set_line_style(self, index, thickness=1, line_segment=None, \ + blank_segment=None): + value = [] + value.append(str(thickness)) + if line_segment: + value.append(str(line_segment)) + value.append(str(blank_segment)) + self.line_styles[index] = value + + # Grid + # ------------------------------------------------------------------------- + + def set_grid(self, x_step, y_step, line_segment=1, \ + blank_segment=0): + self.grid = '%s,%s,%s,%s' % (x_step, y_step, line_segment, \ + blank_segment) + + +class ScatterChart(Chart): + + def type_to_url(self): + return 'cht=s' + + def annotated_data(self): + yield ('x', self.data[0]) + yield ('y', self.data[1]) + if len(self.data) > 2: + # The optional third dataset is relative sizing for point + # markers. + yield ('marker-size', self.data[2]) + + +class LineChart(Chart): + + def __init__(self, *args, **kwargs): + if type(self) == LineChart: + raise AbstractClassException('This is an abstract class') + Chart.__init__(self, *args, **kwargs) + + +class SimpleLineChart(LineChart): + + def type_to_url(self): + return 'cht=lc' + + def annotated_data(self): + # All datasets are y-axis data. + for dataset in self.data: + yield ('y', dataset) + + +class SparkLineChart(SimpleLineChart): + + def type_to_url(self): + return 'cht=ls' + + +class XYLineChart(LineChart): + + def type_to_url(self): + return 'cht=lxy' + + def annotated_data(self): + # Datasets alternate between x-axis, y-axis. + for i, dataset in enumerate(self.data): + if i % 2 == 0: + yield ('x', dataset) + else: + yield ('y', dataset) + + +class BarChart(Chart): + + def __init__(self, *args, **kwargs): + if type(self) == BarChart: + raise AbstractClassException('This is an abstract class') + Chart.__init__(self, *args, **kwargs) + self.bar_width = None + self.zero_lines = {} + + def set_bar_width(self, bar_width): + self.bar_width = bar_width + + def set_zero_line(self, index, zero_line): + self.zero_lines[index] = zero_line + + def get_url_bits(self, data_class=None, skip_chbh=False): + url_bits = Chart.get_url_bits(self, data_class=data_class) + if not skip_chbh and self.bar_width is not None: + url_bits.append('chbh=%i' % self.bar_width) + zero_line = [] + if self.zero_lines: + for index in xrange(max(self.zero_lines) + 1): + if index in self.zero_lines: + zero_line.append(str(self.zero_lines[index])) + else: + zero_line.append('0') + url_bits.append('chp=%s' % ','.join(zero_line)) + return url_bits + + +class StackedHorizontalBarChart(BarChart): + + def type_to_url(self): + return 'cht=bhs' + + +class StackedVerticalBarChart(BarChart): + + def type_to_url(self): + return 'cht=bvs' + + def annotated_data(self): + for dataset in self.data: + yield ('y', dataset) + + +class GroupedBarChart(BarChart): + + def __init__(self, *args, **kwargs): + if type(self) == GroupedBarChart: + raise AbstractClassException('This is an abstract class') + BarChart.__init__(self, *args, **kwargs) + self.bar_spacing = None + self.group_spacing = None + + def set_bar_spacing(self, spacing): + """Set spacing between bars in a group.""" + self.bar_spacing = spacing + + def set_group_spacing(self, spacing): + """Set spacing between groups of bars.""" + self.group_spacing = spacing + + def get_url_bits(self, data_class=None): + # Skip 'BarChart.get_url_bits' and call Chart directly so the parent + # doesn't add "chbh" before we do. + url_bits = BarChart.get_url_bits(self, data_class=data_class, + skip_chbh=True) + if self.group_spacing is not None: + if self.bar_spacing is None: + raise InvalidParametersException('Bar spacing is required ' \ + 'to be set when setting group spacing') + if self.bar_width is None: + raise InvalidParametersException('Bar width is required to ' \ + 'be set when setting bar spacing') + url_bits.append('chbh=%i,%i,%i' + % (self.bar_width, self.bar_spacing, self.group_spacing)) + elif self.bar_spacing is not None: + if self.bar_width is None: + raise InvalidParametersException('Bar width is required to ' \ + 'be set when setting bar spacing') + url_bits.append('chbh=%i,%i' % (self.bar_width, self.bar_spacing)) + elif self.bar_width: + url_bits.append('chbh=%i' % self.bar_width) + return url_bits + + +class GroupedHorizontalBarChart(GroupedBarChart): + + def type_to_url(self): + return 'cht=bhg' + + +class GroupedVerticalBarChart(GroupedBarChart): + + def type_to_url(self): + return 'cht=bvg' + + def annotated_data(self): + for dataset in self.data: + yield ('y', dataset) + + +class PieChart(Chart): + + def __init__(self, *args, **kwargs): + if type(self) == PieChart: + raise AbstractClassException('This is an abstract class') + Chart.__init__(self, *args, **kwargs) + self.pie_labels = [] + if self.y_range: + warnings.warn('y_range is not used with %s.' % \ + (self.__class__.__name__)) + + def set_pie_labels(self, labels): + self.pie_labels = [urllib.quote(a) for a in labels] + + def get_url_bits(self, data_class=None): + url_bits = Chart.get_url_bits(self, data_class=data_class) + if self.pie_labels: + url_bits.append('chl=%s' % '|'.join(self.pie_labels)) + return url_bits + + def annotated_data(self): + # Datasets are all y-axis data. However, there should only be + # one dataset for pie charts. + for dataset in self.data: + yield ('x', dataset) + + def scaled_data(self, data_class, x_range=None, y_range=None): + if not x_range: + x_range = [0, sum(self.data[0])] + return Chart.scaled_data(self, data_class, x_range, self.y_range) + + +class PieChart2D(PieChart): + + def type_to_url(self): + return 'cht=p' + + +class PieChart3D(PieChart): + + def type_to_url(self): + return 'cht=p3' + + +class VennChart(Chart): + + def type_to_url(self): + return 'cht=v' + + def annotated_data(self): + for dataset in self.data: + yield ('y', dataset) + + +class RadarChart(Chart): + + def type_to_url(self): + return 'cht=r' + + +class SplineRadarChart(RadarChart): + + def type_to_url(self): + return 'cht=rs' + + +class MapChart(Chart): + + def __init__(self, *args, **kwargs): + Chart.__init__(self, *args, **kwargs) + self.geo_area = 'world' + self.codes = [] + + def type_to_url(self): + return 'cht=t' + + def set_codes(self, codes): + self.codes = codes + + def get_url_bits(self, data_class=None): + url_bits = Chart.get_url_bits(self, data_class=data_class) + url_bits.append('chtm=%s' % self.geo_area) + if self.codes: + url_bits.append('chld=%s' % ''.join(self.codes)) + return url_bits + + +class GoogleOMeterChart(PieChart): + """Inheriting from PieChart because of similar labeling""" + + def __init__(self, *args, **kwargs): + PieChart.__init__(self, *args, **kwargs) + if self.auto_scale and not self.x_range: + warnings.warn('Please specify an x_range with GoogleOMeterChart, ' + 'otherwise one arrow will always be at the max.') + + def type_to_url(self): + return 'cht=gom' + + +class QRChart(Chart): + + def __init__(self, *args, **kwargs): + Chart.__init__(self, *args, **kwargs) + self.encoding = None + self.ec_level = None + self.margin = None + + def type_to_url(self): + return 'cht=qr' + + def data_to_url(self, data_class=None): + if not self.data: + raise NoDataGivenException() + return 'chl=%s' % urllib.quote(self.data[0]) + + def get_url_bits(self, data_class=None): + url_bits = Chart.get_url_bits(self, data_class=data_class) + if self.encoding: + url_bits.append('choe=%s' % self.encoding) + if self.ec_level: + url_bits.append('chld=%s|%s' % (self.ec_level, self.margin)) + return url_bits + + def set_encoding(self, encoding): + self.encoding = encoding + + def set_ec(self, level, margin): + self.ec_level = level + self.margin = margin + + +class ChartGrammar(object): + + def __init__(self): + self.grammar = None + self.chart = None + + def parse(self, grammar): + self.grammar = grammar + self.chart = self.create_chart_instance() + + for attr in self.grammar: + if attr in ('w', 'h', 'type', 'auto_scale', 'x_range', 'y_range'): + continue # These are already parsed in create_chart_instance + attr_func = 'parse_' + attr + if not hasattr(self, attr_func): + warnings.warn('No parser for grammar attribute "%s"' % (attr)) + continue + getattr(self, attr_func)(grammar[attr]) + + return self.chart + + def parse_data(self, data): + self.chart.data = data + + @staticmethod + def get_possible_chart_types(): + possible_charts = [] + for cls_name in globals().keys(): + if not cls_name.endswith('Chart'): + continue + cls = globals()[cls_name] + # Check if it is an abstract class + try: + a = cls(1, 1, auto_scale=False) + del a + except AbstractClassException: + continue + # Strip off "Class" + possible_charts.append(cls_name[:-5]) + return possible_charts + + def create_chart_instance(self, grammar=None): + if not grammar: + grammar = self.grammar + assert(isinstance(grammar, dict)) # grammar must be a dict + assert('w' in grammar) # width is required + assert('h' in grammar) # height is required + assert('type' in grammar) # type is required + chart_type = grammar['type'] + w = grammar['w'] + h = grammar['h'] + auto_scale = grammar.get('auto_scale', None) + x_range = grammar.get('x_range', None) + y_range = grammar.get('y_range', None) + types = ChartGrammar.get_possible_chart_types() + if chart_type not in types: + raise UnknownChartType('%s is an unknown chart type. Possible ' + 'chart types are %s' % (chart_type, ','.join(types))) + return globals()[chart_type + 'Chart'](w, h, auto_scale=auto_scale, + x_range=x_range, y_range=y_range) + + def download(self): + pass + diff --git a/stats/stats.py b/stats/stats.py new file mode 100644 index 0000000..6eada02 --- /dev/null +++ b/stats/stats.py @@ -0,0 +1,50 @@ +#!/usr/bin/env python + +from pygooglechart import SimpleLineChart +from collections import defaultdict + +WIDTH = 600 +HEIGHT = 200 + +def main(): + data = {} + order = [] + snakes = [] + for line in open('../results.csv'): + game_id, name, length, life = line[:-1].split(',') + game_id = int(game_id) + length = int(length) + life = float(life) + + if name not in data: + snakes.append(name) + data[name] = {} + + if game_id not in order: + order.append(game_id) + + data[name][game_id] = (length, life) + + length_chart = SimpleLineChart(WIDTH, HEIGHT) + time_chart = SimpleLineChart(WIDTH, HEIGHT) + + for name in snakes: + time_series = [] + length_series = [] + + for game_id in order: + length, time = data[name].get(game_id, (None, None)) + time_series.append(time) + length_series.append(length) + + time_chart.add_data(time_series) + length_chart.add_data(length_series) + + length_chart.download('length_chart.png') + time_chart.download('time_chart.png') + + print 'Chart update!' + +if __name__ == '__main__': + main() + |