def respond_allocation(self, code=None):
if code is not None:
allocation = find_element_by_id(self.suggested_allocations, code)
else:
allocation = self.allocation
allocation_dict = {}
allocation_dict["algorithm"] = allocation.internal_algorithm
allocation_dict["indices"] = {
"strong_strong_indicator": allocation.strong_strong_indicator
}
allocation_dict["large_warings"] = allocation.large_warnings
allocation_conv = []
for lattice in allocation:
allocation_conv.append({
"teams":
tools.get_ids(lattice.grid.teams),
"warnings": [
w.status for w in lattice.warnings
], #############################################################
"chairs":
[lattice.chair.code], ##############fix in next version
"venue":
lattice.venue.code if lattice.venue is not None else None,
"panels":
tools.get_ids(lattice.panels)
})
allocation_dict["allocation"] = allocation_conv
allocation_dict["code"] = allocation.code
return allocation_dict
def fetch_adjudicator(self, code):
data = {}
adjudicator = tools.find_element_by_id(self.adjudicator_list, code)
data['code'] = adjudicator.code
data['name'] = adjudicator.name
data['reputation'] = adjudicator.reputation
data['judge_test'] = adjudicator.judge_test
data['institutions'] = tools.get_ids(adjudicator.institutions)
data['conflicts'] = tools.get_ids(adjudicator.conflict_teams)
data['url'] = adjudicator.url
data['available'] = not adjudicator.absent
return data
def respond_matchup(self, code=None):
if code is not None:
matchup = find_element_by_id(self.suggested_matchups, code)
else:
matchup = self.matchup
matchup_dict = {}
matchup_dict["algorithm"] = matchup.internal_algorithm
matchup_dict["indices"] = {
"power_pairing_indicator": matchup.power_pairing_indicator,
"adopt_indicator": matchup.adopt_indicator,
"adopt_indicator2": matchup.adopt_indicator2,
"adopt_indicator_sd": matchup.adopt_indicator_sd,
"gini_index": matchup.gini_index,
"scatter_indicator": matchup.scatter_indicator
}
matchup_dict["large_warings"] = matchup.large_warnings
matchup_conv = []
for grid in matchup:
matchup_conv.append({
"teams": tools.get_ids(grid.teams),
"warnings": [w.status for w in grid.warnings]
})
matchup_dict["allocation"] = matchup_conv
matchup_dict["code"] = matchup.code
return matchup_dict
def total_team_results(self):
result_dicts = []
if self.style["team_num"] == 2:
win_text = "wins"
else:
win_text = "win-points"
for team in self.team_list:
result_dict = OrderedDict()
result_dict["name"] = team.name
result_dict["code"] = team.code
result_dict[win_text] = team.sum_wins()
result_dict["sum"] = round(team.sum_scores(), 2)
result_dict["margin"] = round(team.margin, 2)
result_dict["average"] = round(team.average(), 2)
result_dict["sd"] = round(team.sd(), 2)
for i, score in enumerate(
[round_str2float(score, 2) for score in team.scores_sub]):
result_dict["round" + str(i + 1)] = score
result_dicts.append(result_dict)
team_codes = tools.get_ids(self.team_list)
result_dicts.sort(key=lambda d: (d[win_text], d["sum"], d["margin"]),
reverse=True)
f = lambda d1, d2: d1[win_text] != d2[win_text] or d1["sum"] != d2[
"sum"] or d1["margin"] != d2["margin"]
results_dict = insert_ranking(result_dicts, f)
return results_dict
def fetch_team(self, code):
data = {}
team = tools.find_element_by_id(self.team_list, code)
data['code'] = team.code
data['name'] = team.name
data['speakers'] = tools.get_ids(team.debaters)
data['available'] = team.available
data['url'] = team.url
return data
def list_teams(self):
data = []
for code in tools.get_ids(self.team_list):
data.append(self.fetch_team(code))
return data
def list_institutions(self):
data = []
for code in tools.get_ids(self.institution_list):
data.append(self.fetch_institution(code))
return data
def list_debaters(self):
data = []
for code in tools.get_ids(self.debater_list):
data.append(self.fetch_debater(code))
return data
def list_venues(self):
data = []
for code in tools.get_ids(self.venue_list):
data.append(self.fetch_venue(code))
return data
def list_adjudicators(self):
data = []
for code in tools.get_ids(self.adjudicator_list):
data.append(self.fetch_adjudicator(code))
return data