def main():
with open('creds.json') as f:
creds = json.loads(f.read())
challonge.set_credentials(creds['username'], creds['APIKey'])
tournament_url = creds['tournamentURL']
first_time_flag = True
while True:
tournament = challonge.tournaments.show(tournament_url)
if first_time_flag:
print("Awaiting tournament...")
while tournament["started_at"] == None:
tournament = challonge.tournaments.show(tournament_url)
time.sleep(2)
continue
first_time_flag = False
print("Tournament found!")
if tournament["progress_meter"] == 100:
print("Tournament is over. Thank you for using.")
break
params = get_and_parse_custom_parameters()
if params["ACPN"].upper() == "TRUE":
tree = make_next_match_etree_with_custom_parameters(
tournament, params)
else:
tree = make_next_match_etree(tournament)
print("Matches parsed. Writing to file.")
tree.write("matches.xml")
print("Done! Refreshing in 5 seconds.\n")
time.sleep(5)
def loadConfig():
if config.configExists():
config.loadConfig()
challonge.set_credentials(config.config['challonge']['username'],
config.config['challonge']['apiKey'])
else:
pass
def new_matchups_from_str(username: str, api_key: str, url: str):
challonge.set_credentials(username, api_key)
#so the top n players get a bye, where n is the smallest number s.t. n+t=2^k, where t is the toal number of players, and k is an integer. Or if n = 0, everyone fights in round one.
subdomain = url[url.find("//")+2:url.find(".")]
tourney_name = url[url.rfind("/")+1:]
if subdomain == "challonge":
query = tourney_name
else:
query = subdomain + "-" + tourney_name
participants = []
#make list of participants ordered by seed (which is order api returns)
for participant in challonge.participants.index(query): #doesn't like this
participants.append(participant['name'])
round_one_participants = len(participants) - stupid_func(len(participants))
round_one_matchups = set()
round_one_players = participants[(-1*round_one_participants):]
i = 0
j = len(round_one_players)-1
while i < j:
player_one = normalize(round_one_players[i])
player_two = normalize(round_one_players[j])
if player_two < player_one:
player_one, player_two = player_two, player_one
round_one_matchups.add(frozenset([player_one, player_two]))
i+=1
j-=1
return round_one_matchups
def __init__(self, socketId, parent=None):
super(tournamentServerThread, self).__init__(parent)
self.log = logging.getLogger(__name__)
self.app = None
challonge.set_credentials(CHALLONGE_USER, CHALLONGE_KEY)
self.socket = QtNetwork.QTcpSocket(self)
self.socket.setSocketDescriptor(socketId)
self.parent = parent
if self.socket.state() == 3 and self.socket.isValid():
self.nextBlockSize = 0
self.blockSize = 0
self.socket.readyRead.connect(self.readDatas)
self.socket.disconnected.connect(self.disconnection)
#self.socket.error.connect(self.displayError)
self.parent.db.open()
self.pingTimer = QtCore.QTimer(self)
self.pingTimer.start(31000)
self.pingTimer.timeout.connect(self.ping)
def __init__(self, socketId, parent=None):
super(tournamentServerThread, self).__init__(parent)
self.log = logging.getLogger(__name__)
self.app = None
challonge.set_credentials(CHALLONGE_USER, CHALLONGE_KEY)
self.socket = QtNetwork.QTcpSocket(self)
self.socket.setSocketDescriptor(socketId)
self.parent = parent
if self.socket.state() == 3 and self.socket.isValid():
self.nextBlockSize = 0
self.blockSize = 0
self.socket.readyRead.connect(self.readDatas)
self.socket.disconnected.connect(self.disconnection)
self.parent.db.open()
self.pingTimer = QtCore.QTimer(self)
self.pingTimer.start(31000)
self.pingTimer.timeout.connect(self.ping)
def tournaments(request):
if request.method == 'POST':
form = TournamentForm(request.POST)
if form.is_valid():
challonge.set_credentials("moomoomamoo", "ZGhkIWPh05JyAhwmQI1S8BqYBD7DieZsaKPePIYo")
url = form.cleaned_data['url']
tournament_data = challonge.tournaments.show(url)
name = tournament_data["name"]
description = tournament_data["description"]
created_at = tournament_data["created-at"]
newTournament = ChallongeTournament(name=name,description=description,url=url,created_at=created_at,updated_at=created_at)
newTournament.save()
tournament_create_data(challonge, url, newTournament, created_at)
tournament_update_data(datetime.datetime.now())
#check if url is unqiue and if the tourney is completed
#newTournament = ChallongeTournament(name=name, url=url, updated_at=updated_at)
#tournament_update_data()
else:
form = TournamentForm()
tournaments = ChallongeTournament.objects.all().order_by("created_at")
i=2
doit=True
while(doit==True):
try:
tournaments.append(tournments[i])
tournament[i] = None
i += 3
except:
doit=False
return render(request, 'main/tournaments.html', {'form': form, 'tournaments': tournaments})
def login():
obj = None
with open(login_path) as f:
obj = json.load(f)
challonge_credentials = obj["challonge"]
challonge.set_credentials(challonge_credentials["username"], challonge_credentials["key"])
def main():
user = '******'
key = 'WVcRiQ7UCjMd5JxyGpzXKk7M36KNot2cALXitGSj'
mid = 'gg1115'
challonge.set_credentials(user, key)
tournament = challonge.tournaments.show(mid)
# Represented as dicts
print(tournament["id"]) # 3272
print(tournament["name"]) # My Awesome Tournament
print(tournament["started-at"]) # None
# Retrieve the participants for a given tournament.
p = challonge.participants.index(tournament["id"])
print(len(p))
# Get matches
matches = challonge.matches.index(tournament['id'])
for m in matches:
print(find_player(p, m['winner-id'])['name'] + ' <def.> ' +
find_player(p, m['loser-id'])['name'])
print("\nend")
def setchallonge_init(self):
"""Init Challonge api."""
if not self.check_credentials():
return False
challonge.set_credentials(self.settings["API_USERNAME"],
self.settings["API_KEY"])
return True
def start_compo(request, competition_id):
competition = get_object_or_404(Competition, pk=competition_id)
if competition.status == 1:
try:
names = []
teams, users = competition.get_participants()
if competition.use_teams:
for team in teams:
names.append(team.title)
else:
for user in users:
names.append(user.username)
if len(names) < 2:
messages.error(request, _(u'Too few participants'))
return redirect(competition)
if competition.tournament_format is None:
messages.error(
request,
_(u'Set competition tournament format before using this feature.'
))
return redirect(competition)
if settings.CHALLONGE_INTEGRATION_ENABLED and settings.CHALLONGE_API_USERNAME != '' and \
settings.CHALLONGE_API_KEY != '':
challonge.set_credentials(settings.CHALLONGE_API_USERNAME,
settings.CHALLONGE_API_KEY)
url = unicode(competition.lan) + unicode(
competition.activity) + unicode(int(time.time()))
url = re.sub('[^0-9a-zA-Z]+', '', url)
challonge.tournaments.create(
competition.activity.title,
url,
tournament_type=competition.tournament_format)
challonge.participants.bulk_add(url, names)
challonge.tournaments.start(url)
cparticipants = challonge.participants.index(url)
for part in cparticipants:
if not competition.use_teams:
par = Participant.objects.get(
user__username=part['name'],
competition=competition)
else:
par = Participant.objects.get(team__title=part['name'],
competition=competition)
par.cid = part['id']
par.save()
competition.challonge_url = url
update_match_list(request, competition)
competition.status = 3
competition.save()
messages.success(request, _(u'Tournament has started.'))
except Exception:
messages.error(request, _(u'Something went wrong.'))
return redirect(competition)
def setUp(self):
challonge.set_credentials(username, api_key)
self.t_name = _get_random_name()
self.ps_names = [_get_random_name(), _get_random_name()]
self.t = challonge.tournaments.create(self.t_name, self.t_name)
self.ps = challonge.participants.bulk_add(
self.t['id'],
self.ps_names)
def __init__(self, participant_names, participant_ids, tournament_name, game, url=shortuuid.uuid()[:8], tournament_type='double elimination'):
self.participant_names = participant_names
self.participant_ids = participant_ids
self.tournament_name = tournament_name
self.game = game
self.url = url
self.tournament_type = tournament_type
challonge.set_credentials(config('CHALLONGE_USERNAME'), config('CHALLONGE_API_KEY'))
def test_get_participants(self):
challonge.set_credentials(self.api_username, self.api_key)
tournament = challonge.tournaments.show(self.tournament_url)
participants = challonge.participants.index(tournament["id"])
test_players = ['DTMP', 'zaxtorp', 'hamroctopus', 'davethecust']
for player in participants:
self.assertIn(player['name'], test_players)
def setUp(self):
challonge.set_credentials(username, api_key)
self.t_name = _get_random_name()
self.ps_names = [_get_random_name(), _get_random_name()]
self.t = challonge.tournaments.create(self.t_name, self.t_name)
self.ps = challonge.participants.bulk_add(
self.t['id'],
self.ps_names)
def gen_records(username: str, api_key: str, tournaments: str):
challonge.set_credentials(username, api_key)
# Define our set named tuples
Set = namedtuple("Set", "winner loser t_url")
player_list = set()
season_sets = list(
) #season sets is a list of (winner,loser, url) tuples. There is one tuple per set, for each set in the list of urls provided.
(tournament_urls, tournament_queries,
tournament_names) = normalize_urls(tournaments)
for i in range(len(tournament_queries)):
participants = challonge.participants.index(tournament_queries[i])
matches = challonge.matches.index(tournament_queries[i])
#create a map of player_id->name since the matches structure below identifies players by their id, not name.
player_ids = {}
for participant in participants:
name = participant['name']
player_id = participant['id']
player_ids[player_id] = normalize(name)
player_list.update(player_ids.values())
for match in matches:
winner = player_ids[match['winner_id']]
loser = player_ids[match['loser_id']]
season_sets.append(
Set(winner=winner, loser=loser, t_url=tournament_urls[i]))
player_list = sorted(player_list, key=str.lower)
# Initialize an empty record for each player.
# A record is a defined as a dict mapping a player name to a 2-tuple of 2-tuple: ((wins, [tourney_urls]),(losses, [tourney_urls]))
# Player Name =>
# - Player 2 Name =>
# - Wins, URLs of tournaments
# - Losses, URLs of tournaments
#
# Using this format makes our data manipulation and walking very simple.
season_records = {}
for p in player_list:
season_records[p] = {}
for p2 in player_list:
if p2 == p:
continue
season_records[p][p2] = [[0, []], [0, []]]
for s in season_sets:
w, l, u = s
season_records[w][l][0][0] += 1
season_records[w][l][0][1].append(
u) #Is it possible to efficently sort as they're inserted?
season_records[l][w][1][0] += 1
season_records[l][w][1][1].append(u)
return (player_list, season_records)
def setUp(self):
challonge.set_credentials(username, api_key)
self.t_name = _get_random_name()
self.t = challonge.tournaments.create(self.t_name, self.t_name)
self.p1_name = _get_random_name()
self.p1 = challonge.participants.create(self.t["id"], self.p1_name)
self.p2_name = _get_random_name()
self.p2 = challonge.participants.create(self.t["id"], self.p2_name)
def setUp(self):
challonge.set_credentials(username, api_key)
self.t_name = _get_random_name()
self.t = challonge.tournaments.create(self.t_name, self.t_name)
self.p1_name = _get_random_name()
self.p1 = challonge.participants.create(self.t["id"], self.p1_name)
self.p2_name = _get_random_name()
self.p2 = challonge.participants.create(self.t["id"], self.p2_name)
def get(self):
current_user = get_user_from_auth_header(request, api)
try:
challonge.set_credentials(current_user.challonge_username, xor_crypt_string(current_user.api_key, decode=True))
tournaments = challonge.tournaments.index()
return jsonify({'tournaments' : tournaments})
except HTTPError as e:
api.abort(401, 'Invalid credentials.')
def maxRounds(tournament):
challonge.set_credentials(challonge_username, challonge_key)
maxRound = [1, 1]
for match in challonge.matches.index(tournament["id"]):
if match["round"] > 0:
maxRound[0] = max(maxRound[0], match["round"])
else:
maxRound[1] = max(maxRound[1], abs(match["round"]))
return maxRound
def get_predictions_thread():
load_dotenv()
api_key = get_api_key()
challonge.set_credentials('lstmemery', api_key)
return challonge.tournaments.show(
'madness2022', **{
'include_participants': 1,
'include_matches': 1,
'include_predictions': 1
})
def post(self):
try:
# set the credentials for interfacing with challonge
challonge_username = request.json['challonge_username']
api_key = request.json['api_key']
challonge.set_credentials(challonge_username, api_key)
# index returns a list of the user's tournaments
tournaments = challonge.tournaments.index()
return jsonify({'tournaments' : tournaments})
except HTTPError as e:
api.abort(401, 'Invalid credentials.')
def initialize_challonge_data(self): challonge.set_credentials(self.username, self.api_key) self.tournament = challonge.tournaments.show(self.tournament_url) all_players_raw = challonge.participants.index(self.tournament['id']) for participant in all_players_raw: name = participant['display-name'] self.participant_ids[participant['id']] = name self.all_players.append(name)
def complete_match(request, competition, match):
if settings.CHALLONGE_INTEGRATION_ENABLED and settings.CHALLONGE_API_USERNAME != '' and settings.CHALLONGE_API_KEY != '':
challonge.set_credentials(settings.CHALLONGE_API_USERNAME, settings.CHALLONGE_API_KEY)
challonge.matches.update(competition.challonge_url, match.matchid, scores_csv=match.final_score,
winner_id=match.winner.cid)
match.state = 'complete'
match.save()
update_match_list(request, competition)
if not Match.objects.filter(competition=competition, state='open'):
competition.status = 4
challonge.tournaments.finalize(competition.challonge_url)
competition.save()
async def get_predictions(loop):
load_dotenv()
api_key = get_api_key()
challonge.set_credentials('lstmemery', api_key)
tourney = await challonge.tournaments.show(
'madness2022', **{
'include_participants': 1,
'include_matches': 1,
'include_predictions': 1
})
print('Done')
def setUp(self):
self.api_username = os.environ['CHALLONGE_USERNAME']
self.api_key = os.environ['CHALLONGE_API_KEY']
challonge.set_credentials(self.api_username, self.api_key)
self.t = challonge.tournaments.create(
'AuTO Test Tournament',
"autoto_" + "".join(random.choice(string.ascii_lowercase)
for _ in range(0, 15)))
self.p1 = challonge.participants.create(self.t['id'], 'DTMP')
self.p2 = challonge.participants.create(self.t['id'], 'hamroctopus')
challonge.tournaments.start(self.t['id'])
def complete_match(request, competition, match):
if settings.CHALLONGE_INTEGRATION_ENABELED and settings.CHALLONGE_API_USERNAME != '' and settings.CHALLONGE_API_KEY != '':
challonge.set_credentials(settings.CHALLONGE_API_USERNAME, settings.CHALLONGE_API_KEY)
challonge.matches.update(competition.challonge_url, match.matchid, scores_csv=match.final_score,
winner_id=match.winner.cid)
match.state = 'complete'
match.save()
update_match_list(request, competition)
if not Match.objects.filter(competition=competition, state='open'):
competition.status = 4
challonge.tournaments.finalize(competition.challonge_url)
competition.save()
def __init__(self, user, secretKey, tourneys):
self.user = user
self.secretKey = secretKey
challonge.set_credentials(self.user, self.secretKey)
self.playerDict = {}
self.ctourneyCount = Counter()
self.matchData = {}
multipool = Pool(8)
multipool.map(self._get_players, tourneys)
multipool.map(self._get_matches, tourneys)
def finished_matches(flag):
bracket_url = get_bracket_url()
file = open('api-key.txt', 'r')
apikey = file.read()
file.close()
# setup pychallonge
try:
sendmsg("fetching match results ..")
challonge.set_credentials("aptmac", apikey)
tournament = challonge.tournaments.show(get_bracket_id())
# get response with all participant info
participants = challonge.participants.index(tournament["id"])
players = {}
for participant in participants:
players[participant["id"]] = participant["display-name"]
# get the matches with state complete
matches = challonge.matches.index(tournament["id"])
# if showing --all matches
if flag.strip() == '--all':
sendmsg("\(`O`)/: All completed matches this tournament are:")
for match in matches:
if match["state"] == 'complete':
score = match["scores-csv"]
if ',' in score:
scores = score.split(',')
score = scores[len(scores) - 1]
sendmsg(players[match["player1-id"]].split()[0][::-1] +
' ' + score + ' ' +
players[match["player2-id"]].split()[0][::-1])
time.sleep(0.5)
else:
sendmsg(
"\(`O`)/: The last 5 completed matches this tournament are:")
i = 0
for match in reversed(matches):
if match["state"] == 'complete':
score = match["scores-csv"]
if ',' in score:
scores = score.split(',')
score = scores[len(scores) - 1]
sendmsg(players[match["player1-id"]].split()[0][::-1] +
' ' + score + ' ' +
players[match["player2-id"]].split()[0][::-1])
time.sleep(0.5)
i = i + 1
if i == 5:
break
except:
sendmsg('Error: something went wrong with challonge :/')
def setUp(self):
challonge.set_credentials(username, api_key)
self.t_name = _get_random_name()
self.t = challonge.tournaments.create(
self.t_name,
self.t_name,
accept_attachments=True)
self.ps = challonge.participants.bulk_add(
self.t['id'],
[_get_random_name(), _get_random_name()])
challonge.tournaments.start(self.t['id'])
self.match = challonge.matches.index(self.t['id'])[0]
def setUp(self):
challonge.set_credentials(username, api_key)
self.t_name = _get_random_name()
self.t = challonge.tournaments.create(
self.t_name,
self.t_name,
accept_attachments=True)
self.ps = challonge.participants.bulk_add(
self.t['id'],
[_get_random_name(), _get_random_name()])
challonge.tournaments.start(self.t['id'])
self.match = challonge.matches.index(self.t['id'])[0]
def start_compo(request, competition_id):
competition = get_object_or_404(Competition, pk=competition_id)
if competition.status == 1:
try:
names = []
teams, users = competition.get_participants()
if competition.use_teams:
for team in teams:
names.append(team.title)
else:
for user in users:
names.append(user.username)
if len(names) < 2:
messages.error(request, 'Too few participants')
return redirect(competition)
if competition.tournament_format is None:
messages.error(request, 'Set competition tournament format before using this feature')
return redirect(competition)
if settings.CHALLONGE_INTEGRATION_ENABELED and settings.CHALLONGE_API_USERNAME != '' and \
settings.CHALLONGE_API_KEY != '':
challonge.set_credentials(settings.CHALLONGE_API_USERNAME, settings.CHALLONGE_API_KEY)
url = unicode(competition.lan) + unicode(competition.activity) + unicode(int(time.time()))
url = re.sub('[^0-9a-zA-Z]+', '', url)
challonge.tournaments.create(competition.activity.title, url,
tournament_type=competition.tournament_format)
challonge.participants.bulk_add(url, names)
challonge.tournaments.start(url)
cparticipants = challonge.participants.index(url)
for part in cparticipants:
if not competition.use_teams:
par = Participant.objects.get(user__username=part['name'], competition=competition)
else:
par = Participant.objects.get(team__title=part['name'], competition=competition)
par.cid = part['id']
par.save()
competition.challonge_url = url
update_match_list(request, competition)
competition.status = 3
competition.save()
messages.success(request, 'Tournament has started!')
except Exception:
messages.error(request, 'Something went wrong')
return redirect(competition)
def setUp(self):
password = generate_password_hash('password')
test_user = User('testuser', password, '*****@*****.**',
'matchuptesting', challonge_api_key)
self.test_user = test_user
db.drop_all()
db.create_all()
db.session.add(self.test_user)
db.session.commit()
valid_credentials = base64.b64encode(b'testuser:password').decode(
'utf-8')
response = self.client.post(
LOGIN_URL, headers={'Authorization': 'Basic ' + valid_credentials})
returned = json.loads(response.data)
self.tk_valid_user = returned['token']
self.headers = {
'Content-Type': 'application/json',
'x-access-token': self.tk_valid_user
}
challonge.set_credentials(
self.test_user.challonge_username,
xor_crypt_string(self.test_user.api_key, decode=True))
challonge.tournaments.reset(bracket_1_id)
challonge.tournaments.start(bracket_1_id)
event_data = {
'event_name':
'Test Event',
'brackets': [{
'bracket_id': bracket_1_id,
'number_of_setups': 0
}, {
'bracket_id': bracket_2_id,
'number_of_setups': 0
}]
}
response = self.client.post(EVENT_URL,
json=event_data,
headers=self.headers)
self.event = Event.query.get(json.loads(response.data)['id'])
self.matches_available_bracket_1 = challonge.matches.index(
bracket_1_id, state='open')
self.match_to_test = self.matches_available_bracket_1[0]
def set_challonge_credentials_from_config(config_filename):
"""Sets up your Challonge API credentials from info in a config file.
Args:
config_filename: The filename of the config file to read your credentials
from.
Returns:
True if the credentials were set successfully, False otherwise.
"""
credentials = safe_parse_challonge_credentials_from_config(config_filename)
if not credentials:
return False
challonge.set_credentials(credentials["user"], credentials["api_key"])
return True
def main():
if len(sys.argv) < 2:
print("\n\tUsage:\tpython load_tourney tourney1 tourney2 ...")
return
user = '******'
key = 'WVcRiQ7UCjMd5JxyGpzXKk7M36KNot2cALXitGSj'
challonge.set_credentials(user, key)
for t in sys.argv[1:]:
p = challonge.participants.index(t)
matches = challonge.matches.index(t)
for m in matches:
print(clean(find_player(p, m['winner-id'])['name']) + '\t<def>\t' +
clean(find_player(p, m['loser-id'])['name']))
async def challonge_background_task(self):
# this background task is for showing updates from your tournament
await self.bot.wait_until_ready()
challonge.set_credentials("InkxtheSquid", self.bot.challongekey)
challongeurls = load_challonge_urls()
channel = discord.utils.get(self.bot.get_all_channels(), name='tournyupdates')
server = channel.server # I hope this works
while not self.bot.is_closed:
url = challongeurls[server.id]["url"]
tournament = challonge.tournaments.show(url)
participants = challonge.participants.index(tournament["id"])
number = len(participants)
name = (tournament["name"])
signup = (tournament["sign-up-url"])
await self.bot.send_message(channel, "**{1}** \n teams/players participating in this tournament: {0} \n signup link: {2}".format(number, name, signup))
await asyncio.sleep(1800) #runs every 30 mins
def tournament_details(request, id):
updated_at = datetime.datetime.now()
try:
# Tell pychallonge about your [CHALLONGE! API credentials](http://api.challonge.com/v1).
challonge.set_credentials("moomoomamoo", "ZGhkIWPh05JyAhwmQI1S8BqYBD7DieZsaKPePIYo")
tournament_data = challonge.tournaments.show(id)
sync = True
except:
# couldn't sync to challonge
sync = False
try:
tournament = ChallongeTournament.objects.get(url=id)
if sync == True and tournament.updated_at < parser.parse(tournament_data["updated-at"]):#,"YYYY-MM-DDThh:mm:ssTZD"):
tournament.name=tournament_data["name"]
tournament.updated_at = updated_at
tournament.save()
if tournament_update_data(updated_at):
upToDate = True
else:
upToDate = False
except ChallongeTournament.DoesNotExist:
#should just 404
moo="moo"
playerSyncs = PlayerSync.objects.filter(tournament=tournament).order_by("final_ranking")
if request.method == 'POST':
PlayerSyncFormSet = formset_factory(PlayerSyncForm, extra = playerSyncs.count())
playerSyncFormSet = PlayerSyncFormSet(request.POST, request.FILES)
if playerSyncFormSet.is_valid():
for (p, form) in zip(playerSyncs, playerSyncFormSet):
try:
p.player = form.cleaned_data['playerChoice']
p.save()
except KeyError:
p.player = None
p.save()
p.form = form
tournament_update_data(updated_at)
else:
PlayerSyncFormSet = formset_factory(PlayerSyncForm, extra = playerSyncs.count())
playerSyncFormSet = PlayerSyncFormSet()
for (p, form) in zip(playerSyncs, playerSyncFormSet):
form.fields["playerChoice"].initial = p.player
p.form = form
matches = PlayerMatch.objects.filter(tournament=tournament).order_by("created_at")
return render(request, 'main/tournament_details.html', {'tournament': tournament, 'playerSyncs': playerSyncs, 'management_form': playerSyncFormSet.management_form})
def getTournamentCSV(user, key, subdomain, bracket_id):
challonge.set_credentials(user, key)
tournament = challonge.tournaments.show(subdomain + "-" +
bracket_id) # Tournament link
tour_date = tournament["name"].split('(')[1].replace("/", "-")[:4]
participants = challonge.participants.index(tournament["id"])
players = convertToPlayers(participants)
matches = challonge.matches.index(tournament["id"])
winners = fillInPlayers(matches, players)
# Export data into a .csv file
writeCSV(players, winners)
return tour_date
def challonge_add_users():
username = "******"
api_key = "VeiRWinHgxU3W77ZV2q2L70uTI0BnhNnq68iu8Oo"
challonge.set_credentials(username, api_key)
tournament = challonge.tournaments.show("ufy5bx0r")
tournament_id = tournament["id"]
tournament_name = tournament["name"]
pilots_users = CustomUser.objects.filter(user_role=CustomUser.PILOT)
for user in pilots_users:
try:
challonge.participants.create(tournament_id, user.full_name)
except Exception as e:
print(type(e), e)
continue
def fetch_brackets_to_file(challonge_ids, outfile):
if config.CHALLONGE_USER == None or config.CHALLONGE_API_KEY == None:
raise Exception("Put your challonge username and api key in config.py")
all_matches = []
all_participants = []
challonge.set_credentials(config.CHALLONGE_USER, config.CHALLONGE_API_KEY)
for cid in challonge_ids:
tournament = challonge.tournaments.show(cid)
matches = challonge.matches.index(cid)
participants = challonge.participants.index(cid)
# add some metadata to each challonge match
for match in matches:
if match['completed-at'] == None:
print("WARNING: match %s hasn't been completed; omitting it" %
match['id'])
match['num_games'] = 0
continue
# TODO: could do some smarter parsing here but oh well, DQ's can be
# ignored anyway
if len(match['scores-csv'].split('-')) > 2:
match['num_games'] = 0
continue
scores = list(map(int, match['scores-csv'].split('-')))
match['player1_score'] = scores[0]
match['player2_score'] = scores[1]
match['num_games'] = scores[0] + scores[1]
all_matches.extend([m for m in matches if m['num_games'] > 0])
all_participants.extend(
[p for p in participants if p not in all_participants])
all_data = {'matches': all_matches, 'participants': all_participants}
with open(outfile, 'wb') as fp:
#json.dump(all_data, fp, indent=2, sort_keys=True, default=str)
pickle.dump(all_data, fp)
print(
"Finished fetching challonge data; %s matches and %s participants written to %s"
% (len(all_matches), len(all_participants), outfile))
def update_match_list(request, competition):
if settings.CHALLONGE_INTEGRATION_ENABELED and settings.CHALLONGE_API_USERNAME != '' and \
settings.CHALLONGE_API_KEY != '':
challonge.set_credentials(settings.CHALLONGE_API_USERNAME, settings.CHALLONGE_API_KEY)
c_open_matches = challonge.matches.index(competition.challonge_url)
competition_matches = Match.objects.filter(competition=competition)
for copen in c_open_matches:
if competition_matches:
open_match = Match.objects.get(matchid=str(copen['id']), competition=competition)
else:
open_match = Match(matchid=str(copen['id']), competition=competition)
if open_match.state != 'error':
open_match.state = copen['state']
if copen['player1_id']:
open_match.player1 = Participant.objects.get(competition=competition, cid=copen['player1_id'])
if copen['player2_id']:
open_match.player2 = Participant.objects.get(competition=competition, cid=copen['player2_id'])
open_match.save()
return Match.objects.filter(competition=competition, state='open')
def update_match_list(request, competition):
if settings.CHALLONGE_INTEGRATION_ENABLED and settings.CHALLONGE_API_USERNAME != '' and \
settings.CHALLONGE_API_KEY != '':
challonge.set_credentials(settings.CHALLONGE_API_USERNAME, settings.CHALLONGE_API_KEY)
c_open_matches = challonge.matches.index(competition.challonge_url)
competition_matches = Match.objects.filter(competition=competition)
for copen in c_open_matches:
if competition_matches:
open_match = Match.objects.get(matchid=str(copen['id']), competition=competition)
else:
open_match = Match(matchid=str(copen['id']), competition=competition)
if open_match.state != 'error':
open_match.state = copen['state']
if copen['player1_id']:
open_match.player1 = Participant.objects.get(competition=competition, cid=copen['player1_id'])
if copen['player2_id']:
open_match.player2 = Participant.objects.get(competition=competition, cid=copen['player2_id'])
open_match.save()
return Match.objects.filter(competition=competition, state='open')
def old_matchups_from_str(username: str, api_key: str, tournaments: str):
challonge.set_credentials(username, api_key)
old_matches = set() #set of tuples of (players set, date string)
#print(type(old_matches))
#for line in tournaments.split('\n'):
for line in tournaments.split(','):
url = line.strip()
if url == "":
continue
#get the query for challonge API from the user's provided urls
subdomain = url[url.find("//")+2:url.find(".")]
tourney_name = url[url.rfind("/")+1:]
if subdomain == "challonge":
query = tourney_name
else:
query = subdomain + "-" + tourney_name
tmp_tournament = challonge.tournaments.show(query)
match_date = tmp_tournament['started_at'].strftime("%b %d, %Y")
participants = challonge.participants.index(query)
matches = challonge.matches.index(query)
#create a map of player_id->name since the matches structure below identifies players by their id, not name.
player_ids = {}
for participant in participants:
name = participant['name']
player_id = participant['id']
player_ids[player_id] = normalize(name)
for match in matches:
#print(match)
#old_matches.add((frozenset([player_ids[match['player1_id']], player_ids[match['player2_id']]]), match['started_at'].strftime("%b %d, %Y")))
player_one = normalize(player_ids[match['player1_id']])
player_two = normalize(player_ids[match['player2_id']])
if player_two < player_one:
player_one, player_two = player_two, player_one
old_matches.add((frozenset([player_one, player_two]), match_date))
return old_matches
def form_valid(self, form):
obj = form.save(commit=False)
obj.author = self.request.user
name = obj.name if len(obj.name) < 8 else (obj.name*2)[:8]
url = hashlib.md5(name.encode('utf-8')).hexdigest()[:8]
obj.url = "".join([random.choice(c) for c in url])
username = "******"
api_key = "VeiRWinHgxU3W77ZV2q2L70uTI0BnhNnq68iu8Oo"
challonge.set_credentials(username, api_key)
tournament = challonge.tournaments.create(obj.name, obj.url) #{"started-at": obj.date})
tournament_id = tournament["id"]
obj.id = tournament_id
obj.save()
return super().form_valid(form)
def gen_standings(username: str, api_key: str, tournaments: str):
challonge.set_credentials(username, api_key)
tournament_results = []
(tournament_urls, tournament_queries,
tournament_names) = normalize_urls(tournaments)
for query in tournament_queries:
participants = challonge.participants.index(query)
results = {}
for participant in participants:
name = participant['name']
rank = participant['final_rank']
results[normalize(name)] = rank
tournament_results.append(results)
players = set()
for t in tournament_results:
players.update(t.keys())
players = sorted(players)
return (players, tournament_results, tournament_urls, tournament_names)
def main():
#set credentials and the tournament information.
challonge.set_credentials("eliasingea", "LTQX768N8omoYw2aaRYTn6EyP6yVztkaRjd7TBkQ")
#show the specific tournament that we would like to get information from
tournament = challonge.tournaments.show("qt98yh8i")
tournamentId = tournament["id"]
#get the information for all the games for the tournament.
games = challonge.matches.index(tournamentId)
#get information for all the participants.
participants = challonge.participants.index(tournament["id"])
print tournament["id"]
print tournament["state"]
file = open("streamedGames.txt", "w")
#There are the identifiers for the games that will be streamed.
streamedGames = ['B', 'O', 'G', 'T', 'K', 'W', 'M']
#This is the call to the function that will give us the names
#for the next open game to be streamed.
playerNameOne, playerNameTwo = getPlayers(games, streamedGames, tournamentId)
#writes the names to a textfile named streamedGames.txt
file.write(playerNameOne)
file.write("\n")
file.write(playerNameTwo)
def setUp(self):
challonge.set_credentials(username, api_key)
self.random_name = _get_random_name()
self.t = challonge.tournaments.create(self.random_name, self.random_name)
def test_call(self):
challonge.set_credentials(username, api_key)
self.assertNotEqual(challonge.fetch("GET", "tournaments"), '')
def test_set_credentials(self):
challonge.set_credentials(username, api_key)
self.assertEqual(api._credentials["user"], username)
self.assertEqual(api._credentials["api_key"], api_key)
import challonge, json
from django.conf import settings
from urllib2 import HTTPError
from celery import task
from threading import Timer
# this is here because it's a global that the challonge tasks require
challonge.set_credentials(settings.CHALLONGE_USERNAME, settings.CHALLONGE_API_KEY)
@task()
def create_tournament(name, url, tournament_type):
try:
challonge.tournaments.create(name=name, url=url, tournament_type=tournament_type)
except Exception, e:
print e
@task()
def delete_tournament(tournament):
challonge.tournaments.destroy(tournament=tournament)
@task()
def create_participant(tournament, team):
challonge.participants.create(tournament=tournament.slugified_name, name=team.name)
@task()
def destroy_participant(tournament, team):
try:
for p in challonge.participants.index(tournament=tournament.slugified_name):
if p['name'] == team.name:
challonge.participants.destroy(tournament=tournament.slugified_name, participant_id=p['id'])
except HTTPError, err:
import challonge
import json
import pprint
# Tell pychallonge about your [CHALLONGE! API credentials](http://api.challonge.com/v1).
challonge.set_credentials("JVSalazar", "q3KO6htJ1v8Rr8f8Mwm5ZIZmJ48CqKC1GzwDUQM8")
# Retrieve a tournament by its id (or its url).
tournament = challonge.tournaments.show('ceogaming-2015_melee_final')
# Tournaments, matches, and participants are all represented as normal Python dicts.
print(tournament["id"]) # 3272
print(tournament["name"]) # My Awesome Tournament
print(tournament["started-at"]) # None
# Retrieve the participants for a given tournament.
participants = challonge.participants.index(tournament["id"])
participantNames = []
# for name in range (0, 31):
# participantNames.append(participants[name]["display-name"])
# print(participantNames[name])
for participant in participants:
print(participant["display-name"])
# # Start the tournament and retrieve the updated information to see the effects
# # of the change.
# challonge.tournaments.start(tournament["id"])
# tournament = challonge.tournaments.show(tournament["id"])
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#-------------------------------------------------------------------------------
import logging
from PySide import QtCore, QtNetwork
from PySide.QtSql import *
from . import tournamentServerThread
from passwords import CHALLONGE_KEY, CHALLONGE_USER
import challonge
challonge.set_credentials(CHALLONGE_USER, CHALLONGE_KEY)
class tournamentServer(QtNetwork.QTcpServer):
def __init__(self, parent=None):
super(tournamentServer, self).__init__(parent)
self.logger = logging.getLogger(__name__)
self.parent = parent
self.threads = []
self.updaters = []
self.db = self.parent.db
self.tournaments = {}
self.importTournaments()
tournament_ids = get_all_tournaments([
'http://{}.challonge.com/'.format(config.subdomain),
# 'http://challonge.com/users/' + config.subdomain
])
tournament_ids.append('idnlvvlz')
cached_tournaments = set()
if not os.path.exists(CACHE):
os.makedirs(CACHE)
else:
cached_tournaments = set(os.listdir(CACHE))
challonge.set_credentials(config.user, config.api_key)
players = {}
tournaments = {}
for tournament_id in tournament_ids:
if tournament_id not in cached_tournaments:
if args.verbose:
print tournament_id + ': Getting matches'
matches = challonge.matches.index(tournament_id)
participants = challonge.participants.index(tournament_id)
with open(os.path.join(CACHE, tournament_id), 'w') as f:
json.dump({'matches': matches, 'participants': participants}, f, default=json_serial)
else:
import challonge
from operator import itemgetter, attrgetter, methodcaller
# Tell pychallonge about your [CHALLONGE! API credentials](http://api.challonge.com/v1).
challonge.set_credentials("Timepilotchkn", "dYDXkiKtJQMBekM6RQntuesUGWwc3nTlslME5FLv")
# Retrieve a tournament by its id (or its url).
tournament = challonge.tournaments.show("FBGT14")
# Tournaments, matches, and participants are all represented as normal Python dicts.
print(tournament["id"]) # 3272
print(tournament["name"]) # My Awesome Tournament
print(tournament["started-at"]) # None
# Retrieve the participants for a given tournament.
participantsData = challonge.participants.index(tournament["id"])
matchData = challonge.matches.index(tournament["id"])
#print(matchData[0])
#---------------------------------------------------------- Player Class
class Player:
def __init__(self, tagData, playerID, placing):
self.tag = tagData
self.ids = [playerID]
self.place = placing
if placing == 32:
self.points = 400
elif placing == 33:
self.points = 0
def test_set_credentials(self):
challonge.set_credentials(username, api_key)
self.assertEqual(challonge.api._credentials['user'], username)
self.assertEqual(challonge.api._credentials['api_key'], api_key)
def __init__(self,
challonge_tournament_name,
api_token='xoxb-15050499792-qRGSf7w5Qv0Eitp7XMoC8w39',
slack_username="******",
slack_icon_url='http://i.imgur.com/GlnLNWg.jpg',
challonge_api_key='ubxCn7J3myaGWsYLeFliIIFD53HhUJQZdgUOlEvY',
challonge_username='******',
develop=False,
no_websocket=False):
self.logger = logging.getLogger('foosbotson.FoosBotson')
self.develop = develop
self.slack = Slacker(api_token)
self.slack_default_username = slack_username
self.slack_default_icon_url = slack_icon_url
self.nick_slack_id = 'U0EFNV9SN'
self.challonge_tournament_name = challonge_tournament_name
self.tournament_name = 'amadeus-%s' % challonge_tournament_name
self.logger.info("Connecting to tournament with id %s" % self.tournament_name)
challonge.set_credentials(challonge_username, challonge_api_key)
self.tournament = challonge.tournaments.show(self.tournament_name)
self.participants = challonge.participants.index(self.tournament_name)
self.matches = challonge.matches.index(self.tournament_name)
# The stage must be started manually - so annoy myself here until I do it
reminders = 0
while reminders < 5 and not self.find_group_stage_ids():
self.logger.debug('Sleeping for 30 seconds while waiting for id map')
self.post_direct_message("(Reminder %i of 5) Start the Group Stage Dumb Dumb :foosball: :snoop:" %
reminders)
reminders += 1
time.sleep(30)
if not no_websocket:
self.menu_options = {
'help': {
'help_text': 'Display help menu',
'detailed_help_text': 'Usage: help [option]\nGet help with a specific menu option',
'callable': self.menu_help_text,
},
'gloat': {
'help_text': 'Gloat about a non-tournament game',
'detailed_help_text': 'Gloat about a non-tournament game',
'callable': self.menu_gloat,
},
'change_name': {
'help_text': 'Change the name of your team in a tournament',
'detailed_help_text': 'Change the name of your team in a tournament',
'callable': self.menu_help_text,
},
'generate_teams': {
'help_text': 'Generate Teams for a tournament',
'detailed_help_text': 'Generate teams for a tournament',
'callable': self.menu_help_text,
}
}
# Start the real time messaging
import websocket
r = self.slack.rtm.start()
self.websocket_url = r.body["url"]
self.logger.info("Websocket URL: %s" % self.websocket_url)
websocket.enableTrace(True)
ws = websocket.WebSocketApp(self.websocket_url,
on_message=self.on_message,
on_error=self.on_error,
on_close=self.on_close,
on_open=self.on_open)
ws.run_forever()
def configure():
challonge.set_credentials(api_email, api_key)
import challonge
import elo
from os import environ
username=environ.get("CHALLONGE_USERNAME", "")
api_key=environ.get("CHALLONGE_API_KEY", "")
assert username != "" and api_key != ""
challonge.set_credentials(username, api_key)
# Who the program should print out scores for
topN = ["Lyme", "Bean", "Fest", "Nook", "Couch",
"Meero", "Ai", "Justin", "Succulent"]
class PlayerStats(object):
def __init__(self, rank, player, rating):
self.rank = rank
self.player = player
self.rating = rating
def to_dict(self):
return {'rank': self.rank,
'player': self.player,
'rating': self.rating}
def fetchdemo():
return [PlayerStats(1, "Lyme", 1250),
PlayerStats(2, "Bean", 1100),
PlayerStats(3, "Chump", 1000)]
def fetch():
ratings = dict()
def main():
listPlayers = pickle.load(open("info/players.pickle", "rb"));
listMatches = pickle.load(open("info/matches.pickle", "rb"));
ranking = [];
user = raw_input("Enter your challonge username: "******"uiblis";
api_key = raw_input("Enter your api_key: ");
api_key = "GqEWndsdFiH7JhkIc3l6Ezf8eg3VyxHkACjQN5Pa"
challonge.set_credentials(user, api_key)
print("Welcome to BetterPR!")
while True:
print("");
print("Choose an option: ");
print("1) Input a tournament URL ");
print("2) Add a match ");
print("3) View players ");
print("4) Exit ");
while True:
choice = raw_input();
if (choice == "1"):
url = getURL();
tournament = loadURL(url);
print "";
print "Tournament: " + tournament["name"];
print "Date:",
print tournament["started-at"];
while True:
decision = raw_input("Compile data from this tournament? (y/n) ");
if (decision == "n"):
break;
elif (decision == "y"):
tourneyPlayers = [];
tourneyMatches = [];
compileParticipants(url, tourneyPlayers, listPlayers);
compileMatches(url, tourneyMatches, tourneyPlayers, tournament, listPlayers, listMatches);
listPlayers.sort(key = lambda x: x.rating.mu, reverse = True)
break;
else:
print ("Please enter 'y' or 'n'. ");
break;
if (choice == "2"):
break;
if (choice == "3"):
index = 1;
for player in listPlayers:
player.rank = index;
index += 1;
player.showInfo();
break;
if (choice == "4"):
pickle.dump(listPlayers, open("info/players.pickle", "wb"))
pickle.dump(listMatches, open("info/matches.pickle", "wb"))
exit();
else:
print "Please choose a valid option."