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)
'''
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)
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)
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%%;"> </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
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
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
one_level = self.whale.rank_subdimensions_ratio('test_rank_ratio', 'value', 'visitors',
t, recursive=False)
all_levels = self.whale.rank_subdimensions_ratio(pk, 'value', 'visitors', t)
self.assertEqual(True, maybe_dumps([t, 'a', 'asub1']) not in one_level)
self.assertEqual(all_levels[maybe_dumps([t, 'a', 'asub1'])]['important'], False)
self.assertEqual(all_levels[maybe_dumps([t, 'a', 'asub2'])]['important'], True)
self.assertEqual(all_levels[maybe_dumps([t, 'b'])]['important'], True)
self.assertEqual(all_levels[maybe_dumps([t, 'c'])]['important'], False)
def testBasicDecision(self):
pk = 'test_basic_decision'
decision = str(time.time())
# Make a decision, any decision, from no information whatsoever
good, bad, test = self.whale.weighted_reasons(pk, 'random', [1,2,3])
#_print_reasons(good, bad, test)
any_one = self.whale.decide_from_reasons(good, bad, test)
self.assertEqual(True, any_one in [1, 2, 3])
# OK, now how about something somewhat informed?
# This will be easy. Slogan A makes us huge profit. Products B and C suck.
# D looks promissing but isn't yet significant
opts = ['a', 'b', 'c', 'd']
self.whale.count_now([pk, decision, 'a'], None, dict(dollars=5000, visitors=1000))
self.whale.count_now([pk, decision, 'b'], None, dict(dollars=0, visitors=2000))
self.whale.count_now([pk, decision, 'c'], None, dict(dollars=0, visitors=2000))
self.whale.count_now([pk, decision, 'd'], None, dict(dollars=50, visitors=10))
good, bad, test = self.whale.weighted_reasons(pk, decision, opts, formula='dollars/visitors')
#_print_reasons(good, bad, test)
self.assertEqual(True, 'a' in good.keys())
self.assertEqual(True, 'b' in bad.keys())
self.assertEqual(True, 'c' in bad.keys())
self.assertEqual(True, 'd' in test.keys())
which_one = self.whale.decide(pk, decision, opts, formula='dollars/visitors',
bad_idea_threshold=0, test_idea_threshold=0)
self.assertEqual(which_one, 'a')
def testInformedDecision(self):
pk = 'test_informed_decision'
decision = str(time.time())
# A is the clear winner, except when country=UK, in which case B wins
opts = ['a', 'b', 'c', 'd']
self.whale.count_now([pk, decision, 'a'], None, dict(dollars=50000, visitors=10000))
self.whale.count_now([pk, decision, 'b'], None, dict(dollars=0, visitors=2000))
self.whale.count_now([pk, decision, 'b'], {'country': 'uk'}, dict(dollars=10000, visitors=2000))
self.whale.count_now([pk, decision, 'c'], None, dict(dollars=0, visitors=7500))
self.whale.count_now([pk, decision, 'd'], None, dict(dollars=5, visitors=1))
# Here's a visitor with no info -- 'A' should win by far.
good, bad, test = self.whale.weighted_reasons(pk, decision, opts, formula='dollars/visitors')
#_print_reasons(good, bad, test)
self.assertEqual(True, 'a' in good.keys())
self.assertEqual(True, 'b' in bad.keys())
self.assertEqual(True, 'c' in bad.keys())
self.assertEqual(True, 'd' in test.keys())
# How about when we know the country is "UK"?
good, bad, test = self.whale.weighted_reasons(pk, decision, opts, formula='dollars/visitors',
known_data={'country': 'uk'})
#_print_reasons(good, bad, test)
self.assertEqual(True, 'a' in good.keys())
self.assertEqual(True, 'b' in good.keys())
self.assertEqual(True, 'c' in bad.keys())
self.assertEqual(True, 'd' in test.keys())
chosen = {'a': 0, 'b': 0}
for k in range(100):
choose = self.whale.decide(pk, decision, opts, formula='dollars/visitors',
known_data={'country': 'uk'}, bad_idea_threshold=0, test_idea_threshold=0)
chosen[choose] += 1
self.assertEqual(True, chosen['b'] > 70,
"""A decision made 100 times between weights .15 vs .85 should have around 85 votes for 'b',
we got %s, which is unlikely enough to fail a test, but not definitely
indicative of a problem. If this test passes again on the next run, ignore the failure.""" % chosen)
def testTrickyDecision(self):
pk = 'test_tricky_decision'
decision = str(time.time())
opts = ['en', 'sp', 'pt']
def count(geo, lang, dollars, visitors):
self.whale.count_decided_now(pk, decision, lang, geo,
{'dollars': dollars, 'visitors': visitors})
def justify(geo):
#print
#print 'Picking reasons for ', geo
good, bad, test = self.whale.weighted_reasons(pk, decision, opts,
'dollars/visitors', geo)
#print good.keys(), bad.keys(), test.keys()
#_print_reasons(good, bad, test)
return self.whale.decide(pk, decision, opts, 'dollars/visitors', geo,
bad_idea_threshold=0, test_idea_threshold=0)
k = 1000
m = k * k
# Sure, these results seem predictable to a human
# But what will our philosopher whale friend make of it?
count('us', 'en', 1.5 * m, 300 * k) # $5/visitor, alright!
count('us', 'sp', 1 * k, 10 * k) # $.10/visitor, well that is not surprising
count('us', 'pt', 300, 5 * k) # $.06/visitor, :(
count('mx', 'en', 100 * k, 100 * k) # $1/visitor, this almost works
count('mx', 'sp', 200 * k, 100 * k) # $2/visitor aww yah!
count('mx', 'pt', 200, 10 * k) # $.02/visitor lol
count('br', 'en', 300 * k, 100 * k) # $3/visitor is good
count('br', 'sp', 150 * k, 50 * k) # $3/visitor as well
count('br', 'pt', 500 * k, 50 * k) # $10 JACKPOT
self.assertEqual('en', justify('us'))
self.assertEqual(True, justify('mx') in ['sp', 'en'])
self.assertEqual('pt', justify('br'))
def testWhaleCacheWrapper(self):
t = str(time.time())
count = lambda: self.whale.count_now('test_cached', t)
cached_sum = lambda clear=False: sum(self.whale.cached_plotpoints('test_cached',
t, period='fivemin', unmemoize=clear)[t]['hits'].values())
# Set hits to 1
count()
self.assertEqual(cached_sum(), 1)
# Should stay 1 for a while
for i in range(3):
count()
self.assertEqual(cached_sum(), 1)
self.assertEqual(cached_sum(clear=True), 4)
def plotpoints():
whale = Whale()
params = default_params()
params['depth'] = g('depth', 0)
params['period'] = g('period', '1x60')
return json.dumps(whale.plotpoints(**params))
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
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 i.e assign rank on the basis of value and then extract top limit candidate
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
one_level = self.whale.rank_subdimensions_ratio('test_rank_ratio', 'value', 'visitors',
t, recursive=False)
all_levels = self.whale.rank_subdimensions_ratio(pk, 'value', 'visitors', t)
self.assertEqual(True, maybe_dumps([t, 'a', 'asub1']) not in one_level)
self.assertEqual(all_levels[maybe_dumps([t, 'a', 'asub1'])]['important'], False)
self.assertEqual(all_levels[maybe_dumps([t, 'a', 'asub2'])]['important'], True)
self.assertEqual(all_levels[maybe_dumps([t, 'b'])]['important'], True)
self.assertEqual(all_levels[maybe_dumps([t, 'c'])]['important'], False)
def testBasicDecision(self):
pk = 'test_basic_decision'
decision = str(time.time())
# Make a decision, any decision, from no information whatsoever
good, bad, test = self.whale.weighted_reasons(pk, 'random', [1,2,3])
#_print_reasons(good, bad, test)
any_one = self.whale.decide_from_reasons(good, bad, test)
self.assertEqual(True, any_one in [1, 2, 3])
# OK, now how about something somewhat informed?
# This will be easy. Slogan A makes us huge profit. Products B and C suck.
# D looks promissing but isn't yet significant
opts = ['a', 'b', 'c', 'd']
self.whale.count_now([pk, decision, 'a'], None, dict(dollars=5000, visitors=1000))
self.whale.count_now([pk, decision, 'b'], None, dict(dollars=0, visitors=2000))
self.whale.count_now([pk, decision, 'c'], None, dict(dollars=0, visitors=2000))
self.whale.count_now([pk, decision, 'd'], None, dict(dollars=50, visitors=10))
good, bad, test = self.whale.weighted_reasons(pk, decision, opts, formula='dollars/visitors')
#_print_reasons(good, bad, test)
self.assertEqual(True, 'a' in good.keys())
self.assertEqual(True, 'b' in bad.keys())
self.assertEqual(True, 'c' in bad.keys())
self.assertEqual(True, 'd' in test.keys())
which_one = self.whale.decide(pk, decision, opts, formula='dollars/visitors',
bad_idea_threshold=0, test_idea_threshold=0)
self.assertEqual(which_one, 'a')
def testInformedDecision(self):
pk = 'test_informed_decision'
decision = str(time.time())
# A is the clear winner, except when country=UK, in which case B wins
opts = ['a', 'b', 'c', 'd']
self.whale.count_now([pk, decision, 'a'], None, dict(dollars=50000, visitors=10000))
self.whale.count_now([pk, decision, 'b'], None, dict(dollars=0, visitors=2000))
self.whale.count_now([pk, decision, 'b'], {'country': 'uk'}, dict(dollars=10000, visitors=2000))
self.whale.count_now([pk, decision, 'c'], None, dict(dollars=0, visitors=7500))
self.whale.count_now([pk, decision, 'd'], None, dict(dollars=5, visitors=1))
# Here's a visitor with no info -- 'A' should win by far.
good, bad, test = self.whale.weighted_reasons(pk, decision, opts, formula='dollars/visitors')
#_print_reasons(good, bad, test)
self.assertEqual(True, 'a' in good.keys())
self.assertEqual(True, 'b' in bad.keys())
self.assertEqual(True, 'c' in bad.keys())
self.assertEqual(True, 'd' in test.keys())
# How about when we know the country is "UK"?
good, bad, test = self.whale.weighted_reasons(pk, decision, opts, formula='dollars/visitors',
known_data={'country': 'uk'})
#_print_reasons(good, bad, test)
self.assertEqual(True, 'a' in good.keys())
self.assertEqual(True, 'b' in good.keys())
self.assertEqual(True, 'c' in bad.keys())
self.assertEqual(True, 'd' in test.keys())
chosen = {'a': 0, 'b': 0}
for k in range(100):
choose = self.whale.decide(pk, decision, opts, formula='dollars/visitors',
known_data={'country': 'uk'}, bad_idea_threshold=0, test_idea_threshold=0)
chosen[choose] += 1
self.assertEqual(True, chosen['b'] > 70,
"""A decision made 100 times between weights .15 vs .85 should have around 85 votes for 'b',
we got %s, which is unlikely enough to fail a test, but not definitely
indicative of a problem. If this test passes again on the next run, ignore the failure.""" % chosen)
def testTrickyDecision(self):
pk = 'test_tricky_decision'
decision = str(time.time())
opts = ['en', 'sp', 'pt']
def count(geo, lang, dollars, visitors):
self.whale.count_decided_now(pk, decision, lang, geo,
{'dollars': dollars, 'visitors': visitors})
def justify(geo):
#print
#print 'Picking reasons for ', geo
good, bad, test = self.whale.weighted_reasons(pk, decision, opts,
'dollars/visitors', geo)
#print good.keys(), bad.keys(), test.keys()
#_print_reasons(good, bad, test)
return self.whale.decide(pk, decision, opts, 'dollars/visitors', geo,
bad_idea_threshold=0, test_idea_threshold=0)
k = 1000
m = k * k
# Sure, these results seem predictable to a human
# But what will our philosopher whale friend make of it?
count('us', 'en', 1.5 * m, 300 * k) # $5/visitor, alright!
count('us', 'sp', 1 * k, 10 * k) # $.10/visitor, well that is not surprising
count('us', 'pt', 300, 5 * k) # $.06/visitor, :(
count('mx', 'en', 100 * k, 100 * k) # $1/visitor, this almost works
count('mx', 'sp', 200 * k, 100 * k) # $2/visitor aww yah!
count('mx', 'pt', 200, 10 * k) # $.02/visitor lol
count('br', 'en', 300 * k, 100 * k) # $3/visitor is good
count('br', 'sp', 150 * k, 50 * k) # $3/visitor as well
count('br', 'pt', 500 * k, 50 * k) # $10 JACKPOT
self.assertEqual('en', justify('us'))
self.assertEqual(True, justify('mx') in ['sp', 'en'])
self.assertEqual('pt', justify('br'))
def testWhaleCacheWrapper(self):
t = str(time.time())
count = lambda: self.whale.count_now('test_cached', t)
cached_sum = lambda clear=False: sum(self.whale.cached_plotpoints('test_cached',
t, period='fivemin', unmemoize=clear)[t]['hits'].values())
# Set hits to 1
count()
self.assertEqual(cached_sum(), 1)
# Should stay 1 for a while
for i in range(3):
count()
self.assertEqual(cached_sum(), 1)
self.assertEqual(cached_sum(clear=True), 4)
def plotpoints():
whale = Whale()
params = default_params()
params["depth"] = g("depth", 0)
params["period"] = g("period", None)
return json.dumps(whale.plotpoints(**params))
