def create_bracket(players): plr_len = len(players) std = [Bracket('Standard', str(i + 1)) for i in range(0, plr_len - 1)] lsr = [Bracket('Loser', str(i + 1)) for i in range(0, plr_len - 2)] fnl = [Bracket('Final', str(i + 1)) for i in range(0, 2)] return std, lsr, fnl
def bracket(): post_json = request.get_json() tiers = post_json['tiers'] bracket_type = post_json['bracket-type'] best_bracket = None lowest_score = None if bracket_type != 'single-elimination': bracket_type = 'double-elimination' for _ in range(100): players = get_randomnized_player_list(tiers) bracket = Bracket(players) scores = bracket.get_scores() score = scores[bracket_type] if bracket_type == 'double-elimination': score += scores['grand-finals'] if lowest_score is None or score < lowest_score: best_bracket = bracket lowest_score = score if score == 0: break return json.dumps({ 'winners-bracket': best_bracket.get_winners_bracket(), 'losers-bracket': best_bracket.get_losers_bracket(), 'grand-finals': best_bracket.get_grand_finals(), 'players': best_bracket.players, 'score': lowest_score, })
def test_add_players_to_bracket(self): p1_name, p2_name = "Alice", "Bob" p1_challonge_id, p2_challonge_id = "1001", "1002" # Challonge IDs p1_discord_id, p2_discord_id = 1, 2 # Discord IDs # Fake challonge call, will succeed mock_challonge = unittest.mock.MagicMock(spec=challonge.Client) mock_challonge.add_players = unittest.mock.MagicMock( return_value={ p1_name: p1_challonge_id, p2_name: p2_challonge_id, }) state = persistent.State("arbitraryID12") bracket = Bracket(mock_challonge, state) # Create the players. bracket.create_players({ p1_discord_id: p1_name, p2_discord_id: p2_name, }) self.assertEqual(2, len(bracket.players)) self.assertEqual(p1_discord_id, bracket.players[0].discord_id) self.assertEqual(p1_challonge_id, bracket.players[0].challonge_id) self.assertEqual(p2_discord_id, bracket.players[1].discord_id) self.assertEqual(p2_challonge_id, bracket.players[1].challonge_id)
def main(): teamList = deque() teamList.append('Stanford') teamList.append('UCLA') teamList.append('USC') teamList.append('Berkeley') print(teamList) #teamList = ['Stanford','UCLA', 'USC','Berkeley'] testBracket = Bracket(teamList) testBracket.evaluateBracket()
def test_pings_uncalled_players_exactly_once(self): p1_name, p2_name = "Alice", "Bob" # Discord names. p1_discord_id, p2_discord_id = 1, 2 # Discord IDs. p1_challonge_id, p2_challonge_id = "1001", "1002" # Challonge IDs. # Set "challonge" up to add Alice and Bob. mock_challonge = unittest.mock.MagicMock(spec=challonge.Client) mock_challonge.add_players = unittest.mock.MagicMock( return_value={ p1_name: p1_challonge_id, p2_name: p2_challonge_id, }) # Set "challonge" up to have 1 in progress match. match = challonge.Match("arbitrary_match_id", p1_challonge_id, p2_challonge_id) mock_challonge.list_matches = unittest.mock.MagicMock( return_value=[match]) # Not mocked, we're testing real logic here. state = persistent.State("arbitraryID12") bracket = Bracket(mock_challonge, state) # Mock out external dependencies. mock_discord_client = unittest.mock.MagicMock( spec=discord.ext.commands.Bot) output_channel = unittest.mock.MagicMock(spec=discord.TextChannel) output_channel.send.return_value.id = 1234 # Add players to the bracket. bracket.create_players({ p1_discord_id: p1_name, p2_discord_id: p2_name, }) bot = main.Tournament(mock_discord_client, bracket, 4206969, output_channel) _wait_for(bot.check_matches()) # Players should have been pinged, as there is 1 in-progress match that hasn't been called. output_channel.send.assert_called_once() self.assertIn(f"<@!{p1_discord_id}>", output_channel.send.call_args[0][0]) self.assertIn(f"<@!{p2_discord_id}>", output_channel.send.call_args[0][0]) # Check again. Because we already pinged the players once, they should not have been called again. output_channel.send.reset_mock() _wait_for(bot.check_matches()) output_channel.send.assert_not_called()
def generate_bracket(time, seeding): submission_folders = os.listdir('./submissions') if len(submission_folders) == 0: return None elif len(submission_folders) == 1: return submission_folders # Assumption: Each submission folder has a single submission file in it submission_agents = [] submission_import_strings = [] for folder in submission_folders: files = os.listdir('./submissions/' + folder) if len(files) > 1 or len(files) == 0: print(folder, ' has no or more than 1 files in submission') submission_import_strings.append(None) else: if files[0].split('.')[-1] == 'py': submission_import_strings.append('submissions/' + folder + '/' + files[0]) print('submissions/' + folder + '/' + files[0]) submission_pairs = list(zip(submission_folders, submission_import_strings)) submission_pairs_cleaned = [ x for x in submission_pairs if x[1] is not None ] print('Submission name/file pairs:') print(submission_pairs_cleaned) if seeding is not None: seeded_pairs = [] nonseeded_pairs = [] submission_dict = dict(submission_pairs_cleaned) submission_keys = list(submission_dict.keys()) for seed in seeding: if seed in submission_keys: seeded_pairs.append((seed, (submission_dict[seed]))) seed_dict = dict(seeded_pairs) seed_keys = list(seed_dict.keys()) for nonseed in submission_keys: if nonseed not in seed_keys: nonseeded_pairs.append((nonseed, submission_dict[nonseed])) submission_pairs_cleaned = seeded_pairs + nonseeded_pairs print('players:', submission_pairs_cleaned) return Bracket(submission_pairs_cleaned, time)
def determine_tourney_games_and_make_brackets(self): """ We don't have data saying which games were a part of the tournament, so we have to create it programmatically. Some assumptions: - all tournament games occur in March or April - the last game played by the winning team was the championship game - all round i games finish before any round i+1 games start Note we can't just take the last 63 games, because there are e.g., NIT tournament games mixed in. """ self.brackets = {} self.tournament_starts = {} for season in PAST_WINNERS: if season == "2011-2012": continue if season not in self.game_results_by_season: continue bracket = Bracket() dummy, tourney_year = season.split("-") games = [] for i, game in enumerate(self.game_results_by_season[season]): (date, home_id, away_id, home_score, away_score) = game year, month, day = date if not (month == 3 or month == 4): continue home_code = self.team_codes[home_id] away_code = self.team_codes[away_id] games.append((month * 100 + day, home_code, away_code, game)) surviving_teams = [PAST_WINNERS[season]] bracket.round[6] = surviving_teams for game in reversed(sorted(games)): num_surviving = len(surviving_teams) home_code, away_code = game[1], game[2] if home_code in surviving_teams: surviving_teams.append(away_code) elif away_code in surviving_teams: surviving_teams.append(home_code) else: continue r = 5 - int(np.floor(np.log2(num_surviving))) if r < 0: break bracket.round[r].append(game[3]) if season not in self.tournament_starts or \ game[0] < self.tournament_starts[season]: self.tournament_starts[season] = game[0] bracket.make_bracket_structure(team_codes=self.team_codes) self.brackets[season] = bracket
def __init__(self): self.tmpBracket = Bracket() self.formattedBracket = FormatBracket(self.tmpBracket)
class User: def __init__(self): self.tmpBracket = Bracket() self.formattedBracket = FormatBracket(self.tmpBracket) #the user interface for the user def beginning(self): into = 0 while (into != 6): into = input("Options:\n" "1. Make New Bracket:\n" "2. Print Team Schedules:\n" "3. Print Tourament Schedule:\n" "4. Change a Team Name: \n" "5. Output to a file: \n" "6. End the Session\n") if (into == 1): self.useBracket() elif (into == 2): self.printSchedules(into) elif (into == 3): self.printSchedules(into) elif (into == 4): self.changeTeamName() elif (into == 5): self.outputToFile() #making a formatting bracket def useBracket(self): try: gamesNum = input("Number of games per team to play: ") teamsNum = input("Number of teams in the tournament: ") poolsNum = input("Number of pools in the tourament: ") self.tmpBracket.makeBracket(gamesNum, teamsNum, poolsNum) tmpFB = FormatBracket(self.tmpBracket) self.formattedBracket = tmpFB except: print "Please give a valid information." #changes the name of a team #teamNum: the team number to replace #teamName: The name that the team will be replaced to. def changeTeamName(self): teamNum = input("Enter the Team Number to change: ") teamName = str(raw_input("Please enter the Team Name: ")) self.formattedBracket.__changeTeamName__(teamNum, teamName) #printType: 2 for Full Tournament Schedule #printType: 3 for Pools Schedule per Team #prints all of the Schedules def printSchedules(self, printType): if (printType == 2): print "Full Tournament Schedule: " self.formattedBracket.printSchedule("A") print elif (printType == 3): print "Pool Play for each Team:" self.formattedBracket.printSchedule("s") self.outputToFile() #outputs the formatted table to a file def outputToFile(self): self.formattedBracket.fileOutput()
def test_dq_both_players(self): """ Scenario in which neither player checks into their match. Asserts: 1. Both players are warned. 2. A score is set after the DQ interval. 3. No further messages are sent after that. """ warn_timer_in_secs = 1 dq_timer_in_secs = 2 emoji = "😀" # 2 Players, Alice and Bob. p1_name, p2_name = "Alice", "Bob" # Discord names. p1_discord_id, p2_discord_id = 1, 2 # Discord IDs. p1_challonge_id, p2_challonge_id = "1001", "1002" # Challonge IDs. tourney_id = "tourneyID12" # Set "challonge" up to add Alice and Bob. mock_challonge = unittest.mock.MagicMock(spec=challonge.Client) mock_challonge.add_players = unittest.mock.MagicMock( return_value={ p1_name: p1_challonge_id, p2_name: p2_challonge_id, }) # Set "challonge" up to have 1 in progress match (Alice vs Bob). match_id = "arbitrary_match_id" match = challonge.Match(match_id, p1_challonge_id, p2_challonge_id) mock_challonge.list_matches = unittest.mock.MagicMock( return_value=[match]) # Not mocked, we're testing real logic here. state = persistent.State(tourney_id) bracket = Bracket(mock_challonge, state) # Mock out external dependencies. mock_discord_client = unittest.mock.MagicMock( spec=discord.ext.commands.Bot) output_channel = unittest.mock.MagicMock(spec=discord.TextChannel) # Add players to the bracket. bracket.create_players({ p1_discord_id: p1_name, p2_discord_id: p2_name, }) bot = main.Tournament( mock_discord_client, bracket, 4206969, output_channel, options=main.Options( warn_timer_in_minutes=warn_timer_in_secs / 60, dq_timer_in_minutes=dq_timer_in_secs / 60, check_in_emoji=discord.PartialEmoji(name=emoji))) # Call the match. Set the ID to be returned from the sent message, so we can reference it later. match_call_message = unittest.mock.MagicMock(spec=discord.Message) match_call_message.id = 6942096 output_channel.send.return_value = match_call_message _wait_for(bot.check_matches()) output_channel.send.assert_called_once() self.assertIn(f"<@!{p1_discord_id}>", output_channel.send.call_args[0][0]) self.assertIn(f"<@!{p2_discord_id}>", output_channel.send.call_args[0][0]) # Neither player checks in. match_call_message.reactions = [_reaction(emoji)] util.get_user_ids = lambda _: _future({}) output_channel.fetch_message.return_value = match_call_message # 1. Both players should be warned. output_channel.send.reset_mock() time.sleep(warn_timer_in_secs) _wait_for(bot.check_matches()) output_channel.fetch_message.assert_called_with(match_call_message.id) self.assertGreaterEqual(output_channel.send.call_count, 2) self.assertIn(f"<@!{p1_discord_id}>", output_channel.send.call_args_list[0][0][0]) self.assertIn(f"<@!{p2_discord_id}>", output_channel.send.call_args_list[1][0][0]) # Nobody should have been DQ'd yet. mock_challonge.set_score.assert_not_called() # Wait until DQ deadline, nobody checks in still. time.sleep(dq_timer_in_secs - warn_timer_in_secs + 1) output_channel.send.reset_mock() _wait_for(bot.check_matches()) # 2. Make sure a score was set for the match so it doesn't hold up the bracket. output_channel.send.assert_called_once() mock_challonge.set_score.assert_called() # Let's assume that set_score failed, and so the match is still # returned by challonge.list_matches. # 3. Make sure we don't message the players again. output_channel.send.reset_mock() _wait_for(bot.check_matches()) output_channel.send.assert_not_called()
def determine_tourney_games_and_make_brackets(self): """ We don't have data saying which games were a part of the tournament, so we have to create it programmatically. Some assumptions: - all tournament games occur in March or April - the last game played by the winning team was the championship game - all round i games finish before any round i+1 games start Note we can't just take the last 63 games, because there are e.g., NIT tournament games mixed in. """ self.brackets = {} self.tournament_starts = {} for season in PAST_WINNERS: if season == "2011-2012": continue if season not in self.game_results_by_season: continue bracket = Bracket() dummy, tourney_year = season.split("-") games = [] for i, game in enumerate(self.game_results_by_season[season]): (date, home_id, away_id, home_score, away_score) = game year, month, day = date if not (month == 3 or month == 4): continue home_code = self.team_codes[home_id] away_code = self.team_codes[away_id] games.append((month*100+day, home_code, away_code, game)) surviving_teams = [PAST_WINNERS[season]] bracket.round[6] = surviving_teams for game in reversed(sorted(games)): num_surviving = len(surviving_teams) home_code, away_code = game[1], game[2] if home_code in surviving_teams: surviving_teams.append(away_code) elif away_code in surviving_teams: surviving_teams.append(home_code) else: continue r = 5 - int(np.floor(np.log2(num_surviving))) if r < 0: break bracket.round[r].append(game[3]) if season not in self.tournament_starts or \ game[0] < self.tournament_starts[season]: self.tournament_starts[season] = game[0] bracket.make_bracket_structure(team_codes=self.team_codes) self.brackets[season] = bracket
def test_get_score(self): b2021 = Bracket(teams2021) r1picks = [ gonzaga, oklahoma, ucsb, virginia, usc, kansas, oregon, iowa, michigan, lsu, colorado, fsu, ucla, texas, maryland, alabama, baylor, unc, villanova, purdue, texasTech, arkansas, vTech, ohioState, illinois, loyola, tenessee, osu, syracuse, wvu, rutgers, houston ] b2021.set_picks(r1picks) r2picks = [ gonzaga, virginia, usc, iowa, michigan, fsu, ucla, alabama, unc, purdue, texasTech, ohioState, illinois, osu, wvu, houston ] b2021.set_picks(r2picks) r3picks = [ gonzaga, iowa, fsu, alabama, purdue, ohioState, illinois, houston ] b2021.set_picks(r3picks) r4picks = [gonzaga, fsu, ohioState, houston] b2021.set_picks(r4picks) r5picks = [gonzaga, houston] b2021.set_picks(r5picks) championshipPick = [gonzaga] b2021.set_picks(championshipPick) r1winners = [ gonzaga, oklahoma, creighton, ohio, usc, kansas, oregon, iowa, michigan, lsu, colorado, fsu, ucla, abilChristian, maryland, alabama, baylor, wisconsin, villanova, nTexas, texasTech, arkansas, florida, oralRoberts, illinois, loyola, oregonState, osu, syracuse, wvu, rutgers, houston ] b2021.set_winners(r1winners) self.assertEqual(b2021.get_score(), 240) r2winners = [ gonzaga, creighton, usc, oregon, michigan, fsu, ucla, alabama, baylor, villanova, arkansas, oralRoberts, loyola, oregonState, syracuse, houston ] b2021.set_winners(r2winners) self.assertEqual(b2021.get_score(), 380) r3winners = [ gonzaga, usc, michigan, ucla, baylor, arkansas, oregonState, houston ] b2021.set_winners(r3winners) self.assertEqual(b2021.get_score(), 460) r4winners = [gonzaga, ucla, baylor, houston] b2021.set_winners(r4winners) self.assertEqual(b2021.get_score(), 620)
def test_set_picks(self): b2021 = Bracket(teams2021) self.assertEqual(len(b2021.bracket), 32) self.assertEqual(b2021.bracket[18].team1.return_name(), 'Villanova') self.assertEqual(b2021.bracket[18].team2.return_name(), 'Winthorp') self.assertEqual(b2021.bracket[18].pick, None) r1picks = [ gonzaga, oklahoma, ucsb, virginia, usc, kansas, oregon, iowa, michigan, lsu, colorado, fsu, ucla, texas, maryland, alabama, baylor, unc, villanova, purdue, texasTech, arkansas, vTech, ohioState, illinois, loyola, tenessee, osu, syracuse, wvu, rutgers, houston ] b2021.set_picks(r1picks) self.assertEqual(b2021.bracket[18].pick.return_name(), 'Villanova') self.assertEqual(b2021.bracket[41].team1.return_name(), 'Villanova') self.assertEqual(b2021.bracket[41].team2.return_name(), 'Purdue') self.assertEqual(len(b2021.bracket), 48) r2picks = [ gonzaga, virginia, usc, iowa, michigan, fsu, ucla, alabama, unc, purdue, texasTech, ohioState, illinois, osu, wvu, houston ] b2021.set_picks(r2picks) self.assertEqual(len(b2021.bracket), 56) r3picks = [ gonzaga, iowa, fsu, alabama, purdue, ohioState, illinois, houston ] b2021.set_picks(r3picks) self.assertEqual(len(b2021.bracket), 60) r4picks = [gonzaga, fsu, ohioState, houston] b2021.set_picks(r4picks) self.assertEqual(len(b2021.bracket), 62) r5picks = [gonzaga, houston] b2021.set_picks(r5picks) self.assertEqual(len(b2021.bracket), 63) championshipPick = [gonzaga] b2021.set_picks(championshipPick) self.assertEqual(b2021.bracket[62].team2.return_name(), 'Houston') self.assertEqual(b2021.bracket[62].pick.return_name(), 'Gonzaga') self.assertEqual(len(b2021.bracket), 63)
def test_create_initial_bracket(self): b2021 = Bracket(teams2021)
def make(self): # Extract paramaters arena_y_offset = self.params.two_arena_assembly['arena_y_offset'] camera_post_y_offset = self.params.two_arena_assembly[ 'camera_post_y_offset'] camera_post_x_offset = self.params.two_arena_assembly[ 'camera_post_x_offset'] breadboard_thickness = self.params.breadboard['thickness'] camera_plate_color = self.params.camera_plate['color'] camera_plate_z_frac = self.params.two_arena_assembly[ 'camera_plate_z_frac'] # Create components arena_pos = Arena_Assembly(params=self.params) arena_neg = Arena_Assembly(params=self.params) breadboard = Breadboard(**self.params.breadboard) camera_post_pos = Camera_Post(**self.params.camera_post) camera_post_neg = Camera_Post(**self.params.camera_post) camera_plate = Camera_Plate(**self.params.camera_plate) camera = Camera(**self.params.camera) bracket_dict = {} for i in (-1, 1): for j in (-1, 1): bracket_dict[(i, j)] = Bracket(**self.params.bracket) # Translate breadboard into position breadboard.translate(v=(0, 0, -0.5 * breadboard_thickness)) # Translate arenas into position arena_pos.translate(v=(0, arena_y_offset, 0)) arena_neg.translate(v=(0, -arena_y_offset, 0)) # Translate camera posts into position z_shift = 0.5 * self.params.camera_post['length'] camera_post_pos.translate(v=(camera_post_x_offset, camera_post_y_offset, z_shift)) camera_post_neg.translate(v=(camera_post_x_offset, -camera_post_y_offset, z_shift)) # Rotate and translate camera plate into position camera_plate.rotate(a=90, v=(1, 0, 0)) camera_plate.rotate(a=90, v=(0, 0, 1)) z_shift = 0.5 * self.params.camera_plate['width'] z_shift += camera_plate_z_frac * self.params.camera_post['length'] z_shift -= self.params.camera_plate['width'] x_shift = camera_post_x_offset + 0.5 * self.params.camera_post['width'] x_shift += 0.5 * self.params.camera_plate['thickness'] camera_plate.translate(v=(x_shift, 0, z_shift)) camera_plate.color(rgba=self.params.camera_plate['color']) # Rotate and translate camera into position camera.rotate(a=90, v=(0, 1, 0)) z_shift = camera_plate_z_frac * self.params.camera_post['length'] z_shift -= 0.5 * self.params.camera_plate['width'] x_shift = camera_post_x_offset + 0.5 * self.params.camera_post['width'] x_shift += self.params.camera_plate['thickness'] x_shift += 0.5 * self.params.camera['body_thickness'] camera.translate(v=(x_shift, 0, z_shift)) camera.color(rgba=self.params.camera['color']) # Rotate and translate brackets into positon for k, bracket in bracket_dict.iteritems(): i, j = k if i == 1: bracket.rotate(a=180, v=(0, 0, 1)) x_shift = 0.5 * self.params.bracket['length'] x_shift += camera_post_x_offset x_shift += 0.5 * self.params.camera_post['width'] else: x_shift = -0.5 * self.params.bracket['length'] x_shift += camera_post_x_offset x_shift -= 0.5 * self.params.camera_post['width'] y_shift = j * camera_post_y_offset bracket.translate(v=(x_shift, y_shift, 0)) bracket.color(rgba=self.params.bracket['color']) # Create parts dictionary self.parts = { 'breadboard': breadboard, 'arena_pos': arena_pos, 'arena_neg': arena_neg, 'camera_post_pos': camera_post_pos, 'camera_post_neg': camera_post_neg, 'camera_plate': camera_plate, 'camera': camera, } for k, bracket in bracket_dict.iteritems(): i, j = k name = 'bracket' if i == 1: name = '%s_posx' % (name, ) else: name = '%s_negx' % (name, ) if j == 1: name = '%s_posy' % (name, ) else: name = '%s_negy' % (name, ) self.parts[name] = bracket
moreheadState = Team('Midwest', 14, 'Morehead State') clevelandState = Team('Midwest', 15, 'Cleveland State') drexel = Team('Midwest', 16, 'Drexel') teams2021 = [ gonzaga, norfolk, oklahoma, missouri, creighton, ucsb, virginia, ohio, usc, drake, kansas, eWash, oregon, vcu, iowa, gcu, michigan, texasS, lsu, bonaventure, colorado, georgetown, fsu, greensboro, byu, ucla, texas, abilChristian, uConn, maryland, alabama, iona, baylor, hartford, unc, wisconsin, villanova, winthorp, purdue, nTexas, texasTech, utahState, arkansas, colgate, florida, vTech, ohioState, oralRoberts, illinois, drexel, loyola, gatech, tenessee, oregonState, osu, liberty, sdState, syracuse, wvu, moreheadState, clemson, rutgers, houston, clevelandState ] b2021 = Bracket(teams2021) r1picks = [ gonzaga, oklahoma, creighton, virginia, usc, kansas, oregon, iowa, michigan, lsu, colorado, fsu, byu, texas, uConn, alabama, baylor, unc, villanova, purdue, texasTech, arkansas, florida, ohioState, illinois, loyola, tenessee, osu, sdState, wvu, clemson, houston ] b2021.set_picks(r1picks) r2picks = [ gonzaga, virginia, kansas, iowa, michigan, fsu, texas, alabama, baylor, purdue, arkansas, ohioState, illinois, osu, wvu, houston ] b2021.set_picks(r2picks) r3picks = [ gonzaga, iowa, michigan, alabama, baylor, ohioState, illinois, houston ]