def test_update_trueskill_ratings(self):
rating_calculators.update_trueskill_ratings(self.region_id, winner=self.player_1, loser=self.player_2)
self.assertTrue(self.player_1.ratings[self.region_id].trueskill_rating.mu > 25)
self.assertTrue(self.player_1.ratings['texas'].trueskill_rating.mu == 25)
self.assertTrue(self.player_2.ratings[self.region_id].trueskill_rating.mu < 25)
self.assertTrue(self.player_2.ratings['socal'].trueskill_rating.mu == 25)
def test_update_trueskill_ratings(self):
rating_calculators.update_trueskill_ratings(self.region_id, winner=self.player_1, loser=self.player_2)
self.assertTrue(self.player_1.ratings[self.region_id].mu > 25)
self.assertTrue(self.player_1.ratings['texas'].mu == 25)
self.assertTrue(self.player_2.ratings[self.region_id].mu < 25)
self.assertTrue(self.player_2.ratings['socal'].mu == 25)
def generate_ranking(dao, now=datetime.now()):
player_date_map = {}
player_id_to_player_map = {}
tournaments = dao.get_all_tournaments(regions=[dao.region_id])
for tournament in tournaments:
print 'Processing:', tournament.name
for player_id in tournament.players:
player_date_map[player_id] = tournament.date
# TODO add a default rating entry when we add it to the map
for match in tournament.matches:
if not match.winner in player_id_to_player_map:
db_player = dao.get_player_by_id(match.winner)
db_player.ratings[dao.region_id] = DEFAULT_RATING
player_id_to_player_map[match.winner] = db_player
if not match.loser in player_id_to_player_map:
db_player = dao.get_player_by_id(match.loser)
db_player.ratings[dao.region_id] = DEFAULT_RATING
player_id_to_player_map[match.loser] = db_player
winner = player_id_to_player_map[match.winner]
loser = player_id_to_player_map[match.loser]
rating_calculators.update_trueskill_ratings(dao.region_id, winner=winner, loser=loser)
print 'Checking for player inactivity...'
i = 1
players = player_id_to_player_map.values()
sorted_players = sorted(
players,
key=lambda player: trueskill.expose(player.ratings[dao.region_id].trueskill_rating), reverse=True)
ranking = []
for player in sorted_players:
player_last_active_date = player_date_map.get(player.id)
if player_last_active_date == None or dao.is_inactive(player, now) or not dao.region_id in player.regions:
pass # do nothing, skip this player
else:
ranking.append(RankingEntry(i, player.id, trueskill.expose(player.ratings[dao.region_id].trueskill_rating)))
i += 1
print 'Updating players...'
for i, p in enumerate(players, start=1):
dao.update_player(p)
print 'Updated player %d of %d' % (i, len(players))
print 'Inserting new ranking...'
dao.insert_ranking(Ranking(dao.region_id, now, [t.id for t in tournaments], ranking))
print 'Done!'
def generate_ranking(dao, now=datetime.now(), day_limit=60, num_tourneys=2):
player_date_map = {}
player_id_to_player_map = {}
tournaments = dao.get_all_tournaments(regions=[dao.region_id])
for tournament in tournaments:
print 'Processing:', tournament.name.encode('utf-8')
for player_id in tournament.players:
player_date_map[player_id] = tournament.date
# TODO add a default rating entry when we add it to the map
for match in tournament.matches:
if not match.winner in player_id_to_player_map:
db_player = dao.get_player_by_id(match.winner)
db_player.ratings[dao.region_id] = DEFAULT_RATING
player_id_to_player_map[match.winner] = db_player
if not match.loser in player_id_to_player_map:
db_player = dao.get_player_by_id(match.loser)
db_player.ratings[dao.region_id] = DEFAULT_RATING
player_id_to_player_map[match.loser] = db_player
winner = player_id_to_player_map[match.winner]
loser = player_id_to_player_map[match.loser]
rating_calculators.update_trueskill_ratings(dao.region_id, winner=winner, loser=loser)
print 'Checking for player inactivity...'
rank = 1
players = player_id_to_player_map.values()
sorted_players = sorted(
players,
key=lambda player: trueskill.expose(player.ratings[dao.region_id].trueskill_rating), reverse=True)
ranking = []
for player in sorted_players:
player_last_active_date = player_date_map.get(player.id)
if player_last_active_date == None or dao.is_inactive(player, now, day_limit, num_tourneys) or not dao.region_id in player.regions:
pass # do nothing, skip this player
else:
ranking.append(RankingEntry(rank, player.id, trueskill.expose(player.ratings[dao.region_id].trueskill_rating)))
rank += 1
print 'Updating players...'
for i, p in enumerate(players, start=1):
dao.update_player(p)
print 'Updated player %d of %d' % (i, len(players))
print 'Inserting new ranking...'
dao.insert_ranking(Ranking(dao.region_id, now, [t.id for t in tournaments], ranking))
print 'Done!'
def generate_ranking(dao):
dao.reset_all_player_ratings()
player_date_map = {}
now = datetime.now()
player_id_to_player_map = dict((p.id, p) for p in dao.get_all_players())
tournaments = dao.get_all_tournaments()
for tournament in tournaments:
print 'Processing:', tournament.name
for player_id in tournament.players:
player_date_map[player_id] = tournament.date
for match in tournament.matches:
winner = player_id_to_player_map[match.winner]
loser = player_id_to_player_map[match.loser]
rating_calculators.update_trueskill_ratings(winner=winner, loser=loser)
excluded_players = set([p.id for p in dao.get_excluded_players()])
i = 1
players = player_id_to_player_map.values()
sorted_players = sorted(players, key=lambda player: trueskill.expose(player.rating.trueskill_rating), reverse=True)
ranking = []
for player in sorted_players:
player_last_active_date = player_date_map.get(player.id)
if player_last_active_date == None or dao.is_inactive(player, now) or player.id in excluded_players:
pass # do nothing, skip this player
else:
ranking.append(RankingEntry(i, player.id, trueskill.expose(player.rating.trueskill_rating)))
i += 1
print 'Updating players...'
for p in players:
dao.update_player(p)
print 'Inserting new ranking...'
dao.insert_ranking(Ranking(now, [t.id for t in tournaments], ranking))
print 'Done!'
def test_update_trueskill_ratings(self):
rating_calculators.update_trueskill_ratings(winner=self.player_1, loser=self.player_2)
self.assertTrue(self.player_1.rating.trueskill_rating.mu > 25)
self.assertTrue(self.player_2.rating.trueskill_rating.mu < 25)
def generate_ranking(dao,
now=datetime.now(),
day_limit=60,
num_tourneys=2,
tournament_qualified_day_limit=999):
try:
logger.info('Beginning ranking calculation for ' + str(dao.region_id))
player_date_map = {}
player_id_to_player_map = {}
ranking_tournaments = []
tournament_qualified_date = (
now - timedelta(days=tournament_qualified_day_limit))
print('Qualified Date: ' + str(tournament_qualified_date))
logger.info('Qualified Date: ' + str(tournament_qualified_date))
tournaments = dao.get_all_tournaments(regions=[dao.region_id])
for tournament in tournaments:
if tournament.excluded is True:
print 'Tournament Excluded:'
print 'Excluded - ' + str(tournament.name)
logger.warning('Tournament Excluded: ' + str(tournament.name))
continue
if tournament_qualified_date <= tournament.date:
ranking_tournaments.append(tournament)
print 'Processing:', tournament.name.encode('utf-8'), str(
tournament.date)
logger.info('Processing: ' + tournament.name.encode('utf-8') +
", " + str(tournament.date))
for player_id in tournament.players:
player_date_map[player_id] = tournament.date
# TODO add a default rating entry when we add it to the map
for match in tournament.matches:
if match.excluded is True:
print('match excluded:')
print('Tournament: ' + str(tournament.name))
print(str(match))
logger.debug('Match excluded: ' + str(match) +
' Tournament: ' + str(tournament.name))
continue
logger.debug('Getting winner and loser')
# don't count matches where either player is OOR
winner = dao.get_player_by_id(match.winner)
logger.debug('Winner: ' + str(winner))
if winner is None:
logger.warning(
'Player found as NoneType. Skipping match')
continue
elif dao.region_id not in winner.regions:
continue
loser = dao.get_player_by_id(match.loser)
logger.debug('Loser: ' + str(loser))
if loser is None:
logger.warning(
'Player found as NoneType. Skipping match')
continue
elif dao.region_id not in loser.regions:
continue
if match.winner not in player_id_to_player_map:
db_player = dao.get_player_by_id(match.winner)
db_player.ratings[dao.region_id] = model.Rating()
player_id_to_player_map[match.winner] = db_player
if match.loser not in player_id_to_player_map:
db_player = dao.get_player_by_id(match.loser)
db_player.ratings[dao.region_id] = model.Rating()
player_id_to_player_map[match.loser] = db_player
winner = player_id_to_player_map[match.winner]
loser = player_id_to_player_map[match.loser]
rating_calculators.update_trueskill_ratings(dao.region_id,
winner=winner,
loser=loser)
else:
logger.debug('Tournament ' + str(tournament.name) +
' outside qualified date. Skipping.')
print 'Checking for player inactivity...'
logger.info('Checking for player inactivity...')
rank = 1
players = player_id_to_player_map.values()
sorted_players = sorted(
players,
key=lambda player: trueskill.expose(player.ratings[dao.region_id].
trueskill_rating()),
reverse=True)
ranking = []
for player in sorted_players:
if player is None:
logger.warning(
'NoneType player found while checking inactivity. Skipping.'
)
continue
player_last_active_date = player_date_map.get(player.id)
if player_last_active_date is None or \
dao.is_inactive(player, now, day_limit, num_tourneys) or \
dao.region_id not in player.regions:
logger.debug('Player ' + player.name +
' outside of ranking criteria. Skipping.')
pass # do nothing, skip this player
else:
logger.debug('Player ' + player.name + ' updating.')
ranking.append(
model.RankingEntry(
rank=rank,
player=player.id,
rating=trueskill.expose(
player.ratings[dao.region_id].trueskill_rating())))
rank += 1
print 'Updating players...'
logger.info('Updating players...')
for i, p in enumerate(players, start=1):
if p is None:
logger.warning(
'NoneType player found while updating. Skipping.')
continue
logger.debug('Updating player ' + p.name)
dao.update_player(p)
# TODO: log somewhere later
# print 'Updated player %d of %d' % (i, len(players))
print 'Inserting new ranking...'
logger.info('Inserting new ranking...')
dao.insert_ranking(
model.Ranking(id=ObjectId(),
region=dao.region_id,
time=now,
tournaments=[t.id for t in ranking_tournaments],
ranking=ranking))
print 'Done!'
logger.info('Done!')
except Exception as e:
print str(e)
logger.error(str(e))
tb = traceback.format_exc()
logging.error(tb)
def generate_ranking(dao,
now=datetime.now(),
day_limit=60,
num_tourneys=2,
tournament_qualified_day_limit=999):
player_date_map = {}
player_id_to_player_map = {}
tournament_qualified_date = (
now - timedelta(days=tournament_qualified_day_limit))
print('Qualified Date: ' + str(tournament_qualified_date))
tournaments = dao.get_all_tournaments(regions=[dao.region_id])
for tournament in tournaments:
if tournament.excluded is True:
print 'Tournament Excluded:'
print 'Excluded - ' + str(tournament.name)
continue
if tournament_qualified_date <= tournament.date:
print 'Processing:', tournament.name.encode('utf-8'), str(
tournament.date)
for player_id in tournament.players:
player_date_map[player_id] = tournament.date
# TODO add a default rating entry when we add it to the map
for match in tournament.matches:
if match.excluded is True:
print('match excluded:')
print('Tournament: ' + str(tournament.name))
print(str(match))
continue
# don't count matches where either player is OOR
winner = dao.get_player_by_id(match.winner)
if dao.region_id not in winner.regions:
continue
loser = dao.get_player_by_id(match.loser)
if dao.region_id not in loser.regions:
continue
if match.winner not in player_id_to_player_map:
db_player = dao.get_player_by_id(match.winner)
db_player.ratings[dao.region_id] = model.Rating()
player_id_to_player_map[match.winner] = db_player
if match.loser not in player_id_to_player_map:
db_player = dao.get_player_by_id(match.loser)
db_player.ratings[dao.region_id] = model.Rating()
player_id_to_player_map[match.loser] = db_player
winner = player_id_to_player_map[match.winner]
loser = player_id_to_player_map[match.loser]
rating_calculators.update_trueskill_ratings(dao.region_id,
winner=winner,
loser=loser)
print 'Checking for player inactivity...'
rank = 1
players = player_id_to_player_map.values()
sorted_players = sorted(players,
key=lambda player: trueskill.expose(player.ratings[
dao.region_id].trueskill_rating()),
reverse=True)
ranking = []
for player in sorted_players:
player_last_active_date = player_date_map.get(player.id)
if player_last_active_date is None or \
dao.is_inactive(player, now, day_limit, num_tourneys) or \
dao.region_id not in player.regions:
pass # do nothing, skip this player
else:
ranking.append(
model.RankingEntry(
rank=rank,
player=player.id,
rating=trueskill.expose(
player.ratings[dao.region_id].trueskill_rating())))
rank += 1
print 'Updating players...'
for i, p in enumerate(players, start=1):
dao.update_player(p)
# TODO: log somewhere later
# print 'Updated player %d of %d' % (i, len(players))
print 'Inserting new ranking...'
dao.insert_ranking(
model.Ranking(id=ObjectId(),
region=dao.region_id,
time=now,
tournaments=[t.id for t in tournaments],
ranking=ranking))
print 'Done!'
def _create_ranking_from_tournament_list(
dao,
tournaments,
now,
day_limit,
num_tourneys,
tournament_qualified_day_limit,
ranking_to_diff_against):
player_date_map = {}
player_id_to_player_map = {}
tournament_qualified_date = (now - timedelta(days=tournament_qualified_day_limit))
print('Qualified Date: ' + str(tournament_qualified_date))
for tournament in tournaments:
if tournament_qualified_date <= tournament.date:
print 'Processing:', tournament.name.encode('utf-8'), str(tournament.date)
for player_id in tournament.players:
player_date_map[player_id] = tournament.date
# TODO add a default rating entry when we add it to the map
for match in tournament.matches:
if match.excluded is True:
print('match excluded:')
print('Tournament: ' + str(tournament.name))
print(str(match))
continue
if match.winner not in player_id_to_player_map:
db_player = dao.get_player_by_id(match.winner)
db_player.ratings[dao.region_id] = model.Rating()
player_id_to_player_map[match.winner] = db_player
if match.loser not in player_id_to_player_map:
db_player = dao.get_player_by_id(match.loser)
db_player.ratings[dao.region_id] = model.Rating()
player_id_to_player_map[match.loser] = db_player
winner = player_id_to_player_map[match.winner]
loser = player_id_to_player_map[match.loser]
rating_calculators.update_trueskill_ratings(
dao.region_id, winner=winner, loser=loser)
print 'Checking for player inactivity...'
rank = 1
players = player_id_to_player_map.values()
sorted_players = sorted(
players,
key=lambda player: (trueskill.expose(player.ratings[dao.region_id].trueskill_rating()), player.name),
reverse=True)
ranking = []
for player in sorted_players:
player_last_active_date = player_date_map.get(player.id)
if _is_player_inactive(dao, player, tournaments, player_last_active_date, now, day_limit, num_tourneys):
pass # do nothing, skip this player
else:
ranking.append(model.RankingEntry(
rank=rank,
player=player.id,
rating=trueskill.expose(player.ratings[dao.region_id].trueskill_rating()),
previous_rank=ranking_to_diff_against.get_ranking_for_player_id(player.id) if ranking_to_diff_against else None))
rank += 1
print 'Updating players...'
for i, p in enumerate(players, start=1):
dao.update_player(p)
# TODO: log somewhere later
# print 'Updated player %d of %d' % (i, len(players))
print 'Returning new ranking...'
return model.Ranking(
id=ObjectId(),
region=dao.region_id,
time=now,
tournaments=[t.id for t in tournaments],
ranking=ranking)
def generate_ranking(dao, now=datetime.now(), day_limit=60, num_tourneys=2, tournament_qualified_day_limit=999):
player_date_map = {}
player_id_to_player_map = {}
tournament_qualified_date = (now - timedelta(days=tournament_qualified_day_limit))
print('Qualified Date: ' + str(tournament_qualified_date))
tournaments = dao.get_all_tournaments(regions=[dao.region_id])
for tournament in tournaments:
if tournament.excluded is True:
print 'Tournament Excluded:'
print 'Excluded - ' + str(tournament.name)
continue
if tournament_qualified_date <= tournament.date:
print 'Processing:', tournament.name.encode('utf-8'), str(tournament.date)
for player_id in tournament.players:
player_date_map[player_id] = tournament.date
# TODO add a default rating entry when we add it to the map
for match in tournament.matches:
if match.excluded is True:
print('match excluded:')
print('Tournament: ' + str(tournament.name))
print(str(match))
continue
# don't count matches where either player is OOR
winner = dao.get_player_by_id(match.winner)
if dao.region_id not in winner.regions:
continue
loser = dao.get_player_by_id(match.loser)
if dao.region_id not in loser.regions:
continue
if match.winner not in player_id_to_player_map:
db_player = dao.get_player_by_id(match.winner)
db_player.ratings[dao.region_id] = model.Rating()
player_id_to_player_map[match.winner] = db_player
if match.loser not in player_id_to_player_map:
db_player = dao.get_player_by_id(match.loser)
db_player.ratings[dao.region_id] = model.Rating()
player_id_to_player_map[match.loser] = db_player
winner = player_id_to_player_map[match.winner]
loser = player_id_to_player_map[match.loser]
rating_calculators.update_trueskill_ratings(
dao.region_id, winner=winner, loser=loser)
print 'Checking for player inactivity...'
rank = 1
players = player_id_to_player_map.values()
sorted_players = sorted(
players,
key=lambda player: trueskill.expose(player.ratings[dao.region_id].trueskill_rating()), reverse=True)
ranking = []
for player in sorted_players:
player_last_active_date = player_date_map.get(player.id)
if player_last_active_date is None or \
dao.is_inactive(player, now, day_limit, num_tourneys) or \
dao.region_id not in player.regions:
pass # do nothing, skip this player
else:
ranking.append(model.RankingEntry(
rank=rank,
player=player.id, rating=trueskill.expose(player.ratings[dao.region_id].trueskill_rating())))
rank += 1
print 'Updating players...'
for i, p in enumerate(players, start=1):
dao.update_player(p)
# TODO: log somewhere later
# print 'Updated player %d of %d' % (i, len(players))
print 'Inserting new ranking...'
dao.insert_ranking(model.Ranking(
id=ObjectId(),
region=dao.region_id,
time=now,
tournaments=[t.id for t in tournaments],
ranking=ranking))
print 'Done!'
