dao,

now=datetime.now(),

day_limit=60,

num_tourneys=2,

tournament_qualified_day_limit=999,

tournament_to_diff=None):

tournaments = dao.get_all_tournaments(regions=[dao.region_id])

ranking_to_diff_against = None

if tournament_to_diff:

tournaments_for_diff = []

for tournament in tournaments:

tournaments_for_diff.append(tournament)

if tournament.id == tournament_to_diff.id:

break

ranking_to_diff_against = _create_ranking_from_tournament_list(

dao, tournaments_for_diff, tournament_to_diff.date, day_limit, num_tourneys, tournament_qualified_day_limit, None)

dao.insert_ranking(_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],

if (player_last_active_date is None or

dao.region_id not in player.regions):

return True

tournaments_for_player = [

tournament for tournament in tournaments if

tournament.contains_player(player) and tournament.date >= (now - timedelta(days=day_limit))]