def handle(self, *args, **options):
cur_round = TabSettings.get("cur_round") - 1
print(("Simulating round %s..." % cur_round))
rounds_to_simulate = Round.objects.filter(round_number=cur_round,
victor=Round.NONE)
for round_obj in rounds_to_simulate:
self.__simulate_round(round_obj)
def handle(self, *args, **options):
cur_round = TabSettings.get("cur_round") - 1
print(("Simulating round %s..." % cur_round))
rounds_to_simulate = Round.objects.filter(round_number=cur_round, victor=Round.NONE)
for r in rounds_to_simulate:
print(r)
self.__simulate_round(r)
def count_valid_teams(self):
num_teams, num_valid_teams = 0, 0
num_rounds = TabSettings.get('tot_rounds')
for team in Team.objects.all():
num_teams += 1
num_forfeits = NoShow.objects.filter(no_show_team=team).count()
if num_rounds - num_forfeits >= 3:
num_valid_teams += 1
return num_valid_teams, num_teams
def count_valid_teams(self):
num_teams, num_valid_teams = 0, 0
num_rounds = TabSettings.get('tot_rounds')
for team in Team.objects.all():
num_teams += 1
num_forfeits = NoShow.objects.filter(no_show_team=team).count()
if num_rounds - num_forfeits >= 3:
num_valid_teams += 1
return num_valid_teams, num_teams
def ranks_for_debater(debater, average_ironmen=True):
"""Returns a list of ranks for the provided debater
In most normal rounds the ranks of the debater are the ranks the judge
gave them, but there are some special circumstances.
Forfeits:
If a debater won by forfeit, they get their average ranks
If a debater lost by forfeit, they get ranks of 0
If a debater was Noshow for a round, they get ranks of 0
Iron Mans:
If a debater is an iron man for a round, they get the average of their
ranks for that round
Byes:
If a debater wins in a bye, they get their average ranks
If a debater was late to a lenient round, they get average ranks
"""
team = debater.team()
# We start counting at 1, so when cur_round says 6 that means that we are
# in round 5 and should have 5 ranks
num_ranks = TabSettings.get("cur_round") - 1
debater_roundstats = debater.roundstats_set.all()
debater_ranks = []
ranks_per_round = defaultdict(list)
# We might have multiple roundstats per round if we have iron men, so first
# group by round number
for roundstat in debater_roundstats:
ranks_per_round[roundstat.round.round_number].append(roundstat)
for round_number in range(1, num_ranks + 1):
roundstats = ranks_per_round[round_number]
if roundstats:
ranks = [float(rs.ranks) for rs in roundstats]
avg_ranks = sum(ranks) / float(len(roundstats))
roundstat = roundstats[0]
if won_by_forfeit(roundstat.round, team):
debater_ranks.append(avg_deb_ranks(debater))
elif forfeited_round(roundstat.round, team):
debater_ranks.append(MAXIMUM_DEBATER_RANKS)
else:
if average_ironmen:
debater_ranks.append(avg_ranks)
else:
debater_ranks.extend(ranks)
else:
ranks = debater_abnormal_round_ranks(debater, round_number)
if ranks is not None:
debater_ranks.append(ranks)
debater_ranks = list(map(float, debater_ranks))
return debater_ranks
def backup_round(dst_filename=None, round_number=None, btime=None):
if round_number is None:
round_number = TabSettings.get("cur_round", "no-round-number")
if btime is None:
btime = int(time.time())
print("Trying to backup to backups directory")
if dst_filename is None:
dst_filename = "site_round_%i_%i" % (round_number, btime)
dst_filename = _generate_unique_key(dst_filename)
return LocalDump(dst_filename).backup()
def backup_round(dst_filename=None, round_number=None, btime=None):
if round_number is None:
round_number = TabSettings.get("cur_round")
if btime is None:
btime = int(time.time())
print("Trying to backup to backups directory")
if dst_filename == None:
dst_filename = "site_round_%i_%i" % (round_number, btime)
if backup_exists(dst_filename):
dst_filename += "_%i" % btime
return copy_db(DATABASE_PATH, get_backup_filename(dst_filename))
def backup_round(dst_filename = None, round_number = None, btime = None):
if round_number is None:
round_number = TabSettings.get("cur_round")
if btime is None:
btime = int(time.time())
print("Trying to backup to backups directory")
if dst_filename == None:
dst_filename = "site_round_%i_%i" % (round_number, btime)
if backup_exists(dst_filename):
dst_filename += "_%i" % btime
return copy_db(DATABASE_PATH, get_backup_filename(dst_filename))
def handle(self, *args, **options):
cur_round = TabSettings.get("cur_round") - 1
host = options["host"]
csrf_threads = []
rounds = Round.objects.filter(round_number=cur_round,
victor=Round.NONE)
for round_obj in rounds:
judge = round_obj.chair
csrf_threads.append(
GetCsrfThread(host, judge.ballot_code, round_obj))
num_errors = 0
while csrf_threads:
cur_csrf_threads = []
for _ in range(min(len(csrf_threads), options["connections"])):
cur_csrf_threads.append(csrf_threads.pop())
for thr in cur_csrf_threads:
thr.start()
for thr in cur_csrf_threads:
thr.join()
result_threads = []
for thr in cur_csrf_threads:
num_errors += num_errors
csrf_token, num_errors = thr.result
if csrf_token is None:
print("no csrf token")
result_thread = SubmitResultThread(thr.host, thr.ballot_code,
csrf_token, thr.round_obj)
result_threads.append(result_thread)
for thr in result_threads:
thr.start()
for thr in result_threads:
thr.join()
for thr in result_threads:
num_errors += thr.num_errors
print("Done with one batch! Sleeping!")
time.sleep(2)
print("Done!")
print("Total errors: %s" % num_errors)
def avg_deb_ranks(debater):
""" Computes the average debater ranks for the supplied debater
Generally this consistes of finding all the ranks we have, averaging iron
men ranks, and then dividing by the length.
This does not count forfeit losses or noshow's as 7 because having ranks of
3.5 in the first place is penalty enough, and some tab polices may want
forfeits to count as average ranks.
"""
real_ranks = []
num_ranks = TabSettings.get("cur_round") - 1
debater_roundstats = debater.roundstats_set.all()
team = debater.team()
ranks_per_round = defaultdict(list)
# We might have multiple roundstats per round if we have iron men, so first
# group by round number
for roundstat in debater_roundstats:
ranks_per_round[roundstat.round.round_number].append(roundstat)
for round_number in range(1, num_ranks + 1):
roundstats = ranks_per_round[round_number]
if roundstats:
ranks = [float(rs.ranks) for rs in roundstats]
avg_ranks = sum(ranks) / float(len(roundstats))
roundstat = roundstats[0]
if (won_by_forfeit(roundstat.round, team)
or forfeited_round(roundstat.round, team)):
continue
real_ranks.append(avg_ranks)
if not real_ranks:
return 0
else:
return float(sum(real_ranks)) / float(len(real_ranks))
def handle(self, *args, **options):
backup_dir = options['backup_directory']
path = BACKUP_PREFIX
self.stdout.write(
"Creating directory for current tournament in backup directory")
tournament_dir = os.path.join(backup_dir, str(int(time.time())))
if not os.path.exists(tournament_dir):
os.makedirs(tournament_dir)
if not os.path.exists(path + "/backups"):
os.makedirs(path + "/backups")
self.stdout.write(
"Copying current tournament state to backup tournament directory: %s"
% tournament_dir)
try:
shutil.copy(path + "/pairing_db.sqlite3", tournament_dir)
shutil.rmtree(tournament_dir + "/backups", ignore_errors=True)
shutil.copytree(path + "/backups", tournament_dir + "/backups")
except (IOError, os.error) as why:
self.stdout.write("Failed to backup current tournament state")
print(why)
sys.exit(1)
self.stdout.write("Clearing data from database")
try:
call_command("flush", interactive=False)
except (IOError, os.error) as why:
self.stdout.write("Failed to clear database")
print(why)
sys.exit(1)
self.stdout.write("Creating tab/entry users")
tab = User.objects.create_user("tab", None, options["tab_password"])
tab.is_staff = True
tab.is_admin = True
tab.is_superuser = True
tab.save()
entry = User.objects.create_user("entry", None,
options["entry_password"])
self.stdout.write("Setting default tab settings")
TabSettings.set("tot_rounds", 5)
TabSettings.set("lenient_late", 0)
TabSettings.set("cur_round", 1)
self.stdout.write("Cleaning up old backups")
try:
shutil.rmtree(path + "/backups")
os.makedirs(path + "/backups")
except (IOError, os.error) as why:
self.stdout.write(
"Failed to copy clean database to pairing_db.sqlite3")
print(why)
sys.exit(1)
self.stdout.write(
"Done setting up tournament, after backing up old one. New tournament information:"
)
self.stdout.write(
"%s | %s" % ("Username".ljust(10, " "), "Password".ljust(10, " ")))
self.stdout.write(
"%s | %s" %
("tab".ljust(10, " "), options['tab_password'].ljust(10, " ")))
self.stdout.write(
"%s | %s" %
("entry".ljust(10, " "), options['entry_password'].ljust(10, " ")))
def handle(self, *args, **options):
if len(args) != 1:
self.print_help('./manage.py', 'initialize_tourney')
raise CommandError('Please supply valid arguments')
backup_dir = args[0]
path = BACKUP_PREFIX
for user in ['tab', 'entry']:
option_name = '%s_password' % user
if options[option_name] is None or options[option_name].strip(
) == '':
self.stdout.write(
"No password provided for %s, generating password" % user)
options[option_name] = User.objects.make_random_password(
length=8)
self.stdout.write("Proceeding to tournament creation")
self.stdout.write(
"Creating directory for current tournament in backup directory")
tournament_dir = os.path.join(backup_dir, str(int(time.time())))
if not os.path.exists(tournament_dir):
os.makedirs(tournament_dir)
if not os.path.exists(path + "/backups"):
os.makedirs(path + "/backups")
self.stdout.write(
"Copying current tournament state to backup tournament directory: %s"
% tournament_dir)
try:
shutil.copy(path + "/pairing_db.sqlite3", tournament_dir)
shutil.rmtree(tournament_dir + "/backups", ignore_errors=True)
shutil.copytree(path + "/backups", tournament_dir + "/backups")
except (IOError, os.error) as why:
self.stdout.write("Failed to backup current tournament state")
print(why)
sys.exit(1)
self.stdout.write("Clearing data from database")
try:
call_command("flush", interactive=False)
except (IOError, os.error) as why:
self.stdout.write("Failed to clear database")
print(why)
sys.exit(1)
self.stdout.write("Creating tab/entry users")
tab = User.objects.create_user("tab", None, options["tab_password"])
tab.is_staff = True
tab.is_admin = True
tab.is_superuser = True
tab.save()
entry = User.objects.create_user("entry", None,
options["entry_password"])
self.stdout.write("Setting default tab settings")
TabSettings.set("tot_rounds", 5)
TabSettings.set("lenient_late", 0)
TabSettings.set("cur_round", 1)
self.stdout.write("Cleaning up old backups")
try:
shutil.rmtree(path + "/backups")
os.makedirs(path + "/backups")
except (IOError, os.error) as why:
self.stdout.write(
"Failed to copy clean database to pairing_db.sqlite3")
print why
sys.exit(1)
self.stdout.write(
"Done setting up tournament, after backing up old one. New tournament information:"
)
self.stdout.write(
"%s | %s" % ("Username".ljust(10, " "), "Password".ljust(10, " ")))
self.stdout.write(
"%s | %s" %
("tab".ljust(10, " "), options['tab_password'].ljust(10, " ")))
self.stdout.write(
"%s | %s" %
("entry".ljust(10, " "), options['entry_password'].ljust(10, " ")))
def speaks_for_debater(debater, average_ironmen=True):
"""Returns a list of speaks for the provided debater
In most normal rounds the speaks of the debater are the speaks the judge
gave them, but there are some special circumstances.
Forfeits:
If a debater won by forfeit, they get their average speaks
If a debater lost by forfeit, they get speaks of 0
If a debater was Noshow for a round, they get speaks of 0
Iron Mans:
If a debater is an iron man for a round, they get the average of their
speaks for that round
Byes:
If a debater wins in a bye, they get their average speaks
If a debater was late to a lenient round, they get average speaks
"""
team = debater.team()
# We start counting at 1, so when cur_round says 6 that means that we are
# in round 5 and should have 5 speaks
num_speaks = TabSettings.get("cur_round") - 1
debater_roundstats = debater.roundstats_set.all()
debater_speaks = []
speaks_per_round = defaultdict(list)
# We might have multiple roundstats per round if we have iron men, so first
# group by round number
for roundstat in debater_roundstats:
speaks_per_round[roundstat.round.round_number].append(roundstat)
for round_number in range(1, num_speaks + 1):
roundstats = speaks_per_round[round_number]
if roundstats:
# This is so if in the odd chance we get a debater paired in
# twice we take the speaks they actually got
roundstats.sort(key=lambda rs: rs.speaks, reverse=True)
roundstat = roundstats[0]
if not len(set(rs.round for rs in roundstats)) == 1:
roundstats = roundstats[:1]
speaks = [float(rs.speaks) for rs in roundstats]
avg_speaks = sum(speaks) / float(len(roundstats))
if won_by_forfeit(roundstat.round, team):
debater_speaks.append(avg_deb_speaks(debater))
elif forfeited_round(roundstat.round, team):
debater_speaks.append(MINIMUM_DEBATER_SPEAKS)
else:
if average_ironmen:
debater_speaks.append(avg_speaks)
else:
debater_speaks.extend(speaks)
else:
speaks = debater_abnormal_round_speaks(debater, round_number)
if speaks is not None:
debater_speaks.append(speaks)
debater_speaks = list(map(float, debater_speaks))
return debater_speaks