class TeamModelTestCase(TestCase):
def setUp(self):
self.tournament = Tournament()
self.tournament.save()
self.group = Group(letter='A')
self.group.tournament_id = self.tournament.id
self.group.save()
self.team = Team(name='Brazil')
self.team.group_id = self.group.id
def test_model_can_create_team(self):
old_count = Team.objects.count()
self.team.save()
new_count = Team.objects.count()
created_team = Team.objects.last()
self.assertNotEqual(old_count, new_count)
self.assertEquals(self.team.name, created_team.name)
self.assertEquals(self.team.points, created_team.points)
self.assertEquals(self.team.goals, created_team.goals)
self.assertEquals(self.team.position, created_team.position)
self.assertEquals(self.team.group.letter, self.group.letter)
self.assertEquals(self.team, self.group.teams.get())
def test_model_cannot_create_team_without_name(self):
team_without_name = Team()
with self.assertRaises(IntegrityError):
team_without_name.save()
def test_model_cannot_create_team_without_group(self):
team_without_group = Team(name='Japan')
with self.assertRaises(IntegrityError):
team_without_group.save()
class BaseDebateTestCase(TestCase):
"""Currently used in availability and participants tests as a pseudo fixture
to create teh basic data to simulate simple tournament functions"""
def setUp(self):
super(BaseDebateTestCase, self).setUp()
# add test models
self.t = Tournament(slug="tournament")
self.t.save()
for i in range(4):
ins = Institution(code="INS%s"%i, name="Institution %s"%i)
ins.save()
for j in range(3):
team = Team(tournament=self.t, institution=ins, reference="Team%s%s" % (i,j))
team.save()
for k in range(2):
speaker = Speaker(team=team, name="Speaker%s%s%s" % (i,j,k))
speaker.save()
for j in range(2):
adj = Adjudicator(tournament=self.t, institution=ins, name="Adjudicator%s%s" %
(i,j), test_score=0)
adj.save()
for i in range(8):
venue = Venue(name="Venue %s" % i)
venue.priority = i
venue.save()
venue = Venue(name="IVenue %s" % i)
venue.priority = i
venue.save()
def import_tournament(self):
self.tournament = Tournament(name=self.root.get('name'))
if self.root.get('short') is not None:
self.tournament.short_name = self.root.get('short')
self.tournament.slug = slugify(self.root.get('short'))
else:
self.tournament.short_name = self.root.get('name')[:25]
self.tournament.slug = slugify(self.root.get('name')[:50])
self.tournament.save()
self.is_bp = self.root.get('style') == 'bp' or len(
self.root.findall('round/debate[1]/side')) == 4
# Import all the separate parts
self.set_preferences()
self.import_institutions()
self.import_categories()
self.import_venues()
self.import_questions()
self.import_teams()
self.import_speakers()
self.import_adjudicators()
self.import_debates()
self.import_motions()
self.import_results()
self.import_feedback()
def test_saving_and_retrieving_teams(self):
tournament_ = Tournament()
tournament_.save()
first_team = Team()
first_team.name = 'Team 1'
first_team.tournament = tournament_
first_team.save()
second_team = Team()
second_team.name = 'Team 2'
second_team.tournament = tournament_
second_team.save()
saved_tournament = Tournament.objects.first()
self.assertEqual(saved_tournament, tournament_)
saved_teams = Team.objects.all()
self.assertEqual(saved_teams.count(), 2)
first_saved_team = saved_teams[0]
second_saved_team = saved_teams[1]
self.assertEqual(first_saved_team.name, 'Team 1')
self.assertEqual(first_saved_team.tournament, tournament_)
self.assertEqual(second_saved_team.name, 'Team 2')
self.assertEqual(second_saved_team.tournament, tournament_)
def usage_feature(d: int) -> Iterator[Tuple[str, List[float]]]:
"""Computes usage difference between day d and each of the previous 6 days (features 14-19).
Usage is defined as the ratio between the number of times it appears in every deck and the total of cards
that appears in every deck.
Simple stats: only about 1000 different cards are played in tournaments
"""
card_id_to_usages = defaultdict(list)
# Gets all cards that have been played for two weeks.
all_cards = set(
Tournament.get_played_cards(date.today() - timedelta(days=d),
date.today() - timedelta(days=d + 13)))
for i in range(7):
played_cards = Tournament.get_played_cards(
date.today() - timedelta(days=d + i),
date.today() - timedelta(days=d + i + 6))
total = sum(played_cards.values())
for card_name in all_cards:
usage = played_cards.get(card_name, 0) / total
for card in Card.objects.filter(name=card_name):
card_id_to_usages[card.id].append(usage)
for card_id, usages in card_id_to_usages.items():
if len(usages) > 1:
yield card_id, [usages[0] - usage for usage in usages[1:]]
else:
yield card_id, usages
class GroupModelTestCase(TestCase):
def setUp(self):
self.letter = 'A'
self.tournament = Tournament()
self.tournament.save()
self.group = Group(letter=self.letter)
self.group.tournament_id = self.tournament.id
def test_model_can_create_group(self):
old_count = Group.objects.count()
self.group.save()
new_count = Group.objects.count()
created_group = Group.objects.last()
self.assertNotEquals(old_count, new_count)
self.assertEquals(created_group.letter, self.letter)
def test_model_cannot_create_group_without_letter(self):
group_without_letter = Group()
with self.assertRaises(NameError):
group_without_letter.save()
def test_model_cannot_create_group_without_tournament(self):
self.group.tournament_id = None
with self.assertRaises(IntegrityError):
self.group.save()
def test_model_cannot_create_group_with_wrong_letter(self):
self.group.letter = 'F'
with self.assertRaises(NameError):
self.group.save('Wrong group letter name')
def setUp(self):
self.tournament = Tournament()
self.tournament.save()
self.group = Group(letter='A')
self.group.tournament_id = self.tournament.id
self.group.save()
self.team = Team(name='Brazil')
self.team.group_id = self.group.id
class MatchModelTestCase(TestCase):
def setUp(self):
self.phase = Tournament.FIRST_PHASE
self.group_letter = 'A'
self.team_a_name = 'Brazil'
self.team_b_name = 'Germany'
self.tournament = Tournament(phase=self.phase)
self.tournament.save()
self.group = Group(letter=self.group_letter)
self.group.tournament_id = self.tournament.id
self.group.save()
self.team_a_goals = random.randint(0, 10)
self.team_b_goals = random.randint(0, 10)
self.team_a = Team(name=self.team_a_name)
self.team_b = Team(name=self.team_b_name)
self.team_a.group_id = self.group.id
self.team_b.group_id = self.group.id
self.team_a.save()
self.team_b.save()
def test_model_can_create_match(self):
old_count = Match.objects.count()
match = Match(away_team=self.team_a,
home_team=self.team_b,
away_team_goals=self.team_a_goals,
home_team_goals=self.team_b_goals,
tournament=self.tournament,
phase=self.tournament.phase)
match.save()
new_count = Match.objects.count()
created_match = Match.objects.last()
self.assertNotEquals(old_count, new_count)
self.assertEquals(created_match.phase, self.tournament.phase)
self.assertEquals(created_match.away_team.id, self.team_a.id)
self.assertEquals(created_match.away_team_goals, self.team_a_goals)
self.assertEquals(created_match.home_team.id, self.team_b.id)
self.assertEquals(created_match.home_team_goals, self.team_b_goals)
self.assertFalse(created_match.played)
self.assertIsNone(created_match.winner)
def test_model_cannot_create_match_without_teams(self):
match_without_teams = Match()
with self.assertRaises(IntegrityError):
match_without_teams.save()
def test_model_can_create_match_without_input_goals(self):
expected_amount_goals = 0
match_without_goals = Match(away_team=self.team_a,
home_team=self.team_b,
tournament=self.tournament,
phase=self.tournament.phase)
match_without_goals.save()
created_match = Match.objects.last()
self.assertEquals(created_match.away_team_goals, expected_amount_goals)
self.assertEquals(created_match.away_team_goals, expected_amount_goals)
self.assertEquals(created_match.phase, self.phase)
def create_tournament(self, slug, name, short_name):
"""Creates, saves and returns a tournament with the given slug.
Raises exception on error."""
try:
existing = Tournament.objects.get(slug=slug)
except Tournament.DoesNotExist:
self._print_stage("Creating tournament %r" % slug)
t = Tournament(name=name, short_name=short_name, slug=slug)
t.save()
return t
else:
self._warning("Tournament %r already exists, not creating" % slug)
return existing
def create_tournament(self, slug, name, short_name):
"""Creates, saves and returns a tournament with the given slug.
Raises exception on error."""
try:
existing = Tournament.objects.get(slug=slug)
except Tournament.DoesNotExist:
self._print_stage("Creating tournament %r" % slug)
t = Tournament(name=name, short_name=short_name, slug=slug)
t.save()
return t
else:
self._warning("Tournament %r already exists, not creating" % slug)
return existing
def perform(self):
last_tournament = Tournament.objects.last()
if last_tournament and not last_tournament.finished:
raise Exception('The last tournament did not finished')
else:
tournament = Tournament()
return self.create_teams(), tournament
def setUp(self):
super(BaseDebateTestCase, self).setUp()
# add test models
self.t = Tournament(slug="tournament")
self.t.save()
for i in range(4):
ins = Institution(code="INS%s"%i, name="Institution %s"%i)
ins.save()
for j in range(3):
team = Team(tournament=self.t, institution=ins, reference="Team%s%s" % (i,j))
team.save()
for k in range(2):
speaker = Speaker(team=team, name="Speaker%s%s%s" % (i,j,k))
speaker.save()
for j in range(2):
adj = Adjudicator(tournament=self.t, institution=ins, name="Adjudicator%s%s" %
(i,j), test_score=0)
adj.save()
for i in range(8):
venue = Venue(name="Venue %s" % i)
venue.priority = i
venue.save()
venue = Venue(name="IVenue %s" % i)
venue.priority = i
venue.save()
def handle(self, *args, **options):
Tournament.objects.all().delete()
Player.objects.all().delete()
path = '/Users/alexevans/Desktop/Projects/fgolf/fg/external_files/csvs/'
os.chdir(path)
with open('tournaments.csv', encoding='utf-8-sig') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
t = Tournament(name=row['TOURNAMENT'],
file_name=row['FILE NAME'],
start_date=row['START DATE'],
end_date=row['END DATE'],
leaderboard_url=row['URL'])
t.save()
self.load_tournament_players(t)
self.stdout.write(
self.style.SUCCESS('Successfully loaded Tournaments'))
class BaseDebateTestCase(TestCase):
def setUp(self):
super(BaseDebateTestCase, self).setUp()
# add test models
self.t = Tournament(slug="tournament")
self.t.save()
for i in range(4):
ins = Institution(code="INS%s"%i, name="Institution %s"%i)
ins.save()
for j in range(3):
team = Team(tournament=self.t, institution=ins, reference="Team%s%s" % (i,j))
team.save()
for k in range(2):
speaker = Speaker(team=team, name="Speaker%s%s%s" % (i,j,k))
speaker.save()
for j in range(2):
adj = Adjudicator(tournament=self.t, institution=ins, name="Adjudicator%s%s" %
(i,j), test_score=0)
adj.save()
for i in range(8):
venue = Venue(name="Venue %s" % i)
venue.priority = i
venue.save()
venue = Venue(name="IVenue %s" % i)
venue.priority = i
venue.save()
def activate_all_adj(self, r):
for adj in Adjudicator.objects.all():
r.activate_adjudicator(adj, True)
def activate_all_venue(self, r):
for venue in Venue.objects.all():
r.activate_venue(venue, True)
def activate_all_teams(self, r):
for team in Team.objects.all():
r.activate_team(team, True)
def activate_venues(self, r):
for venue in Venue.objects.all():
if venue.name.startswith("Venue"):
r.activate_venue(venue, True)
def setUp(self):
self.phase = Tournament.FIRST_PHASE
self.group_letter = 'A'
self.team_a_name = 'Brazil'
self.team_b_name = 'Germany'
self.tournament = Tournament(phase=self.phase)
self.tournament.save()
self.group = Group(letter=self.group_letter)
self.group.tournament_id = self.tournament.id
self.group.save()
self.team_a_goals = random.randint(0, 10)
self.team_b_goals = random.randint(0, 10)
self.team_a = Team(name=self.team_a_name)
self.team_b = Team(name=self.team_b_name)
self.team_a.group_id = self.group.id
self.team_b.group_id = self.group.id
self.team_a.save()
self.team_b.save()
def single_tournament_views(request, id):
tournament = Tournament.get_tournament_by_uuid(id)
if tournament:
render_data = {'nbar': 'tournaments',
'tournament': tournament}
return render(request, 'tournaments/view-tournament.html', render_data)
else:
raise Http404('The Tournament you are looking for does not exist.')
def get(self, request):
news_count = News.objects.count()
tournaments_count = Tournament.objects.count()
return render(
request, 'bowling_app/home.html', {
'news': News.ordered_by_creation(3),
'tournaments': Tournament.ordered_by_creation(3),
'news_count': news_count,
'tournaments_count': tournaments_count
})
def load_tournament_upcoming():
## FORMAT: ARRAY OF LISTS
## [id, name, date, entry_fee]
tournaments = Tournament.get_upcoming_tournaments()
output = []
for tournament in tournaments:
output.append([
str(tournament.id), tournament.name, tournament.datetime,
tournament.entry_fee
])
return output
def single_account_tournaments_display(user):
tournament_ids = user.tournaments
tournaments_data = [] ## [id, date, name, location, place]
if tournament_ids:
tournaments = Tournament.get_tournaments_by_uuid_list(tournament_ids)
for tournament in tournaments:
tournaments_data.append([
tournament.id, tournament.datetime, tournament.name,
tournament.center_short_location,
tournament.get_place(user.id)
])
return tournaments_data
def update_all_cache():
print('updating all of cache')
cache.set(
'cache_id', '#' + ''.join(
random.choice(string.ascii_uppercase + string.digits)
for _ in range(5)))
cache.set('top_rankings', top_rankings())
cache.set('tournament_winners', Tournament.ss_recent_winners())
cache.set('upcoming_tournaments', Tournament.get_upcoming(5))
cache.set('bowler_of_month', User.ss_bowler_of_month())
cache.set('user_count', User.objects.all().count())
cache.set('tournament_count', Tournament.objects.all().count())
cache.set('donation_count', 12500)
cache.set('featured_tournament', Tournament.ss_featured_tournament())
cache.set('featured_series', Tournament.featured_series())
cache.set('featured_live', Tournament.objects.all().last())
print('finished updating cache')
user = User.objects.filter(last_name__icontains='Snodgrass').first()
user.is_bowler_of_month = True
print(user.first_name)
user.save()
def get_queryset(self):
tournament_type = 'all'
form = self.form_class(self.request.GET)
if 'tournament_type' in self.kwargs:
tournament_type = self.kwargs['tournament_type']
tournaments = Tournament.get_by_type(tournament_type)
if form.is_valid():
return tournaments.filter(
Q(name__icontains=form.cleaned_data['search_field'])
| Q(city__name__icontains=form.cleaned_data['search_field']))[
(self.get_page() - 1) * 10:self.get_page() * 10]
else:
return tournaments[(self.get_page() - 1) * 10:self.get_page() * 10]
def convert_tournaments(jsonstr):
Tournament.objects.all().delete()
datas = json.loads(jsonstr)
length = len(datas)
count = 0
for data in datas:
name = data[0]
count = count + 1
if data is not None and data[1] != 'None' and data[1] is not None:
tournament = Tournament.create(name)
date = datetime.strptime(data[1], '%m/%d/%y')
tournament.tournament_date = date.strftime('%Y-%m-%d')
tournament.tournament_oil = data[2]
tournament.tournament_center = data[3]
tournament.entry = data[4]
tournament.qualifiers = json.dumps(data[5])
tournament.matchplay = json.dumps(data[6])
print('Adding Tournament (' + str(count) + '/' + str(length) + ')')
tournament.save()
return assign_players()
def compute_statistics() -> None:
"""Compute all the statistics for every relevant cards.
This step needs to be done after all steps have finished.
"""
logger.info('Computing cards statistics')
class Classifier:
# TODO: implement me :'(
@staticmethod
def predict(_):
return 0
for card in Card.objects.filter(is_relevant=True):
logger.debug('Predicting price for card {}...'.format(card))
features = Features.objects.get(card=card, date=date.today())
predicted_price = Classifier.predict(features.features)
logger.debug('Computing price ratio for card {}...'.format(card))
current_prices = Price.objects.filter(card=card, date=date.today())
price_ratio = predicted_price / current_prices.mean_price
logger.debug('Computing playing ratio for card {}...'.format(card))
played_cards = Tournament.get_played_cards(
date.today(),
date.today() - timedelta(days=Statistics.PLAYING_WINDOW))
playing_ratio = played_cards[card.name.name] / sum(
played_cards.values())
statistics, created = Statistics.objects.get_or_create(
card=card,
date=date.today(),
defaults={
'predicted_price': predicted_price,
'price_ratio': price_ratio,
'playing_ratio': playing_ratio
})
if created:
logger.debug('Created statistics {}'.format(statistics))
u8 = User(username="******", password="******") u8.save() u9 = User(username="******", password="******") u9.save() p1 = Player(user=u1, is_lta=True, last_lta=datetime.now(), ltas=1) p1.save() p2 = Player(user=u2, is_lta=False, last_lta=None, ltas=0) p2.save() p3 = Player(user=u3, is_lta=False, last_lta=None, ltas=0) p3.save() p4 = Player(user=u4, is_lta=True, last_lta=datetime.now() - timedelta(days=7), ltas=1) p4.save() p5 = Player(user=u5, is_lta=True, last_lta=datetime.now() - timedelta(days=15), ltas=1) p5.save() p6 = Player(user=u6, is_lta=True, last_lta=datetime.now() - timedelta(days=15), ltas=1) p6.save() p7 = Player(user=u7, is_lta=False, last_lta=None, ltas=0) p7.save() p8 = Player(user=u8, is_lta=False, last_lta=None, ltas=0) p8.save() p9 = Player(user=u9, is_lta=False, last_lta=None, ltas=0) p9.save() t1 = Tournament(date=datetime.now(), rounds=4) t1.save() t1.players.set([p1,p2,p3,p4,p5,p6,p7,p8,p9])
def CreateTournamentFromList(data):
if data != None:
tournament = Tournament()
tournament.name = data[0]
if data[1] != None:
tournament.tournament_date = data[1]
tournament.description = data[2]
if data[3] == None or data[3] == 'None':
data[3] = '12:00'
tournament.tournament_time = data[3]
tournament.center = data[4]
tournament.entry_fee = data[5]
tournament.qualifiers = data[6]
tournament.matchplay = data[7]
tournament.format = data[8]
return tournament
p1 = Player(user=u1, is_lta=True, last_lta=datetime.now(), ltas=1)
p1.save()
p2 = Player(user=u2, is_lta=False, last_lta=None, ltas=0)
p2.save()
p3 = Player(user=u3, is_lta=False, last_lta=None, ltas=0)
p3.save()
p4 = Player(user=u4,
is_lta=True,
last_lta=datetime.now() - timedelta(days=7),
ltas=1)
p4.save()
p5 = Player(user=u5,
is_lta=True,
last_lta=datetime.now() - timedelta(days=15),
ltas=1)
p5.save()
p6 = Player(user=u6,
is_lta=True,
last_lta=datetime.now() - timedelta(days=15),
ltas=1)
p6.save()
p7 = Player(user=u7, is_lta=False, last_lta=None, ltas=0)
p7.save()
p8 = Player(user=u8, is_lta=False, last_lta=None, ltas=0)
p8.save()
p9 = Player(user=u9, is_lta=False, last_lta=None, ltas=0)
p9.save()
t1 = Tournament(date=datetime.now(), rounds=4)
t1.save()
t1.players.set([p1, p2, p3, p4, p5, p6, p7, p8, p9])
def setUp(self):
self.letter = 'A'
self.tournament = Tournament()
self.tournament.save()
self.group = Group(letter=self.letter)
self.group.tournament_id = self.tournament.id
class Importer:
def __init__(self, tournament):
self.root = tournament
def import_tournament(self):
self.tournament = Tournament(name=self.root.get('name'))
if self.root.get('short') is not None:
self.tournament.short_name = self.root.get('short')
self.tournament.slug = slugify(self.root.get('short'))
else:
self.tournament.short_name = self.root.get('name')[:25]
self.tournament.slug = slugify(self.root.get('name')[:50])
self.tournament.save()
self.is_bp = self.root.get('style') == 'bp' or len(
self.root.findall('round/debate[1]/side')) == 4
# Import all the separate parts
self.set_preferences()
self.import_institutions()
self.import_categories()
self.import_venues()
self.import_questions()
self.import_teams()
self.import_speakers()
self.import_adjudicators()
self.import_debates()
self.import_motions()
self.import_results()
self.import_feedback()
def _is_consensus_ballot(self, elimination):
xpath = "round[@elimination='" + elimination + "']/debate/side"
return len(self.root.findall(xpath + "/ballot")) == len(
self.root.findall(xpath))
def set_preferences(self):
styles = {
"apda": None,
"asians": None,
"aus-easters": AustralianEastersPreferences,
"australs": AustralsPreferences,
"bp": BritishParliamentaryPreferences,
"cndc": None,
"cp": CanadianParliamentaryPreferences,
"ffd": None,
"joynt": JoyntPreferences,
"npda": None,
"nz-easters": NZEastersPreferences,
"opd": None,
"paris-v": None,
"uadc": UADCPreferences,
"wsdc": WSDCPreferences,
"": None,
}
if self.root.get('style') is not None and styles[self.root.get(
'style', '')] is not None:
style = styles[self.root.get('style')]
save_presets(self.tournament, style)
self.preliminary_consensus = style.debate_rules__ballots_per_debate_prelim == 'per-debate'
self.elimination_consensus = style.debate_rules__ballots_per_debate_elim == 'per-debate'
return True # Exit method
if self.is_bp:
self.preliminary_consensus = True
self.elimination_consensus = True
save_presets(self.tournament, BritishParliamentaryPreferences)
else:
self.preliminary_consensus = self._is_consensus_ballot('false')
self.elimination_consensus = self._is_consensus_ballot('true')
substantive_speakers = len(
self.root.findall(
"round[1]/debate[1]/side[1]/speech[@reply='false']"))
reply_scores_enabled = len(
self.root.findall(
"round/debate/side/speech[@reply='true']")) != 0
margin_includes_dissenters = len(
self.root.findall(
"round/debate/side/ballot[@minority='true'][@ignored='true']"
)) == 0
self.tournament.preferences[
'debate_rules__substantive_speakers'] = substantive_speakers
self.tournament.preferences[
'debate_rules__reply_scores_enabled'] = reply_scores_enabled
self.tournament.preferences[
'debate_rules__ballots_per_debate_prelim'] = 'per-debate' if self.preliminary_consensus else 'per-adj'
self.tournament.preferences[
'debate_rules__ballots_per_debate_elim'] = 'per-debate' if self.elimination_consensus else 'per-adj'
self.tournament.preferences[
'scoring__margin_includes_dissenters'] = margin_includes_dissenters
def import_institutions(self):
self.institutions = {}
self.regions = {}
for institution in self.root.findall('institution'):
# Use get_or_create as institutions may be shared between tournaments
inst_obj, created = Institution.objects.get_or_create(
code=institution.get('reference'),
name=institution.text,
)
self.institutions[institution.get('id')] = inst_obj
if institution.get('region') is not None:
region = institution.get('region')
if region not in self.regions:
self.regions[
region], created = Region.objects.get_or_create(
name=region)
inst_obj.region = self.regions[region]
inst_obj.save()
def import_categories(self):
self.team_breaks = {}
self.speaker_categories = {}
for i, breakqual in enumerate(self.root.findall('break-category'), 1):
bc = BreakCategory(
tournament=self.tournament,
name=breakqual.text,
slug=slugify(breakqual.text[:50]),
seq=i,
break_size=0,
is_general=False,
priority=0,
)
bc.save()
self.team_breaks[breakqual.get('id')] = bc
for i, category in enumerate(self.root.findall('speaker-category'), 1):
sc = SpeakerCategory(
tournament=self.tournament,
name=category.text,
slug=slugify(category.text[:50]),
seq=i,
)
sc.save()
self.speaker_categories[category.get('id')] = sc
def import_venues(self):
self.venues = {}
for venue in self.root.findall('venue'):
v = Venue(tournament=self.tournament,
name=venue.text,
priority=venue.get('priority', 0))
v.save()
self.venues[venue.get('id')] = v
def import_questions(self):
self.questions = {}
for i, question in enumerate(self.root.findall('question'), 1):
q = AdjudicatorFeedbackQuestion(
tournament=self.tournament,
seq=i,
text=question.text,
name=question.get('name'),
reference=slugify(question.get('name')[:50]),
from_adj=question.get('from-adjudicators') == 'true',
from_team=question.get('from-teams') == 'true',
answer_type=question.get('type'),
required=False,
)
q.save()
self.questions[question.get('id')] = q
def import_teams(self):
self.teams = {}
for team in self.root.findall('participants/team'):
team_obj = Team(tournament=self.tournament,
long_name=team.get('name'))
self.teams[team.get('id')] = team_obj
# Get emoji & code name
if 'code' in team.attrib:
team_obj.code_name = team.get('code')
emoji = EMOJI_BY_NAME.get(team.get('code'))
if emoji is not None:
team_obj.emoji = emoji
# Find institution from speakers - Get first institution from each speaker to compare
p_institutions = [
p.get('institutions', '').split(" ")
for p in team.findall('speaker')
]
p_inst = set([i[0] for i in p_institutions])
team_institution = next(iter(p_inst)) if len(p_inst) == 1 else None
institutions = set([i for s in p_institutions for i in s])
if team_institution: # Both None and ""
team_obj.institution = self.institutions.get(team_institution)
# Remove institution from team name
if team_obj.institution is not None and team_obj.long_name.startswith(
team_obj.institution.name + " "):
team_obj.reference = team_obj.long_name[len(team_obj.
institution.name) +
1:]
team_obj.short_name = team_obj.institution.code + " " + team_obj.reference
team_obj.use_institution_prefix = True
else:
team_obj.reference = team_obj.long_name
team_obj.short_name = team_obj.reference[:50]
team_obj.short_reference = team_obj.reference[:35]
team_obj.save()
# Institution conflicts
team_obj.institution_conflicts.set(
[self.institutions.get(i) for i in institutions if i != ""])
# Break eligibilities
team_obj.break_categories.set([
self.team_breaks[bc]
for bc in team.get('break-eligibilities', "").split()
if bc != ""
])
def import_speakers(self):
self.speakers = {}
for team in self.root.findall('participants/team'):
for speaker in team.findall('speaker'):
speaker_obj = Speaker(team=self.teams[team.get('id')],
name=speaker.text,
gender=speaker.get('gender', ''),
email=speaker.get('email', ''))
speaker_obj.save()
self.speakers[speaker.get('id')] = speaker_obj
speaker_obj.categories.set([
self.speaker_categories[sc]
for sc in speaker.get('categories', "").split() if sc != ""
])
def import_adjudicators(self):
self.adjudicators = {}
adj_adj_conflicts = []
for adj in self.root.findall('participants/adjudicator'):
adj_obj = Adjudicator(tournament=self.tournament,
base_score=adj.get('score', 0),
institution=self.institutions.get(
adj.get('institutions',
"").split(" ")[0]),
independent=adj.get('independent',
False) == 'true',
adj_core=adj.get('core', False) == 'true',
name=adj.get('name'),
gender=adj.get('gender', ''),
email=adj.get('email', ''))
adj_obj.save()
self.adjudicators[adj.get('id')] = adj_obj
# Conflicts
adj_obj.institution_conflicts.set([
self.institutions[i]
for i in adj.get('institutions', "").split(" ") if i != ""
])
adj_obj.team_conflicts.set([
self.teams[t] for t in adj.get('team-conflicts', "").split(" ")
if t != ""
])
adj_adj_conflicts.extend([
(adj_obj, adj2)
for adj2 in adj.get('adjudicator-conflicts', "").split(" ")
if adj2 != ""
])
AdjudicatorAdjudicatorConflict.objects.bulk_create([
AdjudicatorAdjudicatorConflict(
adjudicator1=adj1, adjudicator2=self.adjudicators[adj2])
for adj1, adj2 in adj_adj_conflicts
])
def _get_voting_adjs(self, debate):
voting_adjs = set()
for ballot in debate.findall('.//ballot'):
voting_adjs.update(ballot.get('adjudicators').split())
return voting_adjs
def import_debates(self):
self.debates = {}
self.debateteams = {}
self.debateadjudicators = {}
rounds = []
for i, round in enumerate(self.root.findall('round'), 1):
round_stage = Round.STAGE_ELIMINATION if round.get(
'elimination', 'false') == 'true' else Round.STAGE_PRELIMINARY
draw_type = Round.DRAW_ELIMINATION if round_stage == Round.STAGE_ELIMINATION else Round.DRAW_MANUAL
round_obj = Round(tournament=self.tournament,
seq=i,
completed=True,
name=round.get('name'),
abbreviation=round.get('abbreviation',
round.get('name')[:10]),
stage=round_stage,
draw_type=draw_type,
draw_status=Round.STATUS_RELEASED,
feedback_weight=round.get('feedback-weight', 0),
starts_at=round.get('start'))
rounds.append(round_obj)
if round.find('debate') is None:
round_obj.completed = False
if round.find('debate/side/ballot') is None:
round_obj.draw_status = Round.STATUS_NONE
if round_stage == Round.STAGE_ELIMINATION:
round_obj.break_category = self.team_breaks.get(
round.get('break-category'))
round_obj.save()
side_start = 2 if self.is_bp else 0
for debate in round.findall('debate'):
debate_obj = Debate(round=round_obj,
venue=self.venues.get(debate.get('venue')),
result_status=Debate.STATUS_CONFIRMED)
debate_obj.save()
self.debates[debate.get('id')] = debate_obj
# Debate-teams
for i, side in enumerate(debate.findall('side'), side_start):
position = DebateTeam.SIDE_CHOICES[i][0]
debateteam_obj = DebateTeam(
debate=debate_obj,
team=self.teams[side.get('team')],
side=position)
debateteam_obj.save()
self.debateteams[(debate.get('id'),
side.get('team'))] = debateteam_obj
# Debate-adjudicators
voting_adjs = self._get_voting_adjs(debate)
for adj in debate.get('adjudicators').split():
adj_type = DebateAdjudicator.TYPE_PANEL if adj in voting_adjs else DebateAdjudicator.TYPE_TRAINEE
if debate.get('chair') == adj:
adj_type = DebateAdjudicator.TYPE_CHAIR
adj_obj = DebateAdjudicator(
debate=debate_obj,
adjudicator=self.adjudicators[adj],
type=adj_type)
adj_obj.save()
self.debateadjudicators[(debate.get('id'), adj)] = adj_obj
def import_motions(self):
# Can cause data consistency problems if motions are re-used between rounds: See #645
self.motions = {}
motions_by_round = {}
seq_by_round = {}
for r_obj, round in zip(
self.tournament.round_set.all().order_by('seq'),
self.root.findall('round')):
motions_by_round[r_obj.id] = set()
seq_by_round[r_obj.id] = 1
for debate in round.findall('debate'):
motions_by_round[r_obj.id].add(debate.get('motion'))
for motion in self.root.findall('motion'):
for r, m_set in motions_by_round.items():
if motion.get('id') in m_set:
motion_obj = Motion(seq=seq_by_round[r],
text=motion.text,
reference=motion.get('reference'),
info_slide=getattr(
motion.find('info-slide'), 'text',
''),
round_id=r)
motion_obj.save()
self.motions[motion.get('id')] = motion_obj
def import_results(self):
for round in self.root.findall('round'):
consensus = self.preliminary_consensus if round.get(
'elimination') == 'false' else self.elimination_consensus
for debate in round.findall('debate'):
bs_obj = BallotSubmission(
version=1,
submitter_type=Submission.SUBMITTER_TABROOM,
confirmed=True,
debate=self.debates[debate.get('id')],
motion=self.motions.get(debate.get('motion')))
bs_obj.save()
dr = DebateResult(bs_obj)
numeric_scores = True
try:
float(debate.find("side/ballot").text)
except ValueError:
numeric_scores = False
for side, side_code in zip(debate.findall('side'),
self.tournament.sides):
if side.get('motion-veto') is not None:
bs_obj.debateteammotionpreference_set.add(
debate_team=self.debateteams.get(
(debate.get('id'), side.get('team'))),
motion=self.motions.get(side.get('motion-veto')),
preference=3)
for speech, pos in zip(side.findall('speech'),
self.tournament.positions):
if numeric_scores:
dr.set_speaker(
side_code, pos,
self.speakers.get(speech.get('speaker')))
if consensus:
dr.set_score(side_code, pos,
float(speech.find('ballot').text))
else:
for ballot in speech.findall('ballot'):
for adj in [
self.adjudicators[a]
for a in ballot.get(
'adjudicators', "").split(" ")
]:
dr.set_score(adj, side_code, pos,
float(ballot.text))
# Note: Dependent on #1180
if consensus:
if int(side.find('ballot').get('rank')) == 1:
dr.add_winner(side_code)
else:
for ballot in side.findall('ballot'):
for adj in [
self.adjudicators.get(a) for a in
ballot.get('adjudicators', "").split(" ")
]:
if int(ballot.get('rank')) == 1:
dr.add_winner(adj, side_code)
dr.save()
def import_feedback(self):
for adj in self.root.findall('participants/adjudicator'):
adj_obj = self.adjudicators[adj.get('id')]
for feedback in adj.findall('feedback'):
d_adj = self.debateadjudicators.get(
(feedback.get('debate'),
feedback.get('source-adjudicator')))
d_team = self.debateteams.get(
(feedback.get('debate'), feedback.get('source-team')))
feedback_obj = AdjudicatorFeedback(
adjudicator=adj_obj,
score=feedback.get('score'),
version=1,
source_adjudicator=d_adj,
source_team=d_team,
submitter_type=Submission.SUBMITTER_TABROOM,
confirmed=True)
feedback_obj.save()
for answer in feedback.findall('answer'):
question = self.questions[answer.get('question')]
cast_answer = answer.text
# if question.answer_type in AdjudicatorFeedbackQuestion.NUMERICAL_ANSWER_TYPES:
# cast_answer = float(cast_answer)
answer = AdjudicatorFeedbackQuestion.ANSWER_TYPE_CLASSES[
question.answer_type](question=question,
answer=cast_answer,
feedback=feedback_obj)
def post(self, request, *args, **kwargs):
success = False
if request.user.is_authenticated and 'friend_id' in request.data and 'tournament_id' in request.data:
success = Tournament.leave_team(request.data['tournament_id'], request.user.id)
return Response({"success": success})
def post(self, request, *args, **kwargs):
friends = []
if request.user.is_authenticated and 'is_looking' in request.data and 'tournament_id' in request.data:
success = Tournament.set_looking_for_team(request.data['tournament_id'], request.user.id, request.data['is_looking'])
return Response({"success": success})
