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
]
