Python Whale.plotpoints方法代码示例

# 需要导入模块: from whale import Whale [as 别名]
# 或者: from whale.Whale import plotpoints [as 别名]
def plotpoints():
    whale = Whale()
    params = default_params()
    params['depth'] = g('depth', 0)
    params['period'] = g('period', None)
    params['flot_time'] = True
    return whale.plotpoints(**params)

    '''

# 需要导入模块: from whale import Whale [as 别名]
# 或者: from whale.Whale import plotpoints [as 别名]
def plotpoints():
    whale = Whale()
    params = default_params()
    params['depth'] = g('depth', 0)
    params['period'] = g('period', None)
    params['sort'] = g('sort', None)
    params['limit'] = g('limit', 10)
    params['tzoffset'] = g('tzoffset', 0.0)
    params['flot_time'] = True
    return whale.plotpoints(**params)

# 需要导入模块: from whale import Whale [as 别名]
# 或者: from whale.Whale import plotpoints [as 别名]
def graph():
    whale = Whale()
    points = whale.plotpoints(**default_params())
    params = {'script_tag': util.JS_TAG,
              'flotpoints': json.dumps(points),
              'random_name': 'graph_psuedorandom',
              }
    return """
<div id="%(random_name)s" style="width:97%%;height:97%%;">&nbsp;</div>
%(script_tag)s
<script type="text/javascript">
  dimensions = %(flotpoints)s;
  first_dimension = get_keys(dimensions)[0];
  first_metric = get_keys(dimensions[first_dimension])[0];
  //data = dimensions['[\"empty\"]']['hits'];
  data = dimensions[first_dimension][first_metric];
  $.plot($("#%(random_name)s"), [
    {data: data, lines: {show: true}},
  ], { xaxis: { mode: "time" } });

</script>"""%params

# 需要导入模块: from whale import Whale [as 别名]
# 或者: from whale.Whale import plotpoints [as 别名]
def graph():
    from periods import Period
    params = {'pk': g('pk', '_', False),
            'dimension': g('dimension', '_', False),
            'metric': g('metric', 'hits', False),
            'depth': g('depth', 0),
            'tzoffset': g('tzoffset', 0.0),
            'period': g('period', str(Period.get(None))),
            'area': g('area', ''),
            }
    pk = params['pk']
    dimension = params['dimension']
    metric = params['metric']
    period = Period.get(params['period'])
    debug = g('debug', False)
    parent_div = g('parent_div', 'hailwhale_graphs')
    table = g('table', False)
    height = g('height', '300px')
    params['title'] = g('title', '')
    if not params['title']:
        pkname = g('pk', '')
        dimname = util.try_loads(g('dimension', 'Overall'))
        dimname = isinstance(dimname, list) and dimname[-1] or dimname
        params['title'] = '%s [%s]' % (util.maybe_dumps(pkname), util.maybe_dumps(dimname))
    if isinstance(table, basestring):
        table = table.lower() == 'true'
    hwurl = req.GET.get('hwurl', req.url.split('graph.js')[0])
    params['autoupdate'] = g('live', True)
    params['interval'] = g('interval', 6000)
    graph_id = hashlib.md5(str(params)).hexdigest()
    include_string = \
"document.write(\"<scr\" + \"ipt type='text/javascript' src='%sjs/jquery.min.js'></script>\");"%hwurl
    if table:
        try:
            columns = int(g('table', 6, int))
        except:
            columns = 6
        pps = Whale.plotpoints(pk, dimension, metric, period=period,
                depth=params['depth'])
        dates = [p for p in
                Period.get(period).datetimes_strs()][(-1*columns - 1):]

        table_str = '''
            $('#{id} .table').html('<table style="width: 100%"> <tr> <th></th> <th></th> {columns} </tr>
        '''.strip().format(id=graph_id,columns=' '.join([
            '<th>%s</th>'%date.replace('00:00:00 ', '') for date in dates]))

        dimensions = pps.keys()
        if '_' in dimensions:
            dimensions.remove('_')
            dimensions = ['_'] + dimensions
        for dimension_counter, dimension in enumerate(dimensions):
            checked = 'off'
            if dimension_counter < 10:
                checked = 'on'
            if dimension == '_':
                if params['depth']:
                    continue
                dimension_name = '<b>Overall</b>'
            else:
                dimension_name = dimension.capitalize()
            table_str += '''
                <tr> <td><input id="" style="display: none" type="checkbox" value="{checked}" name="checkbox-{pk}-{dimension}"></td> <td>{dimension_name}</td> {columns} </tr>
                '''.format(pk=pk, dimension=dimension, checked=checked,
                        dimension_name=dimension_name,
                        columns=' '.join([
                "<td>%s</td>"%int(pps[dimension][metric][date]) for date in dates])).strip()

        table_str += '''</table>');'''
    else:
        table_str = ''
    include_string = \
"document.write(\"<scr\" + \"ipt type='text/javascript' src='%sjs/hailwhale.min.js'></script>\");"%hwurl

    return_string = '''
appended=false;\n
document.write('<div id="{id}"><div class="graph" style="height: {height}"></div><div class="table"></div></div>');\n
function jqinit() {{\n
    if(typeof(jQuery) == 'undefined' || typeof(jQuery.hailwhale) == 'undefined') {{\n
        if(!appended) {{\n
            appended = true;\n
            {include_string}\n
        }}\n
        setTimeout(jqinit, 250);\n
    }} else {{\n
        $(function() {{\n
                $.hailwhale('{hwurl}').add_graph('{id} .graph', {options});\n
                {table_str}
        }});\n
    }}
}}
jqinit();\n


    '''.format(parent_div=parent_div, include_string=include_string,
            hwurl=hwurl, table_str=table_str, height=height,
            id=graph_id,
            options=util.maybe_dumps(params))
    return return_string

# 需要导入模块: from whale import Whale [as 别名]
# 或者: from whale.Whale import plotpoints [as 别名]
class TestHailWhale(unittest.TestCase):
    def setUp(self):
        from hail import Hail
        from whale import Whale
        self.hail = Hail()
        self.whale = Whale()

    def testGetSubdimensions(self):
        t = 'subs_%s' % str(time.time())
        self.whale.count_now(t, {'a': 1, 'b': 2})
        subs = self.whale.get_subdimensions(t)
        assert('a' in subs)
        assert('b' in subs)

    def testGetAllSubdimensions(self):
        t = 'all_subs_%s' % str(time.time())
        self.whale.count_now(t, {'a': 1, 'b': 2})
        subs = self.whale.all_subdimensions(t)
        assert('a' in subs)
        assert(['a', '1'] in subs)
        assert('b' in subs)
        assert(['b', '2'] in subs)

    def testPlotpoints(self):
        t = str(time.time())

        for i in range(5):
            self.whale.count_now('test_plotpoints', t, {'hits': 1, 'values': 5})
        plotpoints = self.whale.plotpoints('test_plotpoints', t, ['hits', 'values'], points_type=list)

        self.assertEqual(plotpoints[t]['hits'][-1][1], 5)
        self.assertEqual(plotpoints[t]['values'][-1][1], 25)

    def testPlotpointsDepth(self):
        t = str(time.time())
        self.whale.count_now('test_depth', {t: 'a'})
        self.whale.count_now('test_depth', {t: 'b'})
        self.whale.count_now('test_depth', {t: 'b'})
        self.whale.count_now('test_depth', {t: {'c': 'child'}})
        # Test 1 level deep
        plotpoints = self.whale.plotpoints('test_depth', t, points_type=list, depth=1)
        self.assertEqual(plotpoints[maybe_dumps([t, 'a'])]['hits'][-1][1], 1)
        self.assertEqual(plotpoints[maybe_dumps([t, 'b'])]['hits'][-1][1], 2)
        self.assertEqual(plotpoints[maybe_dumps([t, 'c'])]['hits'][-1][1], 1)
        self.assertEqual(False, maybe_dumps([t, 'c', 'child']) in plotpoints)
        # Test 2 levels deep
        plotpoints = self.whale.plotpoints('test_depth', t, points_type=list, depth=2)
        self.assertEqual(True, maybe_dumps([t, 'c', 'child']) in plotpoints)
        self.assertEqual(plotpoints[maybe_dumps([t, 'c', 'child'])]['hits'][-1][1], 1)

        # Test ranking and limiting
        plotpoints = self.whale.plotpoints('test_depth', t, points_type=list,
                depth=1, limit=2)
        self.assertEqual(plotpoints[maybe_dumps([t, 'b'])]['hits'][-1][1], 2)
        self.assertEqual(True, maybe_dumps([t, 'a']) not in plotpoints)
        self.assertEqual(True, maybe_dumps([t, 'c']) not in plotpoints)

    def testRatioPlotpoints(self):
        t = str(time.time())

        for i in range(5):
            self.whale.count_now('test_ratio', t, {'hit': 1, 'value': 5})

        plotpoints = self.whale.plotpoints('test_ratio', t, ['hit', 'value', 'value/hit'], points_type=list)

        self.assertEqual(plotpoints[t]['hit'][-1][1], 5)
        self.assertEqual(plotpoints[t]['value'][-1][1], 25)

        self.assertEqual(plotpoints[t]['value/hit'][-1][1], 5)

    def testRankSubdimensionsScalar(self):
        t = str(time.time())
        self.whale.count_now('test_rank', [t, 'a', 'asub1'], {'value': 1})
        self.whale.count_now('test_rank', [t, 'a', 'asub2'], {'value': 30})
        self.whale.count_now('test_rank', [t, 'b'], {'value': 80})
        self.whale.count_now('test_rank', [t, 'c'], {'value': 10})
        ranked = self.whale.rank_subdimensions_scalar('test_rank', t, 'value')
        self.assertEqual(ranked[maybe_dumps([t, 'a'])]['important'], False)
        self.assertEqual(ranked[maybe_dumps([t, 'a', 'asub1'])]['important'], False)
        self.assertEqual(ranked[maybe_dumps([t, 'a', 'asub2'])]['important'], True)
        self.assertEqual(ranked[maybe_dumps([t, 'b'])]['important'], True)
        self.assertEqual(ranked[maybe_dumps([t, 'c'])]['important'], False)

    def testRankSubdimensionsRatio(self):
        t = str(time.time())
        pk = 'test_ratio_rank'
        # OVERALL STATS: 529,994 value, 50,000 visitors, 10.6 value per visitor
        # Not important, too close to overall
        self.whale.count_now(pk, [t, 'a', 'asub1'],
            {'value': 54989, 'visitors': 4999})  # 11 value per visitor
        # Important, high relative ratio
        self.whale.count_now(pk, [t, 'a', 'asub2'],
            {'value': 375000, 'visitors': 25000})  # 15 value per visitor
        # Important, low relative ratio
        self.whale.count_now(pk, [t, 'b'],
            {'value': 100000, 'visitors': 20000})  # 5 value per visitor
        # Not important, not enough visitors
        self.whale.count_now(pk, [t, 'c'],
            {'value': 5, 'visitors': 1})  # 5 value per visitor

#.........这里部分代码省略.........

# 需要导入模块: from whale import Whale [as 别名]
# 或者: from whale.Whale import plotpoints [as 别名]
def plotpoints():
    whale = Whale()
    params = default_params()
    params['depth'] = g('depth', 0)
    params['period'] = g('period', '1x60')
    return json.dumps(whale.plotpoints(**params))

# 需要导入模块: from whale import Whale [as 别名]
# 或者: from whale.Whale import plotpoints [as 别名]
def plotpoints():
    whale = Whale()
    params = default_params()
    params["depth"] = g("depth", 0)
    params["period"] = g("period", None)
    return json.dumps(whale.plotpoints(**params))