def __calculate_player_results(self):
database = Database()
self.__week_data = database.load_week_data(self.year,self.week_number)
self.__calc = CalculateResults(self.__week_data)
assert self.player_id in self.__week_data.players,"Bad player id"
self.__player = self.__week_data.players[self.player_id]
self.__calculate_player_summary()
self.__calculate_player_game_results_sorted_by_game_number()
def __setup_data_to_use(self, year, week_number, week_data_supplied=None):
if week_data_supplied != None:
week_data = week_data_supplied
else:
database = Database()
week_data = database.load_week_data(year, week_number)
calc = CalculateResults(week_data)
self.__players = week_data.players # save to lookup player by id
data = WeekWinnerCalculationData()
data.player_wins = dict()
data.player_projected_wins = dict()
data.player_featured_game_picks = dict()
data.player_submit_times = dict()
data.week_state = calc.get_summary_state_of_all_games()
data.featured_game = calc.get_featured_game()
data.week = week_data.week
if data.featured_game.game_state == NOT_STARTED:
data.featured_game_winner = None
data.featured_game_ahead = None
if data.featured_game.game_state == IN_PROGRESS:
data.featured_game_winner = None
data.featured_game_ahead = calc.get_team_winning_pool_game(
data.featured_game)
if data.featured_game.game_state == FINAL:
data.featured_game_winner = calc.get_pool_game_winner(
data.featured_game)
data.featured_game_ahead = None
for player_id in week_data.players:
player = week_data.players[player_id]
data.player_wins[player_id] = calc.get_number_of_wins(player)
data.player_projected_wins[
player_id] = calc.get_number_of_projected_wins(player)
if calc.player_did_not_pick(player, data.featured_game):
data.player_featured_game_picks[player_id] = None
data.player_submit_times[player_id] = None
else:
data.player_featured_game_picks[
player_id] = calc.get_player_pick_for_game(
player, data.featured_game)
data.player_submit_times[
player_id] = calc.get_player_submit_time(
player, data.week)
return data
def load_week_data(year,week_number):
d = Database()
data = d.load_week_data(year,week_number)
return data
class LoadWeekDataTest(TestCase):
@classmethod
def setUpClass(cls):
test_db = UnitTestDatabase()
test_db.setup_simple_week(2014,1)
test_db.load_historical_data_for_year(2013)
super(LoadWeekDataTest, cls).setUpClass()
@classmethod
def tearDownClass(cls):
test_db = UnitTestDatabase()
test_db.delete_database()
super(LoadWeekDataTest, cls).tearDownClass()
def setUp(self):
self.db = Database()
# call the load_week_data function
def test_function_call(self):
data = self.db.load_week_data(2014,1)
self.assertIsNotNone(data)
# invalid year parameter
def test_bad_year_parameter(self):
with self.assertRaises(Exception):
data = self.db.load_week_data(1978,1)
# invalid week parameter
def test_bad_week_parameter(self):
with self.assertRaises(Exception):
data = self.db.load_week_data(2014,15)
# load the week information
def test_week_data_present(self):
week = self.db.load_week_data(2014,1).week
self.assertEqual(week.year.yearnum,2014)
self.assertEqual(week.weeknum,1)
# load the games indexed by game number information
def test_week_games_data_present(self):
data = self.db.load_week_data(2014,1)
self.assertEqual(len(data.games),10)
self.assertEqual(set(data.games.keys()),set([1,2,3,4,5,6,7,8,9,10]))
for game in data.games.values():
self.assertEqual(game.week,data.week)
# load the games indexed by id information
def test_week_games_id_data_present(self):
data = self.db.load_week_data(2014,1)
self.assertEqual(len(data.games_id),10)
for game_id in data.games_id:
game = data.games_id[game_id]
self.assertEqual(game.week,data.week)
self.assertEqual(game_id,game.id)
# load the games indexed by id information
def test_week_games_are_same(self):
data = self.db.load_week_data(2014,1)
for game in data.games.values():
self.assertIn(game.id,data.games_id)
# load the teams
def test_teams_data_present(self):
data = self.db.load_week_data(2014,1)
self.assertGreater(len(data.teams),0)
self.assertIn('Georgia Tech',data.teams)
self.assertIn('South Carolina',data.teams)
self.assertIn('Clemson',data.teams)
self.assertIn(data.teams['Georgia Tech'].team_name,'Georgia Tech')
self.assertIn(data.teams['South Carolina'].team_name,'South Carolina')
self.assertIn(data.teams['Clemson'].team_name,'Clemson')
# load the players
def test_players_data_present(self):
data = self.db.load_week_data(2014,1)
self.assertGreater(len(data.players),0)
player_names = [ p.public_name for p in data.players.values() ]
self.assertIn('Brent',player_names)
self.assertIn('John',player_names)
# load the picks
def test_picks_data_present(self):
data = self.db.load_week_data(2014,1)
self.assertGreater(len(data.picks),0)
for pick in data.picks.values():
self.assertEqual(pick.game.week.weeknum,1)
self.assertEqual(pick.game.week.year.yearnum,2014)
# load the player_picks information
def test_player_picks_data_present(self):
data = self.db.load_week_data(2014,1)
self.assertGreater(len(data.player_picks),0)
for player_id in data.player_picks:
player_picks = data.player_picks[player_id]
self.assertEqual(len(player_picks),10)
for pick in player_picks:
self.assertEqual(pick.player.id,player_id)
self.assertEqual(pick.game.week,data.week)
def test_get_week_numbers(self):
self.__get_weeks_test(2013,[1,2,3,4,5,6,7,8,9,10,11,12,13])
def test_get_week_numbers_bad_year(self):
self.__get_weeks_invalid_year_test()
def __get_weeks_test(self,year,expected_weeks):
d = Database()
weeks = d.get_week_numbers(year)
self.assertIsNotNone(weeks)
self.assertEqual(weeks,expected_weeks)
def __get_weeks_invalid_year_test(self):
d = Database()
with self.assertRaises(Exception):
weeks = d.get_week_numbers(1900)
to_field = get_staff_email_addresses()
if len(to_field) <= 0:
print("Could not find any staff email addresses")
return
try:
send_mail(subject,message,cfp_settings.DEFAULT_FROM_EMAIL,to_field)
except:
print("Failed to send an email to %s" % (to_field))
if __name__ == "__main__":
year,week = get_current_week()
data = database.load_week_data(year,week)
deadline = data.week.pick_deadline
if trigger_script(deadline):
print("Finding players with no picks for %d week %d" % (year,week))
find_players_without_picks(data)
fill_in_player_email_and_timezone()
send_admin_email(year,week,deadline)
if len(players) == 0:
print("All players have entered their picks.")
else:
for player in players:
class LoadWeekDataTest(TestCase):
@classmethod
def setUpClass(cls):
test_db = UnitTestDatabase()
test_db.setup_simple_week(2014,1)
test_db.load_historical_data_for_year(2013)
super(LoadWeekDataTest, cls).setUpClass()
@classmethod
def tearDownClass(cls):
test_db = UnitTestDatabase()
test_db.delete_database()
super(LoadWeekDataTest, cls).tearDownClass()
def setUp(self):
self.db = Database()
# call the load_week_data function
def test_function_call(self):
data = self.db.load_week_data(2014,1)
self.assertIsNotNone(data)
# invalid year parameter
def test_bad_year_parameter(self):
with self.assertRaises(Exception):
data = self.db.load_week_data(1978,1)
# invalid week parameter
def test_bad_week_parameter(self):
with self.assertRaises(Exception):
data = self.db.load_week_data(2014,15)
# load the week information
def test_week_data_present(self):
week = self.db.load_week_data(2014,1).week
self.assertEqual(week.year.yearnum,2014)
self.assertEqual(week.weeknum,1)
# load the games indexed by game number information
def test_week_games_data_present(self):
data = self.db.load_week_data(2014,1)
self.assertEqual(len(data.games),10)
self.assertEqual(set(data.games.keys()),set([1,2,3,4,5,6,7,8,9,10]))
for game in data.games.values():
self.assertEqual(game.week,data.week)
# load the games indexed by id information
def test_week_games_id_data_present(self):
data = self.db.load_week_data(2014,1)
self.assertEqual(len(data.games_id),10)
for game_id in data.games_id:
game = data.games_id[game_id]
self.assertEqual(game.week,data.week)
self.assertEqual(game_id,game.id)
# load the games indexed by id information
def test_week_games_are_same(self):
data = self.db.load_week_data(2014,1)
for game in data.games.values():
self.assertIn(game.id,data.games_id)
# load the teams
def test_teams_data_present(self):
data = self.db.load_week_data(2014,1)
self.assertGreater(len(data.teams),0)
self.assertIn('Georgia Tech',data.teams)
self.assertIn('South Carolina',data.teams)
self.assertIn('Clemson',data.teams)
self.assertIn(data.teams['Georgia Tech'].team_name,'Georgia Tech')
self.assertIn(data.teams['South Carolina'].team_name,'South Carolina')
self.assertIn(data.teams['Clemson'].team_name,'Clemson')
# load the players
def test_players_data_present(self):
data = self.db.load_week_data(2014,1)
self.assertGreater(len(data.players),0)
player_names = [ p.public_name for p in data.players.values() ]
self.assertIn('Brent',player_names)
self.assertIn('John',player_names)
# load the picks
def test_picks_data_present(self):
data = self.db.load_week_data(2014,1)
self.assertGreater(len(data.picks),0)
for pick in data.picks.values():
self.assertEqual(pick.game.week.weeknum,1)
self.assertEqual(pick.game.week.year.yearnum,2014)
# load the player_picks information
def test_player_picks_data_present(self):
data = self.db.load_week_data(2014,1)
self.assertGreater(len(data.player_picks),0)
for player_id in data.player_picks:
player_picks = data.player_picks[player_id]
self.assertEqual(len(player_picks),10)
for pick in player_picks:
self.assertEqual(pick.player.id,player_id)
self.assertEqual(pick.game.week,data.week)
def test_get_week_numbers(self):
self.__get_weeks_test(2013,[1,2,3,4,5,6,7,8,9,10,11,12,13])
def test_get_week_numbers_bad_year(self):
self.__get_weeks_invalid_year_test()
def __get_weeks_test(self,year,expected_weeks):
d = Database()
weeks = d.get_week_numbers(year)
self.assertIsNotNone(weeks)
self.assertEqual(weeks,expected_weeks)
def __get_weeks_invalid_year_test(self):
d = Database()
with self.assertRaises(Exception):
weeks = d.get_week_numbers(1900)
pass
player = utils.get_player_from_public_name(1978, 'Brent')
utils.login_assigned_user('Brent', player=player)
utils.login_unassigned_user('user1')
##############################################################################
from pick10.models import *
from pick10.tests.unit_test_database import UnitTestDatabase
from pick10.calculator import CalculateResults, FINAL
from pick10.database import Database
from pick10.calculate_tiebreak import CalculateTiebreak
from pick10.week_winner import WeekWinner
yearnum = 1978
weeknum = 1
playerid = 1
test_db = UnitTestDatabase()
test_db.setup_week_final(yearnum, weeknum)
test_db.setup_week_no_picks(yearnum, weeknum + 1, FINAL)
database = Database()
week_data = database.load_week_data(yearnum, weeknum)
calc = CalculateResults(week_data)
player = week_data.players[playerid]
week = week_data.week
game = calc.get_featured_game()
winners = WeekWinner(yearnum, weeknum)
calc.get_player_submit_time(player, week)
ctb = CalculateTiebreak(yearnum, weeknum)
