def run(race_types, force):
"""main method to update ratings in db"""
for race_type in race_types or ['R', 'G', 'H']:
logger.info('Running race type {}'.format(race_type))
cache = {}
# force truncate
if force:
delete_race_players(race_type)
races = load_races(race_type)
logger.info('loaded {} races...'.format(len(races)))
# continue for new races
else:
last_date = get_last_player_date(race_type)
races = load_races(race_type, last_date)
logger.info('loaded {} races since {}...'.format(
len(races), last_date))
if not races:
raise Exception('No new races')
for i, race in enumerate(races):
logger.debug('Running race {} {}'.format(race.meeting_name,
race.meeting_date))
runners = race.get_runners()
try:
add_odds(runners)
except OddsError as e:
logger.warning(e)
delete_race(race.id)
continue
add_ratings(runners, race_type, cache, force)
add_probabilities(runners)
results = race.get_results()
try:
rate_outcome(race, runners, results, cache)
except (KeyError, ValueError) as e:
logger.warning(e)
delete_race(race.id)
else:
for runner in runners:
runner.pop('rating')
race.set_runners(runners)
logger.info('{:.1f}% completed {}'.format(
i / len(races) * 100, race.race_start_time))
logger.info('saving races...')
db_session.commit()
player_session.commit()
def run(race_types, odds_only, pred_only):
"""main method to update predictions in db"""
for race_type in race_types or ['R', 'G', 'H']:
logger.info('Running race type {}'.format(race_type))
races = load_races(race_type)
logger.info('loaded {} races...'.format(len(races)))
for i, race in enumerate(races):
logger.debug('Running race {} {}'.format(race.meeting_name,
race.meeting_date))
runners = race.get_runners()
try:
# shared with watching
if not pred_only:
add_odds(runners)
if not odds_only:
add_predictions(runners, race_type)
add_probabilities(runners)
except OddsError as e:
logger.warning(e)
delete_race(race.id)
except Exception:
print(json.dumps(race, indent=4, default=str, sort_keys=True))
print(
json.dumps(runners, indent=4, default=str, sort_keys=True))
raise
else:
race.num_runners = len([r for r in runners if r['has_odds']])
race.set_runners(runners)
logger.info('{:.1f}% completed'.format(i / len(races) * 100))
logger.info('saving...')
db_session.commit()
def run(race_types, odds_only, pred_only, force):
"""main method to update predictions in db"""
for race_type in race_types or ['R', 'G', 'H']:
logger.info('Running race type {}'.format(race_type))
cache = {}
# force truncate
if force:
delete_race_players(race_type)
races = load_races(race_type)
logger.info('loaded {} races...'.format(len(races)))
# if predictions
elif pred_only:
races = load_races(race_type)
logger.info('loaded {} races...'.format(len(races)))
# continue for new races
else:
last_date = get_last_player_date(race_type)
races = load_races(race_type, last_date)
logger.info('loaded {} races since {}...'.format(
len(races), last_date))
if not races:
raise Exception('No new races')
for i, race in enumerate(races):
logger.debug('Running race {} {}'.format(race.meeting_name,
race.meeting_date))
runners = race.get_runners()
if not pred_only:
try:
add_odds(runners, cache, force)
except OddsError as e:
logger.warning(e)
delete_race(race.id)
continue
else:
# with odds the outcome can be saved to players
rate_outcome(race, runners, race.get_results(), cache)
if not odds_only:
try:
add_predictions(runners, race_type)
add_probabilities(runners)
except PredictionError as e:
logger.info('Skipping {}'.format(race))
continue
except (Exception, ProbabilityError):
print(
json.dumps(race, indent=4, default=str,
sort_keys=True))
print(
json.dumps(runners,
indent=4,
default=str,
sort_keys=True))
# delete_race(race.id)
race_session.commit()
raise
race.num_runners = len([r for r in runners if r['has_odds']])
race.set_runners(runners)
logger.info('{:.1f}% completed'.format(i / len(races) * 100))
logger.info('saving...')
race_session.commit()
player_session.commit()
def build(bet_type, race_types):
"""main method to update predictions in db"""
logger.info('building exotic bets')
for race_type in race_types or ['R', 'G', 'H']:
logger.info('Running race type {}'.format(race_type))
# recreate as cannot update with no unique info being stored
clear_exotic(race_type, bet_type)
races = load_races(race_type)
if bet_type == BET_TYPE_EXACTA:
r = 2
else:
raise Exception(bet_type)
logger.info(
'building combinations from {} races for {} repeats'.format(
len(races), r))
for race in races:
# get num runners (requires at least 8)
# if race.num_runners < 8:
# logger.debug('skipping {}'.format(race))
# continue
# get results
res1, res2, res3, res4 = race.get_results()
logger.debug('winners = {} {} {} {}'.format(
res1, res2, res3, res4))
try:
res1, res2, res3, res4 = res1[0], res2[0], res3[0], res4[0]
except IndexError as e:
logger.warning('bad results: {}'.format(race.get_results()))
continue
# get runners
runners = race.get_runners()
# remove scratched
try:
runners = [r for r in runners if r['has_odds']]
except:
print(json.dumps(race, indent=4, default=str, sort_keys=True))
print(
json.dumps(runners, indent=4, default=str, sort_keys=True))
raise
# sort to combinations instead of permutations
runners = sorted(runners,
key=itemgetter('win_scaled'),
reverse=True)
combs = build_combinations(runners, r)
rn = ','.join([str(r['runnerNumber']) for r in runners])
for comb in combs:
comb.update({
'race_id': race.id,
'runner_numbers': rn,
'race_type': race_type,
'bet_type': bet_type,
'res1': res1,
'res2': res2,
'res3': res3,
'res4': res4,
})
if bet_type == BET_TYPE_EXACTA:
success = 1 if comb['run1_num'] == res1 and comb[
'run2_num'] == res2 else 0
comb.update({
'success': success,
'dividend': race.exacta,
})
save_exotic(comb)
logger.info('Adding {} combinations for race {}'.format(
len(combs), race))
logger.info('saving...')
db_session.commit()