def _render(self, team_number):
team = Team.get_by_id("frc" + team_number)
if not team:
return self.redirect("/error/404")
event_team_keys_future = EventTeam.query(EventTeam.team == team.key).fetch_async(1000, keys_only=True)
award_keys_future = Award.query(Award.team == team.key).fetch_async(1000, keys_only=True)
event_teams_futures = ndb.get_multi_async(event_team_keys_future.get_result())
awards_futures = ndb.get_multi_async(award_keys_future.get_result())
event_keys = [event_team_future.get_result().event for event_team_future in event_teams_futures]
events_futures = ndb.get_multi_async(event_keys)
awards_by_event = {}
for award_future in awards_futures:
award = award_future.get_result()
if award.event.id() not in awards_by_event:
awards_by_event[award.event.id()] = [award]
else:
awards_by_event[award.event.id()].append(award)
event_awards = []
current_event = None
matches_upcoming = None
short_cache = False
for event_future in events_futures:
event = event_future.get_result()
if event.now:
current_event = event
team_matches_future = Match.query(Match.event == event.key, Match.team_key_names == team.key_name)\
.fetch_async(500, keys_only=True)
matches = ndb.get_multi(team_matches_future.get_result())
matches_upcoming = MatchHelper.upcomingMatches(matches)
if event.within_a_day:
short_cache = True
if event.key_name in awards_by_event:
sorted_awards = AwardHelper.organizeAwards(awards_by_event[event.key_name])['list']
else:
sorted_awards = []
event_awards.append((event, sorted_awards))
event_awards = sorted(event_awards, key=lambda (e, _): e.start_date if e.start_date else datetime.datetime(e.year, 12, 31))
years = sorted(set([et.get_result().year for et in event_teams_futures if et.get_result().year != None]))
template_values = {'team': team,
'event_awards': event_awards,
'years': years,
'current_event': current_event,
'matches_upcoming': matches_upcoming}
if short_cache:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__), '../templates/team_history.html')
return template.render(path, template_values)
def data_payload(self):
from helpers.award_helper import AwardHelper
from helpers.model_to_dict import ModelToDict
return {
'awards': [ModelToDict.awardConverter(award) for award in AwardHelper.organizeAwards(self.event.awards)],
'event_key': self.event.key_name
}
def _render(self, team_key, event_key):
award_keys_future = Award.query(Award.team_list == ndb.Key(Team, self.team_key), Award.event == ndb.Key(Event, event_key)).fetch_async(None, keys_only=True)
awards = ndb.get_multi(award_keys_future.get_result())
awards_dicts = [ModelToDict.awardConverter(award) for award in AwardHelper.organizeAwards(awards)]
return json.dumps(awards_dicts, ensure_ascii=True)
def _render(self, team_key, event_key):
award_keys_future = Award.query(Award.team_list == ndb.Key(Team, self.team_key), Award.event == ndb.Key(Event, event_key)).fetch_async(None, keys_only=True)
awards = ndb.get_multi(award_keys_future.get_result())
awards_dicts = [ModelToDict.awardConverter(award) for award in AwardHelper.organizeAwards(awards)]
return json.dumps(awards_dicts, ensure_ascii=True)
def _render(self, event_key):
event = Event.get_by_id(event_key)
if not event:
return self.redirect("/error/404")
event.prepAwards()
event.prepMatches()
event.prepTeams()
awards = AwardHelper.organizeAwards(event.awards)
matches = MatchHelper.organizeMatches(event.matches)
teams = TeamHelper.sortTeams(event.teams)
num_teams = len(teams)
middle_value = num_teams/2
if num_teams%2 != 0:
middle_value += 1
teams_a, teams_b = teams[:middle_value], teams[middle_value:]
oprs = sorted(zip(event.oprs,event.opr_teams), reverse=True) # sort by OPR
oprs = oprs[:14] # get the top 15 OPRs
if event.within_a_day:
matches_recent = MatchHelper.recentMatches(event.matches)
matches_upcoming = MatchHelper.upcomingMatches(event.matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = {}
qf_matches = matches['qf']
sf_matches = matches['sf']
f_matches = matches['f']
if qf_matches:
bracket_table['qf'] = MatchHelper.generateBracket(qf_matches)
if sf_matches:
bracket_table['sf'] = MatchHelper.generateBracket(sf_matches)
if f_matches:
bracket_table['f'] = MatchHelper.generateBracket(f_matches)
template_values = {
"event": event,
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
}
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__), '../templates/event_details.html')
return template.render(path, template_values)
def render_team_history(cls, handler, team, is_canonical):
award_futures = award_query.TeamAwardsQuery(team.key.id()).fetch_async()
event_futures = event_query.TeamEventsQuery(team.key.id()).fetch_async()
participation_future = team_query.TeamParticipationQuery(team.key.id()).fetch_async()
social_media_future = media_query.TeamSocialMediaQuery(team.key.id()).fetch_async()
awards_by_event = {}
for award in award_futures.get_result():
if award.event.id() not in awards_by_event:
awards_by_event[award.event.id()] = [award]
else:
awards_by_event[award.event.id()].append(award)
event_awards = []
current_event = None
matches_upcoming = None
short_cache = False
years = set()
for event in event_futures.get_result():
years.add(event.year)
if event.now:
current_event = event
matches = match_query.TeamEventMatchesQuery(team.key.id(), event.key.id()).fetch()
matches_upcoming = MatchHelper.upcomingMatches(matches)
if event.within_a_day:
short_cache = True
if event.key_name in awards_by_event:
sorted_awards = AwardHelper.organizeAwards(awards_by_event[event.key_name])
else:
sorted_awards = []
event_awards.append((event, sorted_awards))
event_awards = sorted(event_awards, key=lambda (e, _): e.start_date if e.start_date else datetime.datetime(e.year, 12, 31))
last_competed = None
participation_years = participation_future.get_result()
if len(participation_years) > 0:
last_competed = max(participation_years)
current_year = datetime.date.today().year
social_medias = sorted(social_media_future.get_result(), key=MediaHelper.social_media_sorter)
handler.template_values.update({
'is_canonical': is_canonical,
'team': team,
'event_awards': event_awards,
'years': sorted(years),
"social_medias": social_medias,
'current_event': current_event,
'matches_upcoming': matches_upcoming,
'last_competed': last_competed,
'current_year': current_year
})
if short_cache:
handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('team_history.html', handler.template_values)
def _render(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
num_teams = len(teams)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = teams[:middle_value], teams[middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()] if (event.matchstats is not None and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.within_a_day:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = {}
qf_matches = matches['qf']
sf_matches = matches['sf']
f_matches = matches['f']
if qf_matches:
bracket_table['qf'] = MatchHelper.generateBracket(qf_matches)
if sf_matches:
bracket_table['sf'] = MatchHelper.generateBracket(sf_matches)
if f_matches:
bracket_table['f'] = MatchHelper.generateBracket(f_matches)
template_values = {
"event": event,
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
}
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__), '../templates/event_details.html')
return template.render(path, template_values)
def _render(self, event_key):
self._set_event(event_key)
award_dicts = [
ModelToDict.awardConverter(award)
for award in AwardHelper.organizeAwards(self.event.awards)
]
return json.dumps(award_dicts, ensure_ascii=True)
def parse(self, html):
"""
Parse the awards from USFIRST.
"""
html = html.decode("utf-8", "ignore") # Clean html before feeding itno BeautifulSoup
soup = BeautifulSoup(html, convertEntities=BeautifulSoup.HTML_ENTITIES)
table = soup.findAll("table")[6]
awards_by_type = {}
for tr in table.findAll("tr")[3:]:
tds = tr.findAll("td")
name_str = unicode(self._recurseUntilString(tds[0]))
award_type_enum = AwardHelper.parse_award_type(name_str)
if award_type_enum is None:
continue
team_number = None
try:
team_number = self._recurseUntilString(tds[1])
except AttributeError:
team_number = None
if team_number and team_number.isdigit():
team_number = int(team_number)
else:
team_number = None
awardee = None
if award_type_enum in AwardType.INDIVIDUAL_AWARDS:
try:
awardee_str = self._recurseUntilString(tds[2])
if awardee_str:
awardee = unicode(sanitize(awardee_str))
except TypeError:
awardee = None
if not awardee:
# Turns '' into None
awardee = None
# an award must have either an awardee or a team_number
if awardee is None and team_number is None:
continue
recipient_json = json.dumps({"team_number": team_number, "awardee": awardee})
if award_type_enum in awards_by_type:
if team_number is not None:
awards_by_type[award_type_enum]["team_number_list"].append(team_number)
awards_by_type[award_type_enum]["recipient_json_list"].append(recipient_json)
else:
awards_by_type[award_type_enum] = {
"name_str": strip_number(name_str),
"award_type_enum": award_type_enum,
"team_number_list": [team_number] if team_number is not None else [],
"recipient_json_list": [recipient_json],
}
return awards_by_type.values(), False
def webhook_message_data(self):
payload = self.data_payload
payload['event_name'] = self.event.name
from helpers.award_helper import AwardHelper
from helpers.model_to_dict import ModelToDict
if self.team:
payload['awards'] = [
ModelToDict.awardConverter(award)
for award in AwardHelper.organizeAwards(self.team_awards)
]
else:
payload['awards'] = [
ModelToDict.awardConverter(award)
for award in AwardHelper.organizeAwards(self.event.awards)
]
return payload
def _render(self, team_key, event_key):
awards = TeamEventAwardsQuery(self.team_key, self.event_key).fetch()
awards_dicts = [
ModelToDict.awardConverter(award)
for award in AwardHelper.organizeAwards(awards)
]
return json.dumps(awards_dicts, ensure_ascii=True)
def parse(cls, data):
"""
Parse CSV that contains awards
Format is as follows:
year, event_short, award_name_str, team_number (can be blank), awardee (can be blank)
Example:
2000,mi,Regional Finalist,45,
"""
awards_by_key = {}
csv_data = list(csv.reader(StringIO.StringIO(data), delimiter=',', skipinitialspace=True))
for award in csv_data:
year = int(award[0])
event_short = award[1]
name_str = award[2]
team_number = award[3]
awardee = award[4]
if team_number == '':
team_number = None
else:
team_number = int(team_number)
if awardee == '':
awardee = None
# an award must have either an awardee or a team_number
if awardee is None and team_number is None:
continue
if team_number is not None:
team_number_list = [team_number]
else:
team_number_list = []
recipient_json = json.dumps({
'team_number': team_number,
'awardee': awardee,
})
award_type_enum = AwardHelper.parse_award_type(name_str)
if award_type_enum is None:
# If we can't figure it out, fall back to OTHER (good for offseason events)
award_type_enum = AwardType.OTHER
award_key_name = Award.render_key_name('{}{}'.format(year, event_short), award_type_enum)
if award_key_name in awards_by_key:
if team_number is not None:
awards_by_key[award_key_name]['team_number_list'].append(team_number)
awards_by_key[award_key_name]['recipient_json_list'].append(recipient_json)
else:
awards_by_key[award_key_name] = {
'year': year,
'event_short': event_short,
'name_str': name_str,
'award_type_enum': award_type_enum,
'team_number_list': team_number_list,
'recipient_json_list': [recipient_json],
}
return awards_by_key.values()
def render_team_history(cls, handler, team, is_canonical):
award_futures = award_query.TeamAwardsQuery(
team.key.id()).fetch_async()
event_futures = event_query.TeamEventsQuery(
team.key.id()).fetch_async()
awards_by_event = {}
for award in award_futures.get_result():
if award.event.id() not in awards_by_event:
awards_by_event[award.event.id()] = [award]
else:
awards_by_event[award.event.id()].append(award)
event_awards = []
current_event = None
matches_upcoming = None
short_cache = False
years = set()
for event in event_futures.get_result():
years.add(event.year)
if event.now:
current_event = event
matches = match_query.TeamEventMatchesQuery(
team.key.id(), event.key.id()).fetch()
matches_upcoming = MatchHelper.upcomingMatches(matches)
if event.within_a_day:
short_cache = True
if event.key_name in awards_by_event:
sorted_awards = AwardHelper.organizeAwards(
awards_by_event[event.key_name])
else:
sorted_awards = []
event_awards.append((event, sorted_awards))
event_awards = sorted(
event_awards,
key=lambda (e, _): e.start_date
if e.start_date else datetime.datetime(e.year, 12, 31))
handler.template_values.update({
'is_canonical': is_canonical,
'team': team,
'event_awards': event_awards,
'years': sorted(years),
'current_event': current_event,
'matches_upcoming': matches_upcoming
})
if short_cache:
handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__),
'../templates/team_history.html')
return template.render(path, handler.template_values)
def _render(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
num_teams = len(teams)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = teams[:middle_value], teams[middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()] if (event.matchstats is not None and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.within_a_day:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = MatchHelper.generateBracket(matches, event.alliance_selections)
district_points_sorted = None
if event.district_points:
district_points_sorted = sorted(event.district_points['points'].items(), key=lambda (team, points): -points['total'])
self.template_values.update({
"event": event,
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
"district_points_sorted": district_points_sorted,
})
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__), '../templates/event_details.html')
return template.render(path, self.template_values)
def _build_dict(self):
data = {}
data['message_type'] = NotificationType.type_names[self._type]
data['message_data'] = {}
data['message_data']['event_name'] = self.event.name
data['message_data']['event_key'] = self.event.key_name
data['message_data']['awards'] = [
ModelToDict.awardConverter(award)
for award in AwardHelper.organizeAwards(self.event.awards)
]
return data
def doAwardInsights(self, year):
"""
Calculate award insights for a given year. Returns a list of Insights.
"""
# Only fetch from DB once
keysToQuery = Award.BLUE_BANNER_KEYS.union(Award.DIVISION_FIN_KEYS).union(Award.CHAMPIONSHIP_FIN_KEYS)
awards = AwardHelper.getAwards(keysToQuery, year)
insights = []
insights += self._calculateBlueBanners(awards, year)
insights += self._calculateChampionshipStats(awards, year)
insights += self._calculateRegionalStats(awards, year)
return insights
def parse(self, response):
awards_by_type = {}
for award in response['Awards']:
team_number = award['teamNumber']
if self.valid_team_nums is not None and team_number not in self.valid_team_nums:
continue
award_type_enum = AwardHelper.parse_award_type(award['name'])
if award_type_enum is None:
continue
recipient_json = json.dumps({
'team_number': team_number,
'awardee': award['person'],
})
if award_type_enum in awards_by_type:
if team_number is not None:
awards_by_type[award_type_enum]['team_number_list'].append(
team_number)
awards_by_type[award_type_enum]['recipient_json_list'].append(
recipient_json)
else:
awards_by_type[award_type_enum] = {
'name_str':
award['name'],
'award_type_enum':
award_type_enum,
'team_number_list':
[team_number] if team_number is not None else [],
'recipient_json_list': [recipient_json],
}
awards = []
for award in awards_by_type.values():
awards.append(
Award(id=Award.render_key_name(self.event.key_name,
award['award_type_enum']),
name_str=award['name_str'],
award_type_enum=award['award_type_enum'],
year=self.event.year,
event=self.event.key,
event_type_enum=self.event.event_type_enum,
team_list=[
ndb.Key(Team, 'frc{}'.format(team_number))
for team_number in award['team_number_list']
],
recipient_json_list=award['recipient_json_list']))
return awards
def parse(self, awards_json, event_key):
"""
Parse JSON that contains a list of awards where each award is a dict of:
name_str: String of award name. ex: "Tournament Winner" or "Dean's List Finalist"
team_key: String in the format "frcXXX" for the team that won the award. Can be null.
awardee: String corresponding to the name of an individual that won the award. Can be null.
"""
try:
awards = json.loads(awards_json)
except:
raise ParserInputException("Invalid JSON. Please check input.")
awards_by_key = {}
for award in awards:
if type(award) is not dict:
raise ParserInputException("Awards must be dicts.")
name_str = award.get('name_str', None)
team_key = award.get('team_key', None)
awardee = award.get('awardee', None)
if name_str is None:
raise ParserInputException("Award must have a 'name_str'")
if team_key and not re.match(r'frc\d+', str(team_key)):
raise ParserInputException("Bad team_key: '{}'. Must follow format 'frcXXX' or be null.".format(team_key))
award_type_enum = AwardHelper.parse_award_type(name_str)
if award_type_enum is None:
raise ParserInputException("Cannot determine award type from: '{}'. Please contact a www.thebluealliance.com admin.".format(name_str))
recipient_json = json.dumps({
'team_number': int(team_key[3:]) if team_key else None,
'awardee': awardee,
})
award_key_name = Award.render_key_name(event_key, award_type_enum)
if award_key_name in awards_by_key:
if team_key is not None:
awards_by_key[award_key_name]['team_key_list'].append(team_key)
awards_by_key[award_key_name]['recipient_json_list'].append(recipient_json)
else:
awards_by_key[award_key_name] = {
'name_str': name_str,
'award_type_enum': award_type_enum,
'team_key_list': [team_key] if team_key else [],
'recipient_json_list': [recipient_json],
}
return awards_by_key.values()
def test_build(self):
expected = {}
expected['message_type'] = NotificationType.type_names[
NotificationType.AWARDS]
expected['message_data'] = {}
expected['message_data']['event_name'] = self.event.name
expected['message_data']['event_key'] = self.event.key_name
expected['message_data']['awards'] = [
ModelToDict.awardConverter(award)
for award in AwardHelper.organizeAwards(self.event.awards)
]
data = self.notification._build_dict()
self.assertEqual(expected, data)
def render_team_history(cls, handler, team, is_canonical):
award_futures = award_query.TeamAwardsQuery(team.key.id()).fetch_async()
event_futures = event_query.TeamEventsQuery(team.key.id()).fetch_async()
awards_by_event = {}
for award in award_futures.get_result():
if award.event.id() not in awards_by_event:
awards_by_event[award.event.id()] = [award]
else:
awards_by_event[award.event.id()].append(award)
event_awards = []
current_event = None
matches_upcoming = None
short_cache = False
years = set()
for event in event_futures.get_result():
years.add(event.year)
if event.now:
current_event = event
matches = match_query.TeamEventMatchesQuery(team.key.id(), event.key.id()).fetch()
matches_upcoming = MatchHelper.upcomingMatches(matches)
if event.within_a_day:
short_cache = True
if event.key_name in awards_by_event:
sorted_awards = AwardHelper.organizeAwards(awards_by_event[event.key_name])
else:
sorted_awards = []
event_awards.append((event, sorted_awards))
event_awards = sorted(event_awards, key=lambda (e, _): e.start_date if e.start_date else datetime.datetime(e.year, 12, 31))
handler.template_values.update({
'is_canonical': is_canonical,
'team': team,
'event_awards': event_awards,
'years': sorted(years),
'current_event': current_event,
'matches_upcoming': matches_upcoming
})
if short_cache:
handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__), '../templates/team_history.html')
return template.render(path, handler.template_values)
def parse(self, response):
awards_by_type = {}
for award in response['Awards']:
team_number = award['teamNumber']
if self.valid_team_nums is not None and team_number not in self.valid_team_nums:
continue
award_type_enum = AwardHelper.parse_award_type(award['name'])
if award_type_enum is None:
continue
recipient_json = json.dumps({
'team_number': team_number,
'awardee': award['person'],
})
if award_type_enum in awards_by_type:
if team_number is not None:
awards_by_type[award_type_enum]['team_number_list'].append(team_number)
awards_by_type[award_type_enum]['recipient_json_list'].append(recipient_json)
else:
awards_by_type[award_type_enum] = {
'name_str': award['name'],
'award_type_enum': award_type_enum,
'team_number_list': [team_number] if team_number is not None else [],
'recipient_json_list': [recipient_json],
}
awards = []
for award in awards_by_type.values():
awards.append(Award(
id=Award.render_key_name(self.event.key_name, award['award_type_enum']),
name_str=award['name_str'],
award_type_enum=award['award_type_enum'],
year=self.event.year,
event=self.event.key,
event_type_enum=self.event.event_type_enum,
team_list=[ndb.Key(Team, 'frc{}'.format(team_number)) for team_number in award['team_number_list']],
recipient_json_list=award['recipient_json_list']
))
return awards
def test_parse(self):
"""
Tests for a select subset of award types. Add more if desired.
"""
self.assertEqual(AwardHelper.parse_award_type("Chairman's"),
AwardType.CHAIRMANS)
self.assertEqual(AwardHelper.parse_award_type("Chairman"),
AwardType.CHAIRMANS)
self.assertEqual(AwardHelper.parse_award_type("Winner #1"),
AwardType.WINNER)
self.assertEqual(AwardHelper.parse_award_type("Division Winner #2"),
AwardType.WINNER)
self.assertEqual(
AwardHelper.parse_award_type("Newton - Division Champion #3"),
AwardType.WINNER)
self.assertEqual(
AwardHelper.parse_award_type("Championship Winner #3"),
AwardType.WINNER)
self.assertEqual(
AwardHelper.parse_award_type("Championship Champion #4"),
AwardType.WINNER)
self.assertEqual(AwardHelper.parse_award_type("Championship Champion"),
AwardType.WINNER)
self.assertEqual(AwardHelper.parse_award_type("Championship Winner"),
AwardType.WINNER)
self.assertEqual(AwardHelper.parse_award_type("Winner"),
AwardType.WINNER)
self.assertEqual(AwardHelper.parse_award_type("Finalist #1"),
AwardType.FINALIST)
self.assertEqual(AwardHelper.parse_award_type("Division Finalist #2"),
AwardType.FINALIST)
self.assertEqual(
AwardHelper.parse_award_type("Championship Finalist #3"),
AwardType.FINALIST)
self.assertEqual(
AwardHelper.parse_award_type("Championship Finalist #4"),
AwardType.FINALIST)
self.assertEqual(AwardHelper.parse_award_type("Championship Finalist"),
AwardType.FINALIST)
self.assertEqual(AwardHelper.parse_award_type("Finalist"),
AwardType.FINALIST)
self.assertEqual(
AwardHelper.parse_award_type("Dean's List Finalist #1"),
AwardType.DEANS_LIST)
self.assertEqual(AwardHelper.parse_award_type("Dean's List Finalist"),
AwardType.DEANS_LIST)
self.assertEqual(AwardHelper.parse_award_type("Dean's List Winner #9"),
AwardType.DEANS_LIST)
self.assertEqual(AwardHelper.parse_award_type("Dean's List Winner"),
AwardType.DEANS_LIST)
self.assertEqual(AwardHelper.parse_award_type("Dean's List"),
AwardType.DEANS_LIST)
self.assertEqual(
AwardHelper.parse_award_type(
"Excellence in Design Award sponsored by Autodesk (3D CAD)"),
AwardType.EXCELLENCE_IN_DESIGN_CAD)
self.assertEqual(
AwardHelper.parse_award_type(
"Excellence in Design Award sponsored by Autodesk (Animation)"
), AwardType.EXCELLENCE_IN_DESIGN_ANIMATION)
self.assertEqual(
AwardHelper.parse_award_type("Excellence in Design Award"),
AwardType.EXCELLENCE_IN_DESIGN)
self.assertEqual(
AwardHelper.parse_award_type(
"Dr. Bart Kamen Memorial Scholarship #1"),
AwardType.BART_KAMEN_MEMORIAL)
self.assertEqual(
AwardHelper.parse_award_type(
"Media and Technology Award sponsored by Comcast"),
AwardType.MEDIA_AND_TECHNOLOGY)
self.assertEqual(AwardHelper.parse_award_type("Make It Loud Award"),
AwardType.MAKE_IT_LOUD)
self.assertEqual(AwardHelper.parse_award_type("Founder's Award"),
AwardType.FOUNDERS)
self.assertEqual(
AwardHelper.parse_award_type("Championship - Web Site Award"),
AwardType.WEBSITE)
self.assertEqual(
AwardHelper.parse_award_type(
"Recognition of Extraordinary Service"),
AwardType.RECOGNITION_OF_EXTRAORDINARY_SERVICE)
self.assertEqual(
AwardHelper.parse_award_type("Outstanding Cart Award"),
AwardType.OUTSTANDING_CART)
self.assertEqual(
AwardHelper.parse_award_type(
"Wayne State University Aim Higher Award"),
AwardType.WSU_AIM_HIGHER)
self.assertEqual(
AwardHelper.parse_award_type(
"Delphi \"Driving Tommorow's Technology\" Award"),
AwardType.DRIVING_TOMORROWS_TECHNOLOGY)
self.assertEqual(
AwardHelper.parse_award_type("Delphi Drive Tommorows Technology"),
AwardType.DRIVING_TOMORROWS_TECHNOLOGY)
self.assertEqual(
AwardHelper.parse_award_type(
"Kleiner, Perkins, Caufield and Byers"),
AwardType.ENTREPRENEURSHIP)
self.assertEqual(
AwardHelper.parse_award_type("Leadership in Control Award"),
AwardType.LEADERSHIP_IN_CONTROL)
self.assertEqual(AwardHelper.parse_award_type("#1 Seed"),
AwardType.NUM_1_SEED)
self.assertEqual(AwardHelper.parse_award_type("Incredible Play Award"),
AwardType.INCREDIBLE_PLAY)
self.assertEqual(
AwardHelper.parse_award_type("People's Choice Animation Award"),
AwardType.PEOPLES_CHOICE_ANIMATION)
self.assertEqual(
AwardHelper.parse_award_type(
"Autodesk Award for Visualization - Grand Prize"),
AwardType.VISUALIZATION)
self.assertEqual(
AwardHelper.parse_award_type(
"Autodesk Award for Visualization - Rising Star"),
AwardType.VISUALIZATION_RISING_STAR)
self.assertEqual(
AwardHelper.parse_award_type("Some Random Award Winner"), None)
self.assertEqual(AwardHelper.parse_award_type("Random Champion"), None)
self.assertEqual(AwardHelper.parse_award_type("An Award"), None)
# Make sure all old regional awards have matching types
with open('test_data/pre_2002_regional_awards.csv', 'r') as f:
csv_data = list(
csv.reader(StringIO.StringIO(f.read()),
delimiter=',',
skipinitialspace=True))
for award in csv_data:
self.assertNotEqual(AwardHelper.parse_award_type(award[2]),
None)
# Make sure all old regional awards have matching types
with open('test_data/pre_2007_cmp_awards.csv', 'r') as f:
csv_data = list(
csv.reader(StringIO.StringIO(f.read()),
delimiter=',',
skipinitialspace=True))
for award in csv_data:
self.assertNotEqual(AwardHelper.parse_award_type(award[2]),
None)
# test 2015 award names
with open('test_data/fms_api/2015_award_types.json', 'r') as f:
for award in json.loads(f.read()):
print award['description']
self.assertNotEqual(
AwardHelper.parse_award_type(award['description']), None)
def render_team_details(cls, handler, team, year, is_canonical):
media_key_futures = Media.query(Media.references == team.key,
Media.year == year).fetch_async(
500, keys_only=True)
events_sorted, matches_by_event_key, awards_by_event_key, valid_years = TeamDetailsDataFetcher.fetch(
team, year, return_valid_years=True)
if not events_sorted:
return None
media_futures = ndb.get_multi_async(media_key_futures.get_result())
participation = []
year_wlt_list = []
year_match_avg_list = []
current_event = None
matches_upcoming = None
short_cache = False
for event in events_sorted:
event_matches = matches_by_event_key.get(event.key, [])
event_awards = AwardHelper.organizeAwards(
awards_by_event_key.get(event.key, []))
matches_organized = MatchHelper.organizeMatches(event_matches)
if event.now:
current_event = event
matches_upcoming = MatchHelper.upcomingMatches(event_matches)
if event.within_a_day:
short_cache = True
if year == 2015:
display_wlt = None
match_avg = EventHelper.calculateTeamAvgScoreFromMatches(
team.key_name, event_matches)
year_match_avg_list.append(match_avg)
qual_avg, elim_avg, _, _ = match_avg
else:
qual_avg = None
elim_avg = None
wlt = EventHelper.calculateTeamWLTFromMatches(
team.key_name, event_matches)
year_wlt_list.append(wlt)
if wlt["win"] + wlt["loss"] + wlt["tie"] == 0:
display_wlt = None
else:
display_wlt = wlt
team_rank = None
if event.rankings:
for element in event.rankings:
if str(element[1]) == str(team.team_number):
team_rank = element[0]
break
participation.append({
'event': event,
'matches': matches_organized,
'wlt': display_wlt,
'qual_avg': qual_avg,
'elim_avg': elim_avg,
'rank': team_rank,
'awards': event_awards
})
if year == 2015:
year_wlt = None
year_qual_scores = []
year_elim_scores = []
for _, _, event_qual_scores, event_elim_scores in year_match_avg_list:
year_qual_scores += event_qual_scores
year_elim_scores += event_elim_scores
year_qual_avg = float(sum(year_qual_scores)) / len(
year_qual_scores) if year_qual_scores != [] else None
year_elim_avg = float(sum(year_elim_scores)) / len(
year_elim_scores) if year_elim_scores != [] else None
else:
year_qual_avg = None
year_elim_avg = None
year_wlt = {"win": 0, "loss": 0, "tie": 0}
for wlt in year_wlt_list:
year_wlt["win"] += wlt["win"]
year_wlt["loss"] += wlt["loss"]
year_wlt["tie"] += wlt["tie"]
if year_wlt["win"] + year_wlt["loss"] + year_wlt["tie"] == 0:
year_wlt = None
medias_by_slugname = MediaHelper.group_by_slugname(
[media_future.get_result() for media_future in media_futures])
handler.template_values.update({
"is_canonical": is_canonical,
"team": team,
"participation": participation,
"year": year,
"years": valid_years,
"year_wlt": year_wlt,
"year_qual_avg": year_qual_avg,
"year_elim_avg": year_elim_avg,
"current_event": current_event,
"matches_upcoming": matches_upcoming,
"medias_by_slugname": medias_by_slugname
})
if short_cache:
handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__),
'../templates/team_details.html')
return template.render(path, handler.template_values)
def parse(self, html):
"""
Parse the awards from USFIRST.
"""
html = html.decode(
'utf-8', 'ignore') # Clean html before feeding itno BeautifulSoup
soup = BeautifulSoup(html, convertEntities=BeautifulSoup.HTML_ENTITIES)
table = soup.findAll('table')[6]
awards_by_type = {}
for tr in table.findAll('tr')[3:]:
tds = tr.findAll('td')
name_str = unicode(self._recurseUntilString(tds[0]))
award_type_enum = AwardHelper.parse_award_type(name_str)
if award_type_enum is None:
continue
team_number = None
try:
team_number = self._recurseUntilString(tds[1])
except AttributeError:
team_number = None
if team_number and team_number.isdigit():
team_number = int(team_number)
else:
team_number = None
awardee = None
if award_type_enum in AwardType.INDIVIDUAL_AWARDS:
try:
awardee_str = self._recurseUntilString(tds[2])
if awardee_str:
awardee = unicode(sanitize(awardee_str))
except TypeError:
awardee = None
if not awardee:
# Turns '' into None
awardee = None
# an award must have either an awardee or a team_number
if awardee is None and team_number is None:
continue
recipient_json = json.dumps({
'team_number': team_number,
'awardee': awardee,
})
if award_type_enum in awards_by_type:
if team_number is not None:
awards_by_type[award_type_enum]['team_number_list'].append(
team_number)
awards_by_type[award_type_enum]['recipient_json_list'].append(
recipient_json)
else:
awards_by_type[award_type_enum] = {
'name_str':
strip_number(name_str),
'award_type_enum':
award_type_enum,
'team_number_list':
[team_number] if team_number is not None else [],
'recipient_json_list': [recipient_json],
}
return awards_by_type.values(), False
def _render(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
medias_future = media_query.EventTeamsPreferredMediasQuery(event_key).fetch_async()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
# Organize medias by team
image_medias = MediaHelper.get_images([media for media in medias_future.get_result()])
team_medias = defaultdict(list)
for image_media in image_medias:
for reference in image_media.references:
team_medias[reference].append(image_media)
team_and_medias = []
for team in teams:
team_and_medias.append((team, team_medias.get(team.key, [])))
num_teams = len(team_and_medias)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = team_and_medias[:middle_value], team_and_medias[middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()] if (event.matchstats is not None and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.now:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = MatchHelper.generateBracket(matches, event.alliance_selections)
is_2015_playoff = EventHelper.is_2015_playoff(event_key)
if is_2015_playoff:
playoff_advancement = MatchHelper.generatePlayoffAdvancement2015(matches, event.alliance_selections)
for comp_level in ['qf', 'sf']:
if comp_level in bracket_table:
del bracket_table[comp_level]
else:
playoff_advancement = None
district_points_sorted = None
if event.district_points:
district_points_sorted = sorted(event.district_points['points'].items(), key=lambda (team, points): -points['total'])
event_insights = EventInsightsHelper.calculate_event_insights(cleaned_matches, event.year)
event_insights_template = None
if event_insights:
event_insights_template = 'event_partials/event_insights_{}.html'.format(event.year)
# rankings processing for ranking score per match
full_rankings = event.rankings
rankings_enhanced = event.rankings_enhanced
if rankings_enhanced is not None:
rp_index = RankingIndexes.CUMULATIVE_RANKING_SCORE[event.year]
matches_index = RankingIndexes.MATCHES_PLAYED[event.year]
ranking_criterion_name = full_rankings[0][rp_index]
full_rankings[0].append(ranking_criterion_name + "/Match*")
for row in full_rankings[1:]:
team = row[1]
if rankings_enhanced["ranking_score_per_match"] is not None:
rp_per_match = rankings_enhanced['ranking_score_per_match'][team]
row.append(rp_per_match)
if rankings_enhanced["match_offset"] is not None:
match_offset = rankings_enhanced["match_offset"][team]
if match_offset != 0:
row[matches_index] = "{} ({})".format(row[matches_index], match_offset)
self.template_values.update({
"event": event,
"district_name": DistrictType.type_names.get(event.event_district_enum, None),
"district_abbrev": DistrictType.type_abbrevs.get(event.event_district_enum, None),
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
"playoff_advancement": playoff_advancement,
"district_points_sorted": district_points_sorted,
"is_2015_playoff": is_2015_playoff,
"event_insights_qual": event_insights['qual'] if event_insights else None,
"event_insights_playoff": event_insights['playoff'] if event_insights else None,
"event_insights_template": event_insights_template,
})
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('event_details.html', self.template_values)
def get(self):
self._require_registration()
user = self.user_bundle.account.key
now = datetime.datetime.now()
year = self.request.get('year')
if year and year.isdigit():
year = int(year)
else:
year = now.year
team_favorites_future = Favorite.query(
Favorite.model_type == ModelType.TEAM,
ancestor=user).fetch_async()
favorite_team_keys = map(lambda f: ndb.Key(Team, f.model_key),
team_favorites_future.get_result())
favorite_teams_future = ndb.get_multi_async(favorite_team_keys)
favorite_teams = [
team_future.get_result() for team_future in favorite_teams_future
]
favorite_teams_events_futures = []
favorite_teams_awards_futures = {}
for team in favorite_teams:
favorite_teams_events_futures.append(
TeamYearEventsQuery(team.key_name, year).fetch_async())
favorite_teams_awards_futures[team.key.id()] = TeamYearAwardsQuery(
team.key_name, year).fetch_async()
past_events_by_event = {}
live_events_by_event = {}
future_events_by_event = {}
favorite_event_team_keys = []
for team, events_future in zip(favorite_teams,
favorite_teams_events_futures):
events = events_future.get_result()
if not events:
continue
EventHelper.sort_events(events) # Sort by date
for event in events:
favorite_event_team_keys.append(
ndb.Key(EventTeam, '{}_{}'.format(event.key.id(),
team.key.id())))
if event.within_a_day:
if event.key_name not in live_events_by_event:
live_events_by_event[event.key_name] = (event, [])
live_events_by_event[event.key_name][1].append(team)
elif event.start_date < now:
if event.key_name not in past_events_by_event:
past_events_by_event[event.key_name] = (event, [])
past_events_by_event[event.key_name][1].append(team)
else:
if event.key_name not in future_events_by_event:
future_events_by_event[event.key_name] = (event, [])
future_events_by_event[event.key_name][1].append(team)
event_team_awards = defaultdict(lambda: defaultdict(list))
for team_key, awards_future in favorite_teams_awards_futures.items():
for award in awards_future.get_result():
event_team_awards[award.event.id()][team_key].append(award)
ndb.get_multi(favorite_event_team_keys) # Warms context cache
past_events_with_teams = []
for event, teams in past_events_by_event.itervalues():
teams_and_statuses = []
for team in teams:
event_team = EventTeam.get_by_id('{}_{}'.format(
event.key.id(),
team.key.id())) # Should be in context cache
status_str = {
'alliance':
EventTeamStatusHelper.
generate_team_at_event_alliance_status_string(
team.key.id(), event_team.status),
'playoff':
EventTeamStatusHelper.
generate_team_at_event_playoff_status_string(
team.key.id(), event_team.status),
}
teams_and_statuses.append(
(team, event_team.status, status_str,
AwardHelper.organizeAwards(
event_team_awards[event.key.id()][team.key.id()])))
teams_and_statuses.sort(key=lambda x: x[0].team_number)
past_events_with_teams.append((event, teams_and_statuses))
past_events_with_teams.sort(key=lambda x: x[0].name)
past_events_with_teams.sort(
key=lambda x: EventHelper.distantFutureIfNoStartDate(x[0]))
past_events_with_teams.sort(
key=lambda x: EventHelper.distantFutureIfNoEndDate(x[0]))
live_events_with_teams = []
for event, teams in live_events_by_event.itervalues():
teams_and_statuses = []
for team in teams:
event_team = EventTeam.get_by_id('{}_{}'.format(
event.key.id(),
team.key.id())) # Should be in context cache
status_str = {
'alliance':
EventTeamStatusHelper.
generate_team_at_event_alliance_status_string(
team.key.id(), event_team.status),
'playoff':
EventTeamStatusHelper.
generate_team_at_event_playoff_status_string(
team.key.id(), event_team.status),
}
teams_and_statuses.append(
(team, event_team.status, status_str))
teams_and_statuses.sort(key=lambda x: x[0].team_number)
live_events_with_teams.append((event, teams_and_statuses))
live_events_with_teams.sort(key=lambda x: x[0].name)
live_events_with_teams.sort(
key=lambda x: EventHelper.distantFutureIfNoStartDate(x[0]))
live_events_with_teams.sort(
key=lambda x: EventHelper.distantFutureIfNoEndDate(x[0]))
future_events_with_teams = []
for event, teams in future_events_by_event.itervalues():
teams.sort(key=lambda t: t.team_number)
future_events_with_teams.append((event, teams))
future_events_with_teams.sort(key=lambda x: x[0].name)
future_events_with_teams.sort(
key=lambda x: EventHelper.distantFutureIfNoStartDate(x[0]))
future_events_with_teams.sort(
key=lambda x: EventHelper.distantFutureIfNoEndDate(x[0]))
self.template_values.update({
'year':
year,
'past_only':
year < now.year,
'past_events_with_teams':
past_events_with_teams,
'live_events_with_teams':
live_events_with_teams,
'future_events_with_teams':
future_events_with_teams,
})
path = os.path.join(os.path.dirname(__file__),
'../templates/mytba_live.html')
self.response.out.write(template.render(path, self.template_values))
def parse(self, html):
"""
Parse the awards from USFIRST.
"""
html = html.decode('utf-8', 'ignore') # Clean html before feeding itno BeautifulSoup
soup = BeautifulSoup(html, convertEntities=BeautifulSoup.HTML_ENTITIES)
# Bad formatting on some pages makes this necessary
trs1 = soup.findAll('tr', {'style': 'background-color:#D2D2FF;'})
trs2 = soup.findAll('tr', {'style': 'background-color:#FFFFFF;'})
trs = trs1 + trs2
awards_by_type = {}
for tr in trs:
tds = tr.findAll('td')
name_str = unicode(self._recurseUntilString(tds[0]))
award_type_enum = AwardHelper.parse_award_type(name_str)
if award_type_enum is None:
continue
team_number = None
try:
team_number = self._recurseUntilString(tds[1])
except AttributeError:
team_number = None
if team_number and team_number.isdigit():
team_number = int(team_number)
else:
team_number = None
awardee = None
if award_type_enum in AwardType.INDIVIDUAL_AWARDS:
try:
awardee_str = self._recurseUntilString(tds[2])
if awardee_str:
awardee = unicode(sanitize(awardee_str))
except TypeError:
awardee = None
if not awardee:
# Turns '' into None
awardee = None
# an award must have either an awardee or a team_number
if awardee is None and team_number is None:
continue
recipient_json = json.dumps({
'team_number': team_number,
'awardee': awardee,
})
if award_type_enum in awards_by_type:
if team_number is not None:
awards_by_type[award_type_enum]['team_number_list'].append(team_number)
awards_by_type[award_type_enum]['recipient_json_list'].append(recipient_json)
else:
awards_by_type[award_type_enum] = {
'name_str': strip_number(name_str),
'award_type_enum': award_type_enum,
'team_number_list': [team_number] if team_number is not None else [],
'recipient_json_list': [recipient_json],
}
return awards_by_type.values(), False
def _render(self, event_key):
event = EventQuery(event_key).fetch()
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
event.prep_details()
medias_future = media_query.EventTeamsPreferredMediasQuery(event_key).fetch_async()
district_future = DistrictQuery(event.district_key.id()).fetch_async() if event.district_key else None
event_medias_future = media_query.EventMediasQuery(event_key).fetch_async()
status_sitevar_future = Sitevar.get_by_id_async('apistatus.down_events')
event_divisions_future = None
event_codivisions_future = None
parent_event_future = None
if event.divisions:
event_divisions_future = ndb.get_multi_async(event.divisions)
elif event.parent_event:
parent_event_future = event.parent_event.get_async()
event_codivisions_future = EventDivisionsQuery(event.parent_event.id()).fetch_async()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches, event)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
# Organize medias by team
image_medias = MediaHelper.get_images([media for media in medias_future.get_result()])
team_medias = defaultdict(list)
for image_media in image_medias:
for reference in image_media.references:
team_medias[reference].append(image_media)
team_and_medias = []
for team in teams:
team_and_medias.append((team, team_medias.get(team.key, [])))
num_teams = len(team_and_medias)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = team_and_medias[:middle_value], team_and_medias[middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()] if (event.matchstats is not None and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.now:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = MatchHelper.generateBracket(matches, event, event.alliance_selections)
playoff_advancement = None
playoff_template = None
double_elim_matches = None
if EventHelper.is_2015_playoff(event_key):
playoff_advancement = MatchHelper.generatePlayoffAdvancement2015(matches, event.alliance_selections)
playoff_template = 'playoff_table'
for comp_level in ['qf', 'sf']:
if comp_level in bracket_table:
del bracket_table[comp_level]
elif event.playoff_type == PlayoffType.ROUND_ROBIN_6_TEAM:
playoff_advancement = MatchHelper.generatePlayoffAdvancementRoundRobin(matches, event.year, event.alliance_selections)
playoff_template = 'playoff_round_robin_6_team'
comp_levels = bracket_table.keys()
for comp_level in comp_levels:
if comp_level != 'f':
del bracket_table[comp_level]
elif event.playoff_type == PlayoffType.BO3_FINALS or event.playoff_type == PlayoffType.BO5_FINALS:
comp_levels = bracket_table.keys()
for comp_level in comp_levels:
if comp_level != 'f':
del bracket_table[comp_level]
elif event.playoff_type == PlayoffType.DOUBLE_ELIM_8_TEAM:
double_elim_matches = MatchHelper.organizeDoubleElimMatches(matches)
district_points_sorted = None
if event.district_key and event.district_points:
district_points_sorted = sorted(event.district_points['points'].items(), key=lambda (team, points): -points['total'])
event_insights = event.details.insights if event.details else None
event_insights_template = None
if event_insights:
event_insights_template = 'event_partials/event_insights_{}.html'.format(event.year)
district = district_future.get_result() if district_future else None
event_divisions = None
if event_divisions_future:
event_divisions = [e.get_result() for e in event_divisions_future]
elif event_codivisions_future:
event_divisions = event_codivisions_future.get_result()
medias_by_slugname = MediaHelper.group_by_slugname([media for media in event_medias_future.get_result()])
has_time_predictions = matches_upcoming and any(match.predicted_time for match in matches_upcoming)
status_sitevar = status_sitevar_future.get_result()
self.template_values.update({
"event": event,
"event_down": status_sitevar and event_key in status_sitevar.contents,
"district_name": district.display_name if district else None,
"district_abbrev": district.abbreviation if district else None,
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
'has_time_predictions': has_time_predictions,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
"playoff_advancement": playoff_advancement,
"playoff_template": playoff_template,
"district_points_sorted": district_points_sorted,
"event_insights_qual": event_insights['qual'] if event_insights else None,
"event_insights_playoff": event_insights['playoff'] if event_insights else None,
"event_insights_template": event_insights_template,
"medias_by_slugname": medias_by_slugname,
"event_divisions": event_divisions,
'parent_event': parent_event_future.get_result() if parent_event_future else None,
'double_elim_matches': double_elim_matches,
'double_elim_playoff_types': PlayoffType.DOUBLE_ELIM_TYPES,
})
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('event_details.html', self.template_values)
def _render(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
num_teams = len(teams)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = teams[:middle_value], teams[middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()
] if (event.matchstats is not None
and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.now:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = MatchHelper.generateBracket(matches,
event.alliance_selections)
is_2015_playoff = EventHelper.is_2015_playoff(event_key)
if is_2015_playoff:
playoff_advancement = MatchHelper.generatePlayoffAdvancement2015(
matches, event.alliance_selections)
for comp_level in ['qf', 'sf']:
if comp_level in bracket_table:
del bracket_table[comp_level]
else:
playoff_advancement = None
district_points_sorted = None
if event.district_points:
district_points_sorted = sorted(
event.district_points['points'].items(),
key=lambda (team, points): -points['total'])
event_insights = EventInsightsHelper.calculate_event_insights(
cleaned_matches, event.year)
self.template_values.update({
"event": event,
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
"playoff_advancement": playoff_advancement,
"district_points_sorted": district_points_sorted,
"is_2015_playoff": is_2015_playoff,
"event_insights": event_insights
})
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('event_details.html', self.template_values)
def _build_dict(self):
data = {}
data['message_type'] = NotificationType.type_names[self._type]
data['message_data'] = {}
data['message_data']['event_name'] = self.event.name
data['message_data']['event_key'] = self.event.key_name
data['message_data']['awards'] = [ModelToDict.awardConverter(award) for award in AwardHelper.organizeAwards(self.event.awards)]
return data
def test_build(self):
expected = {}
expected['notification_type'] = NotificationType.type_names[NotificationType.AWARDS]
expected['message_data'] = {}
expected['message_data']['event_name'] = self.event.name
expected['message_data']['event_key'] = self.event.key_name
expected['message_data']['awards'] = [ModelToDict.awardConverter(award) for award in AwardHelper.organizeAwards(self.event.awards)]
data = self.notification._build_dict()
self.assertEqual(expected, data)
def _render(self, team_number, year=None, explicit_year=False):
team = Team.get_by_id("frc" + team_number)
if not team:
return self.redirect("/error/404")
event_teams = EventTeam.query(EventTeam.team == team.key).fetch(1000)
event_keys = [event_team.event for event_team in event_teams if event_team.year == year]
events = ndb.get_multi(event_keys)
for event in events:
if not event.start_date:
event.start_date = datetime.datetime(year, 12, 31) #unknown goes last
events = sorted(events, key=lambda event: event.start_date)
years = sorted(set([a.year for a in event_teams if a.year != None]))
awards_future = Award.query(Award.year == year, Award.team == team.key).fetch_async(500)
for e in events:
e.team_matches_future = Match.query(Match.event == e.key, Match.team_key_names == team.key_name).fetch_async(500)
# Return an array of event names and a list of matches from that event that the
# team was a participant in.
participation = list()
year_wlt_list = list()
current_event = None
matches_upcoming = None
short_cache = False
for e in events:
awards = AwardHelper.organizeAwards([award for award in awards_future.get_result() if award.event == e.key])
matches = e.team_matches_future.get_result()
matches_organized = MatchHelper.organizeMatches(matches)
if e.now:
current_event = e
matches_upcoming = MatchHelper.upcomingMatches(matches)
if event.within_a_day:
short_cache = True
wlt = EventHelper.calculateTeamWLTFromMatches(team.key_name, matches)
year_wlt_list.append(wlt)
if wlt["win"] + wlt["loss"] + wlt["tie"] == 0:
display_wlt = None
else:
display_wlt = wlt
team_rank = None
if e.rankings:
for element in e.rankings:
if element[1] == team_number:
team_rank = element[0]
break
participation.append({ 'event' : e,
'matches' : matches_organized,
'wlt': display_wlt,
'rank': team_rank,
'awards': awards })
year_wlt = {"win": 0, "loss": 0, "tie": 0}
for wlt in year_wlt_list:
year_wlt["win"] += wlt["win"]
year_wlt["loss"] += wlt["loss"]
year_wlt["tie"] += wlt["tie"]
if year_wlt["win"] + year_wlt["loss"] + year_wlt["tie"] == 0:
year_wlt = None
template_values = { "explicit_year": explicit_year,
"team": team,
"participation": participation,
"year": year,
"years": years,
"year_wlt": year_wlt,
"current_event": current_event,
"matches_upcoming": matches_upcoming }
if short_cache:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__), '../templates/team_details.html')
return template.render(path, template_values)
def render_team_details(cls, handler, team, year, is_canonical):
media_future = media_query.TeamYearMediaQuery(team.key.id(), year).fetch_async()
social_media_future = media_query.TeamSocialMediaQuery(team.key.id()).fetch_async()
robot_future = Robot.get_by_id_async('{}_{}'.format(team.key.id(), year))
team_districts_future = team_query.TeamDistrictsQuery(team.key.id()).fetch_async()
participation_future = team_query.TeamParticipationQuery(team.key.id()).fetch_async()
events_sorted, matches_by_event_key, awards_by_event_key, valid_years = TeamDetailsDataFetcher.fetch(team, year, return_valid_years=True)
if not events_sorted:
return None
participation = []
season_wlt_list = []
offseason_wlt_list = []
year_match_avg_list = []
current_event = None
matches_upcoming = None
short_cache = False
for event in events_sorted:
event_matches = matches_by_event_key.get(event.key, [])
event_awards = AwardHelper.organizeAwards(awards_by_event_key.get(event.key, []))
matches_organized = MatchHelper.organizeMatches(event_matches)
if event.now:
current_event = event
matches_upcoming = MatchHelper.upcomingMatches(event_matches)
if event.within_a_day:
short_cache = True
if year == 2015:
display_wlt = None
match_avg = EventHelper.calculateTeamAvgScoreFromMatches(team.key_name, event_matches)
year_match_avg_list.append(match_avg)
qual_avg, elim_avg, _, _ = match_avg
else:
qual_avg = None
elim_avg = None
wlt = EventHelper.calculateTeamWLTFromMatches(team.key_name, event_matches)
if event.event_type_enum in EventType.SEASON_EVENT_TYPES:
season_wlt_list.append(wlt)
else:
offseason_wlt_list.append(wlt)
if wlt["win"] + wlt["loss"] + wlt["tie"] == 0:
display_wlt = None
else:
display_wlt = wlt
team_rank = None
if event.rankings:
for element in event.rankings:
if str(element[1]) == str(team.team_number):
team_rank = element[0]
break
participation.append({'event': event,
'matches': matches_organized,
'wlt': display_wlt,
'qual_avg': qual_avg,
'elim_avg': elim_avg,
'rank': team_rank,
'awards': event_awards})
season_wlt = None
offseason_wlt = None
if year == 2015:
year_wlt = None
year_qual_scores = []
year_elim_scores = []
for _, _, event_qual_scores, event_elim_scores in year_match_avg_list:
year_qual_scores += event_qual_scores
year_elim_scores += event_elim_scores
year_qual_avg = float(sum(year_qual_scores)) / len(year_qual_scores) if year_qual_scores != [] else None
year_elim_avg = float(sum(year_elim_scores)) / len(year_elim_scores) if year_elim_scores != [] else None
else:
year_qual_avg = None
year_elim_avg = None
season_wlt = {"win": 0, "loss": 0, "tie": 0}
offseason_wlt = {"win": 0, "loss": 0, "tie": 0}
for wlt in season_wlt_list:
season_wlt["win"] += wlt["win"]
season_wlt["loss"] += wlt["loss"]
season_wlt["tie"] += wlt["tie"]
if season_wlt["win"] + season_wlt["loss"] + season_wlt["tie"] == 0:
season_wlt = None
for wlt in offseason_wlt_list:
offseason_wlt["win"] += wlt["win"]
offseason_wlt["loss"] += wlt["loss"]
offseason_wlt["tie"] += wlt["tie"]
if offseason_wlt["win"] + offseason_wlt["loss"] + offseason_wlt["tie"] == 0:
offseason_wlt = None
medias_by_slugname = MediaHelper.group_by_slugname([media for media in media_future.get_result()])
image_medias = MediaHelper.get_images(media_future.get_result())
social_medias = sorted(social_media_future.get_result(), key=MediaHelper.social_media_sorter)
preferred_image_medias = filter(lambda x: team.key in x.preferred_references, image_medias)
district_name = None
district_abbrev = None
team_districts = team_districts_future.get_result()
for district in team_districts:
if district.year == year:
district_abbrev = district.abbreviation
district_name = district.display_name
last_competed = None
participation_years = participation_future.get_result()
if len(participation_years) > 0:
last_competed = max(participation_years)
current_year = datetime.date.today().year
handler.template_values.update({
"is_canonical": is_canonical,
"team": team,
"participation": participation,
"year": year,
"years": valid_years,
"season_wlt": season_wlt,
"offseason_wlt": offseason_wlt,
"year_qual_avg": year_qual_avg,
"year_elim_avg": year_elim_avg,
"current_event": current_event,
"matches_upcoming": matches_upcoming,
"medias_by_slugname": medias_by_slugname,
"social_medias": social_medias,
"image_medias": image_medias,
"preferred_image_medias": preferred_image_medias,
"robot": robot_future.get_result(),
"district_name": district_name,
"district_abbrev": district_abbrev,
"last_competed": last_competed,
"current_year": current_year,
})
if short_cache:
handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('team_details.html', handler.template_values)
def _render(self, team_number, year=None, explicit_year=False):
team = Team.get_by_id("frc" + team_number)
if not team:
self.abort(404)
events_sorted, matches_by_event_key, awards_by_event_key, valid_years = TeamDetailsDataFetcher.fetch(team, year, return_valid_years=True)
if not events_sorted:
self.abort(404)
participation = []
year_wlt_list = []
current_event = None
matches_upcoming = None
short_cache = False
for event in events_sorted:
event_matches = matches_by_event_key.get(event.key, [])
event_awards = AwardHelper.organizeAwards(awards_by_event_key.get(event.key, []))
matches_organized = MatchHelper.organizeMatches(event_matches)
if event.now:
current_event = event
matches_upcoming = MatchHelper.upcomingMatches(event_matches)
if event.within_a_day:
short_cache = True
wlt = EventHelper.calculateTeamWLTFromMatches(team.key_name, event_matches)
year_wlt_list.append(wlt)
if wlt["win"] + wlt["loss"] + wlt["tie"] == 0:
display_wlt = None
else:
display_wlt = wlt
team_rank = None
if event.rankings:
for element in event.rankings:
if element[1] == team_number:
team_rank = element[0]
break
participation.append({'event': event,
'matches': matches_organized,
'wlt': display_wlt,
'rank': team_rank,
'awards': event_awards})
year_wlt = {"win": 0, "loss": 0, "tie": 0}
for wlt in year_wlt_list:
year_wlt["win"] += wlt["win"]
year_wlt["loss"] += wlt["loss"]
year_wlt["tie"] += wlt["tie"]
if year_wlt["win"] + year_wlt["loss"] + year_wlt["tie"] == 0:
year_wlt = None
template_values = {"explicit_year": explicit_year,
"team": team,
"participation": participation,
"year": year,
"years": valid_years,
"year_wlt": year_wlt,
"current_event": current_event,
"matches_upcoming": matches_upcoming}
if short_cache:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__), '../templates/team_details.html')
return template.render(path, template_values)
def _render(self, event_key):
event = EventQuery(event_key).fetch()
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
event.prep_details()
medias_future = media_query.EventTeamsPreferredMediasQuery(event_key).fetch_async()
district_future = DistrictQuery(event.district_key.id()).fetch_async() if event.district_key else None
event_medias_future = media_query.EventMediasQuery(event_key).fetch_async()
status_sitevar_future = Sitevar.get_by_id_async('apistatus.down_events')
event_divisions_future = None
event_codivisions_future = None
parent_event_future = None
if event.divisions:
event_divisions_future = ndb.get_multi_async(event.divisions)
elif event.parent_event:
parent_event_future = event.parent_event.get_async()
event_codivisions_future = EventDivisionsQuery(event.parent_event.id()).fetch_async()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches, event)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
# Organize medias by team
image_medias = MediaHelper.get_images([media for media in medias_future.get_result()])
team_medias = defaultdict(list)
for image_media in image_medias:
for reference in image_media.references:
team_medias[reference].append(image_media)
team_and_medias = []
for team in teams:
team_and_medias.append((team, team_medias.get(team.key, [])))
num_teams = len(team_and_medias)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = team_and_medias[:middle_value], team_and_medias[middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()] if (event.matchstats is not None and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.now:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = MatchHelper.generateBracket(matches, event, event.alliance_selections)
playoff_advancement = None
playoff_template = None
double_elim_matches = None
if EventHelper.is_2015_playoff(event_key):
playoff_advancement = MatchHelper.generatePlayoffAdvancement2015(matches, event.alliance_selections)
playoff_template = 'playoff_table'
for comp_level in ['qf', 'sf']:
if comp_level in bracket_table:
del bracket_table[comp_level]
elif event.playoff_type == PlayoffType.ROUND_ROBIN_6_TEAM:
playoff_advancement = MatchHelper.generatePlayoffAdvancementRoundRobin(matches, event.year, event.alliance_selections)
playoff_template = 'playoff_round_robin_6_team'
comp_levels = bracket_table.keys()
for comp_level in comp_levels:
if comp_level != 'f':
del bracket_table[comp_level]
elif event.playoff_type == PlayoffType.BO3_FINALS or event.playoff_type == PlayoffType.BO5_FINALS:
comp_levels = bracket_table.keys()
for comp_level in comp_levels:
if comp_level != 'f':
del bracket_table[comp_level]
elif event.playoff_type == PlayoffType.DOUBLE_ELIM_8_TEAM:
double_elim_matches = MatchHelper.organizeDoubleElimMatches(matches)
district_points_sorted = None
if event.district_key and event.district_points:
district_points_sorted = sorted(event.district_points['points'].items(), key=lambda (team, points): -points['total'])
event_insights = event.details.insights if event.details else None
event_insights_template = None
if event_insights:
event_insights_template = 'event_partials/event_insights_{}.html'.format(event.year)
district = district_future.get_result() if district_future else None
event_divisions = None
if event_divisions_future:
event_divisions = [e.get_result() for e in event_divisions_future]
elif event_codivisions_future:
event_divisions = event_codivisions_future.get_result()
medias_by_slugname = MediaHelper.group_by_slugname([media for media in event_medias_future.get_result()])
has_time_predictions = matches_upcoming and any(match.predicted_time for match in matches_upcoming)
status_sitevar = status_sitevar_future.get_result()
self.template_values.update({
"event": event,
"event_down": status_sitevar and event_key in status_sitevar.contents,
"district_name": district.display_name if district else None,
"district_abbrev": district.abbreviation if district else None,
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
'has_time_predictions': has_time_predictions,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
"playoff_advancement": playoff_advancement,
"playoff_template": playoff_template,
"district_points_sorted": district_points_sorted,
"event_insights_qual": event_insights['qual'] if event_insights else None,
"event_insights_playoff": event_insights['playoff'] if event_insights else None,
"event_insights_template": event_insights_template,
"medias_by_slugname": medias_by_slugname,
"event_divisions": event_divisions,
'parent_event': parent_event_future.get_result() if parent_event_future else None,
'double_elim_matches': double_elim_matches,
'double_elim_playoff_types': PlayoffType.DOUBLE_ELIM_TYPES,
})
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('event_details.html', self.template_values)
def parse(self, html):
"""
Parse the awards from USFIRST.
"""
html = html.decode('utf-8', 'ignore') # Clean html before feeding itno BeautifulSoup
soup = BeautifulSoup(html)
table = soup.findAll('table')[0]
awards_by_type = {}
for tr in table.findAll('tr')[2:]:
tds = tr.findAll('td')
if tds == []:
continue
name_str = unicode(self._recurseUntilString(tds[0]))
award_type_enum = AwardHelper.parse_award_type(name_str)
if award_type_enum is None:
continue
team_number = None
try:
team_number = self._recurseUntilString(tds[1])
except AttributeError:
team_number = None
if team_number and team_number.isdigit():
team_number = int(team_number)
else:
team_number = None
awardee = None
if award_type_enum in AwardType.INDIVIDUAL_AWARDS:
try:
awardee_str = self._recurseUntilString(tds[2])
if awardee_str:
awardee = unicode(sanitize(awardee_str))
except TypeError:
awardee = None
if not awardee:
# Turns '' into None
awardee = None
# an award must have either an awardee or a team_number
if awardee is None and team_number is None:
continue
recipient_json = json.dumps({
'team_number': team_number,
'awardee': awardee,
})
if award_type_enum in awards_by_type:
if team_number is not None:
awards_by_type[award_type_enum]['team_number_list'].append(team_number)
awards_by_type[award_type_enum]['recipient_json_list'].append(recipient_json)
else:
awards_by_type[award_type_enum] = {
'name_str': strip_number(name_str),
'award_type_enum': award_type_enum,
'team_number_list': [team_number] if team_number is not None else [],
'recipient_json_list': [recipient_json],
}
return awards_by_type.values(), False
def get(self):
self._require_registration()
user = self.user_bundle.account.key
now = datetime.datetime.now()
year = self.request.get('year')
if year and year.isdigit():
year = int(year)
else:
year = now.year
team_favorites_future = Favorite.query(Favorite.model_type == ModelType.TEAM, ancestor=user).fetch_async()
favorite_team_keys = map(lambda f: ndb.Key(Team, f.model_key), team_favorites_future.get_result())
favorite_teams_future = ndb.get_multi_async(favorite_team_keys)
favorite_teams = [team_future.get_result() for team_future in favorite_teams_future]
favorite_teams_events_futures = []
favorite_teams_awards_futures = {}
for team in favorite_teams:
favorite_teams_events_futures.append(TeamYearEventsQuery(team.key_name, year).fetch_async())
favorite_teams_awards_futures[team.key.id()] = TeamYearAwardsQuery(team.key_name, year).fetch_async()
past_events_by_event = {}
live_events_by_event = {}
future_events_by_event = {}
favorite_event_team_keys = []
for team, events_future in zip(favorite_teams, favorite_teams_events_futures):
events = events_future.get_result()
if not events:
continue
EventHelper.sort_events(events) # Sort by date
for event in events:
favorite_event_team_keys.append(ndb.Key(EventTeam, '{}_{}'.format(event.key.id(), team.key.id())))
if event.within_a_day:
if event.key_name not in live_events_by_event:
live_events_by_event[event.key_name] = (event, [])
live_events_by_event[event.key_name][1].append(team)
elif event.start_date < now:
if event.key_name not in past_events_by_event:
past_events_by_event[event.key_name] = (event, [])
past_events_by_event[event.key_name][1].append(team)
else:
if event.key_name not in future_events_by_event:
future_events_by_event[event.key_name] = (event, [])
future_events_by_event[event.key_name][1].append(team)
event_team_awards = defaultdict(lambda: defaultdict(list))
for team_key, awards_future in favorite_teams_awards_futures.items():
for award in awards_future.get_result():
event_team_awards[award.event.id()][team_key].append(award)
ndb.get_multi(favorite_event_team_keys) # Warms context cache
past_events_with_teams = []
for event, teams in past_events_by_event.itervalues():
teams_and_statuses = []
for team in teams:
event_team = EventTeam.get_by_id('{}_{}'.format(event.key.id(), team.key.id())) # Should be in context cache
status_str = {
'alliance': EventTeamStatusHelper.generate_team_at_event_alliance_status_string(team.key.id(), event_team.status),
'playoff': EventTeamStatusHelper.generate_team_at_event_playoff_status_string(team.key.id(), event_team.status),
}
teams_and_statuses.append((
team,
event_team.status,
status_str,
AwardHelper.organizeAwards(event_team_awards[event.key.id()][team.key.id()])
))
teams_and_statuses.sort(key=lambda x: x[0].team_number)
past_events_with_teams.append((event, teams_and_statuses))
past_events_with_teams.sort(key=lambda x: x[0].name)
past_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoStartDate(x[0]))
past_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoEndDate(x[0]))
live_events_with_teams = []
for event, teams in live_events_by_event.itervalues():
teams_and_statuses = []
for team in teams:
event_team = EventTeam.get_by_id('{}_{}'.format(event.key.id(), team.key.id())) # Should be in context cache
status_str = {
'alliance': EventTeamStatusHelper.generate_team_at_event_alliance_status_string(team.key.id(), event_team.status),
'playoff': EventTeamStatusHelper.generate_team_at_event_playoff_status_string(team.key.id(), event_team.status),
}
teams_and_statuses.append((
team,
event_team.status,
status_str
))
teams_and_statuses.sort(key=lambda x: x[0].team_number)
live_events_with_teams.append((event, teams_and_statuses))
live_events_with_teams.sort(key=lambda x: x[0].name)
live_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoStartDate(x[0]))
live_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoEndDate(x[0]))
future_events_with_teams = []
for event, teams in future_events_by_event.itervalues():
teams.sort(key=lambda t: t.team_number)
future_events_with_teams.append((event, teams))
future_events_with_teams.sort(key=lambda x: x[0].name)
future_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoStartDate(x[0]))
future_events_with_teams.sort(key=lambda x: EventHelper.distantFutureIfNoEndDate(x[0]))
self.template_values.update({
'year': year,
'past_only': year < now.year,
'past_events_with_teams': past_events_with_teams,
'live_events_with_teams': live_events_with_teams,
'future_events_with_teams': future_events_with_teams,
})
path = os.path.join(os.path.dirname(__file__), '../templates/mytba_live.html')
self.response.out.write(template.render(path, self.template_values))
def _render(self, team_key, event_key):
awards = TeamEventAwardsQuery(self.team_key, self.event_key).fetch()
awards_dicts = [ModelToDict.awardConverter(award) for award in AwardHelper.organizeAwards(awards)]
return json.dumps(awards_dicts, ensure_ascii=True)
def render_team_details(cls, handler, team, year, is_canonical):
media_future = media_query.TeamYearMediaQuery(team.key.id(),
year).fetch_async()
robot_future = Robot.get_by_id_async('{}_{}'.format(
team.key.id(), year))
team_districts_future = team_query.TeamDistrictsQuery(
team.key.id()).fetch_async()
events_sorted, matches_by_event_key, awards_by_event_key, valid_years = TeamDetailsDataFetcher.fetch(
team, year, return_valid_years=True)
if not events_sorted:
return None
participation = []
year_wlt_list = []
year_match_avg_list = []
current_event = None
matches_upcoming = None
short_cache = False
for event in events_sorted:
event_matches = matches_by_event_key.get(event.key, [])
event_awards = AwardHelper.organizeAwards(
awards_by_event_key.get(event.key, []))
matches_organized = MatchHelper.organizeMatches(event_matches)
if event.now:
current_event = event
matches_upcoming = MatchHelper.upcomingMatches(event_matches)
if event.within_a_day:
short_cache = True
if year == 2015:
display_wlt = None
match_avg = EventHelper.calculateTeamAvgScoreFromMatches(
team.key_name, event_matches)
year_match_avg_list.append(match_avg)
qual_avg, elim_avg, _, _ = match_avg
else:
qual_avg = None
elim_avg = None
wlt = EventHelper.calculateTeamWLTFromMatches(
team.key_name, event_matches)
year_wlt_list.append(wlt)
if wlt["win"] + wlt["loss"] + wlt["tie"] == 0:
display_wlt = None
else:
display_wlt = wlt
team_rank = None
if event.rankings:
for element in event.rankings:
if str(element[1]) == str(team.team_number):
team_rank = element[0]
break
participation.append({
'event': event,
'matches': matches_organized,
'wlt': display_wlt,
'qual_avg': qual_avg,
'elim_avg': elim_avg,
'rank': team_rank,
'awards': event_awards
})
if year == 2015:
year_wlt = None
year_qual_scores = []
year_elim_scores = []
for _, _, event_qual_scores, event_elim_scores in year_match_avg_list:
year_qual_scores += event_qual_scores
year_elim_scores += event_elim_scores
year_qual_avg = float(sum(year_qual_scores)) / len(
year_qual_scores) if year_qual_scores != [] else None
year_elim_avg = float(sum(year_elim_scores)) / len(
year_elim_scores) if year_elim_scores != [] else None
else:
year_qual_avg = None
year_elim_avg = None
year_wlt = {"win": 0, "loss": 0, "tie": 0}
for wlt in year_wlt_list:
year_wlt["win"] += wlt["win"]
year_wlt["loss"] += wlt["loss"]
year_wlt["tie"] += wlt["tie"]
if year_wlt["win"] + year_wlt["loss"] + year_wlt["tie"] == 0:
year_wlt = None
medias_by_slugname = MediaHelper.group_by_slugname(
[media for media in media_future.get_result()])
image_medias = MediaHelper.get_images(
[media for media in media_future.get_result()])
district_name = None
district_abbrev = None
team_districts = team_districts_future.get_result()
if year in team_districts:
district_key = team_districts[year]
district_abbrev = district_key[4:]
district_type = DistrictType.abbrevs[district_abbrev]
district_name = DistrictType.type_names[district_type]
handler.template_values.update({
"is_canonical": is_canonical,
"team": team,
"participation": participation,
"year": year,
"years": valid_years,
"year_wlt": year_wlt,
"year_qual_avg": year_qual_avg,
"year_elim_avg": year_elim_avg,
"current_event": current_event,
"matches_upcoming": matches_upcoming,
"medias_by_slugname": medias_by_slugname,
"image_medias": image_medias,
"robot": robot_future.get_result(),
"district_name": district_name,
"district_abbrev": district_abbrev,
})
if short_cache:
handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('team_details.html',
handler.template_values)
def render_team_history(cls, handler, team, is_canonical):
hof_award_future = award_query.TeamEventTypeAwardsQuery(team.key.id(), EventType.CMP_FINALS, AwardType.CHAIRMANS).fetch_async()
hof_video_future = media_query.TeamTagMediasQuery(team.key.id(), MediaTag.CHAIRMANS_VIDEO).fetch_async()
hof_presentation_future = media_query.TeamTagMediasQuery(team.key.id(), MediaTag.CHAIRMANS_PRESENTATION).fetch_async()
hof_essay_future = media_query.TeamTagMediasQuery(team.key.id(), MediaTag.CHAIRMANS_ESSAY).fetch_async()
award_futures = award_query.TeamAwardsQuery(team.key.id()).fetch_async()
event_futures = event_query.TeamEventsQuery(team.key.id()).fetch_async()
participation_future = team_query.TeamParticipationQuery(team.key.id()).fetch_async()
social_media_future = media_query.TeamSocialMediaQuery(team.key.id()).fetch_async()
hof_awards = hof_award_future.get_result()
hof_video = hof_video_future.get_result()
hof_presentation = hof_presentation_future.get_result()
hof_essay = hof_essay_future.get_result()
hall_of_fame = {
"is_hof": len(hof_awards) > 0,
"years": [award.year for award in hof_awards],
"media": {
"video": hof_video[0].youtube_url_link if len(hof_video) > 0 else None,
"presentation": hof_presentation[0].youtube_url_link if len(hof_presentation) > 0 else None,
"essay": hof_essay[0].external_link if len(hof_essay) > 0 else None,
},
}
awards_by_event = {}
for award in award_futures.get_result():
if award.event.id() not in awards_by_event:
awards_by_event[award.event.id()] = [award]
else:
awards_by_event[award.event.id()].append(award)
event_awards = []
current_event = None
matches_upcoming = None
short_cache = False
years = set()
for event in event_futures.get_result():
years.add(event.year)
if event.now:
current_event = event
matches = match_query.TeamEventMatchesQuery(team.key.id(), event.key.id()).fetch()
matches_upcoming = MatchHelper.upcomingMatches(matches)
if event.within_a_day:
short_cache = True
if event.key_name in awards_by_event:
sorted_awards = AwardHelper.organizeAwards(awards_by_event[event.key_name])
else:
sorted_awards = []
event_awards.append((event, sorted_awards))
event_awards = sorted(event_awards, key=lambda (e, _): e.start_date if e.start_date else datetime.datetime(e.year, 12, 31))
last_competed = None
participation_years = participation_future.get_result()
if len(participation_years) > 0:
last_competed = max(participation_years)
current_year = datetime.date.today().year
social_medias = sorted(social_media_future.get_result(), key=MediaHelper.social_media_sorter)
handler.template_values.update({
"is_canonical": is_canonical,
"team": team,
"event_awards": event_awards,
"years": sorted(years),
"social_medias": social_medias,
"current_event": current_event,
"matches_upcoming": matches_upcoming,
"last_competed": last_competed,
"current_year": current_year,
"max_year": tba_config.MAX_YEAR,
"hof": hall_of_fame,
})
if short_cache:
handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION
return jinja2_engine.render("team_history.html", handler.template_values)
def render_team_details(cls, handler, team, year, is_canonical):
media_future = media_query.TeamYearMediaQuery(team.key.id(), year).fetch_async()
social_media_future = media_query.TeamSocialMediaQuery(team.key.id()).fetch_async()
robot_future = Robot.get_by_id_async('{}_{}'.format(team.key.id(), year))
team_districts_future = team_query.TeamDistrictsQuery(team.key.id()).fetch_async()
participation_future = team_query.TeamParticipationQuery(team.key.id()).fetch_async()
events_sorted, matches_by_event_key, awards_by_event_key, valid_years = TeamDetailsDataFetcher.fetch(team, year, return_valid_years=True)
if not events_sorted:
return None
participation = []
season_wlt_list = []
offseason_wlt_list = []
year_match_avg_list = []
current_event = None
matches_upcoming = None
short_cache = False
for event in events_sorted:
event_matches = matches_by_event_key.get(event.key, [])
event_awards = AwardHelper.organizeAwards(awards_by_event_key.get(event.key, []))
matches_organized = MatchHelper.organizeMatches(event_matches)
if event.now:
current_event = event
matches_upcoming = MatchHelper.upcomingMatches(event_matches)
if event.within_a_day:
short_cache = True
if year == 2015:
display_wlt = None
match_avg = EventHelper.calculateTeamAvgScoreFromMatches(team.key_name, event_matches)
year_match_avg_list.append(match_avg)
qual_avg, elim_avg, _, _ = match_avg
else:
qual_avg = None
elim_avg = None
wlt = EventHelper.calculateTeamWLTFromMatches(team.key_name, event_matches)
if event.event_type_enum in EventType.SEASON_EVENT_TYPES:
season_wlt_list.append(wlt)
else:
offseason_wlt_list.append(wlt)
if wlt["win"] + wlt["loss"] + wlt["tie"] == 0:
display_wlt = None
else:
display_wlt = wlt
team_rank = None
if event.rankings:
for element in event.rankings:
if str(element[1]) == str(team.team_number):
team_rank = element[0]
break
participation.append({'event': event,
'matches': matches_organized,
'wlt': display_wlt,
'qual_avg': qual_avg,
'elim_avg': elim_avg,
'rank': team_rank,
'awards': event_awards})
season_wlt = None
offseason_wlt = None
if year == 2015:
year_wlt = None
year_qual_scores = []
year_elim_scores = []
for _, _, event_qual_scores, event_elim_scores in year_match_avg_list:
year_qual_scores += event_qual_scores
year_elim_scores += event_elim_scores
year_qual_avg = float(sum(year_qual_scores)) / len(year_qual_scores) if year_qual_scores != [] else None
year_elim_avg = float(sum(year_elim_scores)) / len(year_elim_scores) if year_elim_scores != [] else None
else:
year_qual_avg = None
year_elim_avg = None
season_wlt = {"win": 0, "loss": 0, "tie": 0}
offseason_wlt = {"win": 0, "loss": 0, "tie": 0}
for wlt in season_wlt_list:
season_wlt["win"] += wlt["win"]
season_wlt["loss"] += wlt["loss"]
season_wlt["tie"] += wlt["tie"]
if season_wlt["win"] + season_wlt["loss"] + season_wlt["tie"] == 0:
season_wlt = None
for wlt in offseason_wlt_list:
offseason_wlt["win"] += wlt["win"]
offseason_wlt["loss"] += wlt["loss"]
offseason_wlt["tie"] += wlt["tie"]
if offseason_wlt["win"] + offseason_wlt["loss"] + offseason_wlt["tie"] == 0:
offseason_wlt = None
medias_by_slugname = MediaHelper.group_by_slugname([media for media in media_future.get_result()])
image_medias = MediaHelper.get_images(media_future.get_result())
social_medias = sorted(social_media_future.get_result(), key=MediaHelper.social_media_sorter)
preferred_image_medias = filter(lambda x: team.key in x.preferred_references, image_medias)
district_name = None
district_abbrev = None
team_districts = team_districts_future.get_result()
if year in team_districts:
district_key = team_districts[year]
district_abbrev = district_key[4:]
district_type = DistrictType.abbrevs[district_abbrev]
district_name = DistrictType.type_names[district_type]
last_competed = None
participation_years = participation_future.get_result()
if len(participation_years) > 0:
last_competed = max(participation_years)
current_year = datetime.date.today().year
handler.template_values.update({
"is_canonical": is_canonical,
"team": team,
"participation": participation,
"year": year,
"years": valid_years,
"season_wlt": season_wlt,
"offseason_wlt": offseason_wlt,
"year_qual_avg": year_qual_avg,
"year_elim_avg": year_elim_avg,
"current_event": current_event,
"matches_upcoming": matches_upcoming,
"medias_by_slugname": medias_by_slugname,
"social_medias": social_medias,
"image_medias": image_medias,
"preferred_image_medias": preferred_image_medias,
"robot": robot_future.get_result(),
"district_name": district_name,
"district_abbrev": district_abbrev,
"last_competed": last_competed,
"current_year": current_year,
})
if short_cache:
handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('team_details.html', handler.template_values)
def parse(self, html):
"""
Parse the awards from USFIRST.
"""
html = html.decode(
'utf-8', 'ignore') # Clean html before feeding itno BeautifulSoup
soup = BeautifulSoup(html)
# Bad formatting on some pages makes this necessary
trs1 = soup.findAll('tr', {'style': 'background-color:#D2D2FF;'})
trs2 = soup.findAll('tr', {'style': 'background-color:#FFFFFF;'})
trs = trs1 + trs2
awards_by_type = {}
for tr in trs:
tds = tr.findAll('td')
name_str = unicode(self._recurseUntilString(tds[0]))
award_type_enum = AwardHelper.parse_award_type(name_str)
if award_type_enum is None:
continue
team_number = None
try:
team_number = self._recurseUntilString(tds[1])
except AttributeError:
team_number = None
if team_number and team_number.isdigit():
team_number = int(team_number)
else:
team_number = None
awardee = None
if award_type_enum in AwardType.INDIVIDUAL_AWARDS:
try:
awardee_str = self._recurseUntilString(tds[2])
if awardee_str:
awardee = unicode(sanitize(awardee_str))
except TypeError:
awardee = None
if not awardee:
# Turns '' into None
awardee = None
# an award must have either an awardee or a team_number
if awardee is None and team_number is None:
continue
recipient_json = json.dumps({
'team_number': team_number,
'awardee': awardee,
})
if award_type_enum in awards_by_type:
if team_number is not None:
awards_by_type[award_type_enum]['team_number_list'].append(
team_number)
awards_by_type[award_type_enum]['recipient_json_list'].append(
recipient_json)
else:
awards_by_type[award_type_enum] = {
'name_str':
strip_number(name_str),
'award_type_enum':
award_type_enum,
'team_number_list':
[team_number] if team_number is not None else [],
'recipient_json_list': [recipient_json],
}
return awards_by_type.values(), False
def _render(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
medias_future = media_query.EventTeamsPreferredMediasQuery(
event_key).fetch_async()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
# Organize medias by team
image_medias = MediaHelper.get_images(
[media for media in medias_future.get_result()])
team_medias = defaultdict(list)
for image_media in image_medias:
for reference in image_media.references:
team_medias[reference].append(image_media)
team_and_medias = []
for team in teams:
team_and_medias.append((team, team_medias.get(team.key, [])))
num_teams = len(team_and_medias)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = team_and_medias[:middle_value], team_and_medias[
middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()
] if (event.matchstats is not None
and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.now:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = MatchHelper.generateBracket(matches,
event.alliance_selections)
is_2015_playoff = EventHelper.is_2015_playoff(event_key)
if is_2015_playoff:
playoff_advancement = MatchHelper.generatePlayoffAdvancement2015(
matches, event.alliance_selections)
for comp_level in ['qf', 'sf']:
if comp_level in bracket_table:
del bracket_table[comp_level]
else:
playoff_advancement = None
district_points_sorted = None
if event.district_points:
district_points_sorted = sorted(
event.district_points['points'].items(),
key=lambda (team, points): -points['total'])
event_insights = EventInsightsHelper.calculate_event_insights(
cleaned_matches, event.year)
event_insights_template = None
if event_insights:
event_insights_template = 'event_partials/event_insights_{}.html'.format(
event.year)
self.template_values.update({
"event":
event,
"district_name":
DistrictType.type_names.get(event.event_district_enum, None),
"district_abbrev":
DistrictType.type_abbrevs.get(event.event_district_enum, None),
"matches":
matches,
"matches_recent":
matches_recent,
"matches_upcoming":
matches_upcoming,
"awards":
awards,
"teams_a":
teams_a,
"teams_b":
teams_b,
"num_teams":
num_teams,
"oprs":
oprs,
"bracket_table":
bracket_table,
"playoff_advancement":
playoff_advancement,
"district_points_sorted":
district_points_sorted,
"is_2015_playoff":
is_2015_playoff,
"event_insights_qual":
event_insights['qual'] if event_insights else None,
"event_insights_playoff":
event_insights['playoff'] if event_insights else None,
"event_insights_template":
event_insights_template,
})
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('event_details.html', self.template_values)
def _render(self, event_key):
event = Event.get_by_id(event_key)
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
num_teams = len(teams)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = teams[:middle_value], teams[middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()] if (event.matchstats is not None and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.now:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = MatchHelper.generateBracket(matches, event.alliance_selections)
is_2015_playoff = EventHelper.is_2015_playoff(event_key)
if is_2015_playoff:
playoff_advancement = MatchHelper.generatePlayoffAdvancement2015(matches, event.alliance_selections)
for comp_level in ['qf', 'sf']:
if comp_level in bracket_table:
del bracket_table[comp_level]
else:
playoff_advancement = None
district_points_sorted = None
if event.district_points:
district_points_sorted = sorted(event.district_points['points'].items(), key=lambda (team, points): -points['total'])
self.template_values.update({
"event": event,
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
"playoff_advancement": playoff_advancement,
"district_points_sorted": district_points_sorted,
"is_2015_playoff": is_2015_playoff,
})
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__), '../templates/event_details.html')
return template.render(path, self.template_values)
def _render(self,event_key):
self._set_event(event_key)
award_dicts = [ModelToDict.awardConverter(award) for award in AwardHelper.organizeAwards(self.event.awards)]
return json.dumps(award_dicts, ensure_ascii=True)
def render_team_details(cls, handler, team, year, is_canonical):
media_key_futures = Media.query(Media.references == team.key, Media.year == year).fetch_async(500, keys_only=True)
events_sorted, matches_by_event_key, awards_by_event_key, valid_years = TeamDetailsDataFetcher.fetch(team, year, return_valid_years=True)
if not events_sorted:
return None
media_futures = ndb.get_multi_async(media_key_futures.get_result())
participation = []
year_wlt_list = []
year_match_avg_list = []
current_event = None
matches_upcoming = None
short_cache = False
for event in events_sorted:
event_matches = matches_by_event_key.get(event.key, [])
event_awards = AwardHelper.organizeAwards(awards_by_event_key.get(event.key, []))
matches_organized = MatchHelper.organizeMatches(event_matches)
if event.now:
current_event = event
matches_upcoming = MatchHelper.upcomingMatches(event_matches)
if event.within_a_day:
short_cache = True
if year == 2015:
display_wlt = None
match_avg = EventHelper.calculateTeamAvgScoreFromMatches(team.key_name, event_matches)
year_match_avg_list.append(match_avg)
qual_avg, elim_avg, _, _ = match_avg
else:
qual_avg = None
elim_avg = None
wlt = EventHelper.calculateTeamWLTFromMatches(team.key_name, event_matches)
year_wlt_list.append(wlt)
if wlt["win"] + wlt["loss"] + wlt["tie"] == 0:
display_wlt = None
else:
display_wlt = wlt
team_rank = None
if event.rankings:
for element in event.rankings:
if str(element[1]) == str(team.team_number):
team_rank = element[0]
break
participation.append({'event': event,
'matches': matches_organized,
'wlt': display_wlt,
'qual_avg': qual_avg,
'elim_avg': elim_avg,
'rank': team_rank,
'awards': event_awards})
if year == 2015:
year_wlt = None
year_qual_scores = []
year_elim_scores = []
for _, _, event_qual_scores, event_elim_scores in year_match_avg_list:
year_qual_scores += event_qual_scores
year_elim_scores += event_elim_scores
year_qual_avg = float(sum(year_qual_scores)) / len(year_qual_scores) if year_qual_scores != [] else None
year_elim_avg = float(sum(year_elim_scores)) / len(year_elim_scores) if year_elim_scores != [] else None
else:
year_qual_avg = None
year_elim_avg = None
year_wlt = {"win": 0, "loss": 0, "tie": 0}
for wlt in year_wlt_list:
year_wlt["win"] += wlt["win"]
year_wlt["loss"] += wlt["loss"]
year_wlt["tie"] += wlt["tie"]
if year_wlt["win"] + year_wlt["loss"] + year_wlt["tie"] == 0:
year_wlt = None
medias_by_slugname = MediaHelper.group_by_slugname([media_future.get_result() for media_future in media_futures])
handler.template_values.update({
"is_canonical": is_canonical,
"team": team,
"participation": participation,
"year": year,
"years": valid_years,
"year_wlt": year_wlt,
"year_qual_avg": year_qual_avg,
"year_elim_avg": year_elim_avg,
"current_event": current_event,
"matches_upcoming": matches_upcoming,
"medias_by_slugname": medias_by_slugname
})
if short_cache:
handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__), '../templates/team_details.html')
return template.render(path, handler.template_values)
def render_team_details(cls, handler, team, year, is_canonical):
hof_award_future = award_query.TeamEventTypeAwardsQuery(team.key.id(), EventType.CMP_FINALS, AwardType.CHAIRMANS).fetch_async()
hof_video_future = media_query.TeamTagMediasQuery(team.key.id(), MediaTag.CHAIRMANS_VIDEO).fetch_async()
hof_presentation_future = media_query.TeamTagMediasQuery(team.key.id(), MediaTag.CHAIRMANS_PRESENTATION).fetch_async()
hof_essay_future = media_query.TeamTagMediasQuery(team.key.id(), MediaTag.CHAIRMANS_ESSAY).fetch_async()
media_future = media_query.TeamYearMediaQuery(team.key.id(), year).fetch_async()
social_media_future = media_query.TeamSocialMediaQuery(team.key.id()).fetch_async()
robot_future = Robot.get_by_id_async("{}_{}".format(team.key.id(), year))
team_districts_future = team_query.TeamDistrictsQuery(team.key.id()).fetch_async()
participation_future = team_query.TeamParticipationQuery(team.key.id()).fetch_async()
hof_awards = hof_award_future.get_result()
hof_video = hof_video_future.get_result()
hof_presentation = hof_presentation_future.get_result()
hof_essay = hof_essay_future.get_result()
hall_of_fame = {
"is_hof": len(hof_awards) > 0,
"years": [award.year for award in hof_awards],
"media": {
"video": hof_video[0].youtube_url_link if len(hof_video) > 0 else None,
"presentation": hof_presentation[0].youtube_url_link if len(hof_presentation) > 0 else None,
"essay": hof_essay[0].external_link if len(hof_essay) > 0 else None,
},
}
events_sorted, matches_by_event_key, awards_by_event_key, valid_years = TeamDetailsDataFetcher.fetch(team, year, return_valid_years=True)
if not events_sorted:
return None
district_name = None
district_abbrev = None
team_district_points = None
team_districts = team_districts_future.get_result()
for district in team_districts:
if district and district.year == year:
district_abbrev = district.abbreviation
district_name = district.display_name
if district.rankings:
team_district_points = next(
iter(filter(lambda r: r['team_key'] == team.key_name,
district.rankings)), None)
break
participation = []
season_wlt_list = []
offseason_wlt_list = []
year_match_avg_list = []
current_event = None
matches_upcoming = None
short_cache = False
for event in events_sorted:
event_matches = matches_by_event_key.get(event.key, [])
event_awards = AwardHelper.organizeAwards(awards_by_event_key.get(event.key, []))
matches_organized = MatchHelper.organizeMatches(event_matches)
if event.now:
current_event = event
matches_upcoming = MatchHelper.upcomingMatches(event_matches)
if event.within_a_day:
short_cache = True
if year == 2015:
display_wlt = None
match_avg = EventHelper.calculateTeamAvgScoreFromMatches(team.key_name, event_matches)
year_match_avg_list.append(match_avg)
qual_avg, elim_avg, _, _ = match_avg
else:
qual_avg = None
elim_avg = None
wlt = EventHelper.calculateTeamWLTFromMatches(team.key_name, event_matches)
if event.event_type_enum in EventType.SEASON_EVENT_TYPES:
season_wlt_list.append(wlt)
else:
offseason_wlt_list.append(wlt)
if wlt["win"] + wlt["loss"] + wlt["tie"] == 0:
display_wlt = None
else:
display_wlt = wlt
team_rank = None
if event.details and event.details.rankings2:
for ranking in event.details.rankings2:
if ranking['team_key'] == team.key.id():
team_rank = ranking['rank']
break
video_ids = []
playlist = ""
for level in Match.COMP_LEVELS:
matches = matches_organized[level]
for match in matches:
video_ids += [video.split("?")[0] for video in match.youtube_videos]
if video_ids:
playlist_title = u"{} (Team {})".format(event.name, team.team_number)
playlist = u"https://www.youtube.com/watch_videos?video_ids={}&title={}"
playlist = playlist.format(u",".join(video_ids), playlist_title)
district_points = None
if team_district_points:
district_points = next(
iter(
filter(lambda e: e['event_key'] == event.key_name,
team_district_points['event_points'])), None)
participation.append({
"event": event,
"matches": matches_organized,
"wlt": display_wlt,
"qual_avg": qual_avg,
"elim_avg": elim_avg,
"rank": team_rank,
"awards": event_awards,
"playlist": playlist,
"district_points": district_points,
})
season_wlt = None
offseason_wlt = None
if year == 2015:
year_wlt = None
year_qual_scores = []
year_elim_scores = []
for _, _, event_qual_scores, event_elim_scores in year_match_avg_list:
year_qual_scores += event_qual_scores
year_elim_scores += event_elim_scores
year_qual_avg = float(sum(year_qual_scores)) / len(year_qual_scores) if year_qual_scores != [] else None
year_elim_avg = float(sum(year_elim_scores)) / len(year_elim_scores) if year_elim_scores != [] else None
else:
year_qual_avg = None
year_elim_avg = None
season_wlt = {"win": 0, "loss": 0, "tie": 0}
offseason_wlt = {"win": 0, "loss": 0, "tie": 0}
for wlt in season_wlt_list:
season_wlt["win"] += wlt["win"]
season_wlt["loss"] += wlt["loss"]
season_wlt["tie"] += wlt["tie"]
if season_wlt["win"] + season_wlt["loss"] + season_wlt["tie"] == 0:
season_wlt = None
for wlt in offseason_wlt_list:
offseason_wlt["win"] += wlt["win"]
offseason_wlt["loss"] += wlt["loss"]
offseason_wlt["tie"] += wlt["tie"]
if offseason_wlt["win"] + offseason_wlt["loss"] + offseason_wlt["tie"] == 0:
offseason_wlt = None
medias_by_slugname = MediaHelper.group_by_slugname([media for media in media_future.get_result()])
avatar = MediaHelper.get_avatar(media_future.get_result())
image_medias = MediaHelper.get_images(media_future.get_result())
social_medias = sorted(social_media_future.get_result(), key=MediaHelper.social_media_sorter)
preferred_image_medias = filter(lambda x: team.key in x.preferred_references, image_medias)
last_competed = None
participation_years = participation_future.get_result()
if len(participation_years) > 0:
last_competed = max(participation_years)
current_year = datetime.date.today().year
handler.template_values.update({
"is_canonical": is_canonical,
"team": team,
"participation": participation,
"year": year,
"years": valid_years,
"season_wlt": season_wlt,
"offseason_wlt": offseason_wlt,
"year_qual_avg": year_qual_avg,
"year_elim_avg": year_elim_avg,
"current_event": current_event,
"matches_upcoming": matches_upcoming,
"medias_by_slugname": medias_by_slugname,
"avatar": avatar,
"social_medias": social_medias,
"image_medias": image_medias,
"preferred_image_medias": preferred_image_medias,
"robot": robot_future.get_result(),
"district_name": district_name,
"district_abbrev": district_abbrev,
"last_competed": last_competed,
"current_year": current_year,
"max_year": tba_config.MAX_YEAR,
"hof": hall_of_fame,
"team_district_points": team_district_points,
})
if short_cache:
handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION
return jinja2_engine.render("team_details.html", handler.template_values)
def test_parse(self):
"""
Tests for a select subset of award types. Add more if desired.
"""
self.assertEqual(AwardHelper.parse_award_type("Chairman's"), AwardType.CHAIRMANS)
self.assertEqual(AwardHelper.parse_award_type("Chairman"), AwardType.CHAIRMANS)
self.assertEqual(AwardHelper.parse_award_type("Winner #1"), AwardType.WINNER)
self.assertEqual(AwardHelper.parse_award_type("Division Winner #2"), AwardType.WINNER)
self.assertEqual(AwardHelper.parse_award_type("Newton - Division Champion #3"), AwardType.WINNER)
self.assertEqual(AwardHelper.parse_award_type("Championship Winner #3"), AwardType.WINNER)
self.assertEqual(AwardHelper.parse_award_type("Championship Champion #4"), AwardType.WINNER)
self.assertEqual(AwardHelper.parse_award_type("Championship Champion"), AwardType.WINNER)
self.assertEqual(AwardHelper.parse_award_type("Championship Winner"), AwardType.WINNER)
self.assertEqual(AwardHelper.parse_award_type("Winner"), AwardType.WINNER)
self.assertEqual(AwardHelper.parse_award_type("Finalist #1"), AwardType.FINALIST)
self.assertEqual(AwardHelper.parse_award_type("Division Finalist #2"), AwardType.FINALIST)
self.assertEqual(AwardHelper.parse_award_type("Championship Finalist #3"), AwardType.FINALIST)
self.assertEqual(AwardHelper.parse_award_type("Championship Finalist #4"), AwardType.FINALIST)
self.assertEqual(AwardHelper.parse_award_type("Championship Finalist"), AwardType.FINALIST)
self.assertEqual(AwardHelper.parse_award_type("Finalist"), AwardType.FINALIST)
self.assertEqual(AwardHelper.parse_award_type("Dean's List Finalist #1"), AwardType.DEANS_LIST)
self.assertEqual(AwardHelper.parse_award_type("Dean's List Finalist"), AwardType.DEANS_LIST)
self.assertEqual(AwardHelper.parse_award_type("Dean's List Winner #9"), AwardType.DEANS_LIST)
self.assertEqual(AwardHelper.parse_award_type("Dean's List Winner"), AwardType.DEANS_LIST)
self.assertEqual(AwardHelper.parse_award_type("Dean's List"), AwardType.DEANS_LIST)
self.assertEqual(AwardHelper.parse_award_type("Excellence in Design Award sponsored by Autodesk (3D CAD)"), AwardType.EXCELLENCE_IN_DESIGN_CAD)
self.assertEqual(AwardHelper.parse_award_type("Excellence in Design Award sponsored by Autodesk (Animation)"), AwardType.EXCELLENCE_IN_DESIGN_ANIMATION)
self.assertEqual(AwardHelper.parse_award_type("Excellence in Design Award"), AwardType.EXCELLENCE_IN_DESIGN)
self.assertEqual(AwardHelper.parse_award_type("Dr. Bart Kamen Memorial Scholarship #1"), AwardType.BART_KAMEN_MEMORIAL)
self.assertEqual(AwardHelper.parse_award_type("Media and Technology Award sponsored by Comcast"), AwardType.MEDIA_AND_TECHNOLOGY)
self.assertEqual(AwardHelper.parse_award_type("Make It Loud Award"), AwardType.MAKE_IT_LOUD)
self.assertEqual(AwardHelper.parse_award_type("Founder's Award"), AwardType.FOUNDERS)
self.assertEqual(AwardHelper.parse_award_type("Championship - Web Site Award"), AwardType.WEBSITE)
self.assertEqual(AwardHelper.parse_award_type("Recognition of Extraordinary Service"), AwardType.RECOGNITION_OF_EXTRAORDINARY_SERVICE)
self.assertEqual(AwardHelper.parse_award_type("Outstanding Cart Award"), AwardType.OUTSTANDING_CART)
self.assertEqual(AwardHelper.parse_award_type("Wayne State University Aim Higher Award"), AwardType.WSU_AIM_HIGHER)
self.assertEqual(AwardHelper.parse_award_type("Delphi \"Driving Tommorow's Technology\" Award"), AwardType.DRIVING_TOMORROWS_TECHNOLOGY)
self.assertEqual(AwardHelper.parse_award_type("Delphi Drive Tommorows Technology"), AwardType.DRIVING_TOMORROWS_TECHNOLOGY)
self.assertEqual(AwardHelper.parse_award_type("Kleiner, Perkins, Caufield and Byers"), AwardType.ENTREPRENEURSHIP)
self.assertEqual(AwardHelper.parse_award_type("Leadership in Control Award"), AwardType.LEADERSHIP_IN_CONTROL)
self.assertEqual(AwardHelper.parse_award_type("#1 Seed"), AwardType.NUM_1_SEED)
self.assertEqual(AwardHelper.parse_award_type("Incredible Play Award"), AwardType.INCREDIBLE_PLAY)
self.assertEqual(AwardHelper.parse_award_type("People's Choice Animation Award"), AwardType.PEOPLES_CHOICE_ANIMATION)
self.assertEqual(AwardHelper.parse_award_type("Autodesk Award for Visualization - Grand Prize"), AwardType.VISUALIZATION)
self.assertEqual(AwardHelper.parse_award_type("Autodesk Award for Visualization - Rising Star"), AwardType.VISUALIZATION_RISING_STAR)
self.assertEqual(AwardHelper.parse_award_type("Some Random Award Winner"), None)
self.assertEqual(AwardHelper.parse_award_type("Random Champion"), None)
self.assertEqual(AwardHelper.parse_award_type("An Award"), None)
# Make sure all old regional awards have matching types
with open('test_data/pre_2002_regional_awards.csv', 'r') as f:
csv_data = list(csv.reader(StringIO.StringIO(f.read()), delimiter=',', skipinitialspace=True))
for award in csv_data:
self.assertNotEqual(AwardHelper.parse_award_type(award[2]), None)
# Make sure all old regional awards have matching types
with open('test_data/pre_2007_cmp_awards.csv', 'r') as f:
csv_data = list(csv.reader(StringIO.StringIO(f.read()), delimiter=',', skipinitialspace=True))
for award in csv_data:
self.assertNotEqual(AwardHelper.parse_award_type(award[2]), None)
# test 2015 award names
with open('test_data/fms_api/2015_award_types.json', 'r') as f:
for award in json.loads(f.read()):
self.assertNotEqual(AwardHelper.parse_award_type(award['description']), None)
def parse(self, data):
"""
Parse CSV that contains awards
Format is as follows:
year, event_short, award_name_str, team_number (can be blank), awardee (can be blank)
Example:
2000,mi,Regional Finalist,45,
"""
awards_by_key = {}
csv_data = list(
csv.reader(StringIO.StringIO(data),
delimiter=',',
skipinitialspace=True))
for award in csv_data:
year = int(award[0])
event_short = award[1]
name_str = award[2]
team_number = award[3]
awardee = award[4]
if team_number == '':
team_number = None
else:
team_number = int(team_number)
if awardee == '':
awardee = None
# an award must have either an awardee or a team_number
if awardee is None and team_number is None:
continue
if team_number is not None:
team_number_list = [team_number]
else:
team_number_list = []
recipient_json = json.dumps({
'team_number': team_number,
'awardee': awardee,
})
award_type_enum = AwardHelper.parse_award_type(name_str)
if award_type_enum is None:
continue
award_key_name = Award.render_key_name(
'{}{}'.format(year, event_short), award_type_enum)
if award_key_name in awards_by_key:
if team_number is not None:
awards_by_key[award_key_name]['team_number_list'].append(
team_number)
awards_by_key[award_key_name]['recipient_json_list'].append(
recipient_json)
else:
awards_by_key[award_key_name] = {
'year': year,
'event_short': event_short,
'name_str': name_str,
'award_type_enum': award_type_enum,
'team_number_list': team_number_list,
'recipient_json_list': [recipient_json],
}
return awards_by_key.values()
def _render(self, event_key):
event = EventQuery(event_key).fetch()
if not event:
self.abort(404)
event.prepAwardsMatchesTeams()
event.prep_details()
medias_future = media_query.EventTeamsPreferredMediasQuery(event_key).fetch_async()
district_future = DistrictQuery(event.district_key.id()).fetch_async() if event.district_key else None
event_medias_future = media_query.EventMediasQuery(event_key).fetch_async()
awards = AwardHelper.organizeAwards(event.awards)
cleaned_matches = MatchHelper.deleteInvalidMatches(event.matches)
matches = MatchHelper.organizeMatches(cleaned_matches)
teams = TeamHelper.sortTeams(event.teams)
# Organize medias by team
image_medias = MediaHelper.get_images([media for media in medias_future.get_result()])
team_medias = defaultdict(list)
for image_media in image_medias:
for reference in image_media.references:
team_medias[reference].append(image_media)
team_and_medias = []
for team in teams:
team_and_medias.append((team, team_medias.get(team.key, [])))
num_teams = len(team_and_medias)
middle_value = num_teams / 2
if num_teams % 2 != 0:
middle_value += 1
teams_a, teams_b = team_and_medias[:middle_value], team_and_medias[middle_value:]
oprs = [i for i in event.matchstats['oprs'].items()] if (event.matchstats is not None and 'oprs' in event.matchstats) else []
oprs = sorted(oprs, key=lambda t: t[1], reverse=True) # sort by OPR
oprs = oprs[:15] # get the top 15 OPRs
if event.now:
matches_recent = MatchHelper.recentMatches(cleaned_matches)
matches_upcoming = MatchHelper.upcomingMatches(cleaned_matches)
else:
matches_recent = None
matches_upcoming = None
bracket_table = MatchHelper.generateBracket(matches, event.alliance_selections)
is_2015_playoff = EventHelper.is_2015_playoff(event_key)
if is_2015_playoff:
playoff_advancement = MatchHelper.generatePlayoffAdvancement2015(matches, event.alliance_selections)
for comp_level in ['qf', 'sf']:
if comp_level in bracket_table:
del bracket_table[comp_level]
else:
playoff_advancement = None
district_points_sorted = None
if event.district_points:
district_points_sorted = sorted(event.district_points['points'].items(), key=lambda (team, points): -points['total'])
event_insights = event.details.insights if event.details else None
event_insights_template = None
if event_insights:
event_insights_template = 'event_partials/event_insights_{}.html'.format(event.year)
district = district_future.get_result() if district_future else None
medias_by_slugname = MediaHelper.group_by_slugname([media for media in event_medias_future.get_result()])
self.template_values.update({
"event": event,
"district_name": district.display_name if district else None,
"district_abbrev": district.abbreviation if district else None,
"matches": matches,
"matches_recent": matches_recent,
"matches_upcoming": matches_upcoming,
"awards": awards,
"teams_a": teams_a,
"teams_b": teams_b,
"num_teams": num_teams,
"oprs": oprs,
"bracket_table": bracket_table,
"playoff_advancement": playoff_advancement,
"district_points_sorted": district_points_sorted,
"is_2015_playoff": is_2015_playoff,
"event_insights_qual": event_insights['qual'] if event_insights else None,
"event_insights_playoff": event_insights['playoff'] if event_insights else None,
"event_insights_template": event_insights_template,
"medias_by_slugname": medias_by_slugname,
})
if event.within_a_day:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('event_details.html', self.template_values)
def _render(self, team_number, year=None, explicit_year=False):
@ndb.tasklet
def get_event_matches_async(event_team_key):
event_team = yield event_team_key.get_async()
years.add(event_team.year) # years is a "global" variable (defined below). Doing this removes the complexity of having to propagate the years up through the tasklet call chain.
if (event_team.year == year):
event = yield event_team.event.get_async()
if not event.start_date:
event.start_date = datetime.datetime(year, 12, 31) #unknown goes last
matches_keys = yield Match.query(
Match.event == event.key, Match.team_key_names == team.key_name).fetch_async(500, keys_only=True)
matches = yield ndb.get_multi_async(matches_keys)
raise ndb.Return((event, matches))
raise ndb.Return(None)
@ndb.tasklet
def get_events_matches_async():
event_team_keys = yield EventTeam.query(EventTeam.team == team.key).fetch_async(1000, keys_only=True)
events_matches = yield map(get_event_matches_async, event_team_keys)
events_matches = filter(None, events_matches)
raise ndb.Return(events_matches)
@ndb.tasklet
def get_awards_async():
award_keys = yield Award.query(Award.year == year, Award.team == team.key).fetch_async(500, keys_only=True)
awards = yield ndb.get_multi_async(award_keys)
raise ndb.Return(awards)
@ndb.toplevel
def get_events_matches_awards():
events_matches, awards = yield get_events_matches_async(), get_awards_async()
raise ndb.Return(events_matches, awards)
team = Team.get_by_id("frc" + team_number)
if not team:
return self.redirect("/error/404")
years = set()
events_matches, awards = get_events_matches_awards()
events_matches = sorted(events_matches, key=lambda (e, _): e.start_date)
years = sorted(years)
participation = list()
year_wlt_list = list()
current_event = None
matches_upcoming = None
short_cache = False
for e, matches in events_matches:
event_awards = AwardHelper.organizeAwards([award for award in awards if award.event == e.key])
matches_organized = MatchHelper.organizeMatches(matches)
if e.now:
current_event = e
matches_upcoming = MatchHelper.upcomingMatches(matches)
if e.within_a_day:
short_cache = True
wlt = EventHelper.calculateTeamWLTFromMatches(team.key_name, matches)
year_wlt_list.append(wlt)
if wlt["win"] + wlt["loss"] + wlt["tie"] == 0:
display_wlt = None
else:
display_wlt = wlt
team_rank = None
if e.rankings:
for element in e.rankings:
if element[1] == team_number:
team_rank = element[0]
break
participation.append({ 'event' : e,
'matches' : matches_organized,
'wlt': display_wlt,
'rank': team_rank,
'awards': event_awards })
year_wlt = {"win": 0, "loss": 0, "tie": 0}
for wlt in year_wlt_list:
year_wlt["win"] += wlt["win"]
year_wlt["loss"] += wlt["loss"]
year_wlt["tie"] += wlt["tie"]
if year_wlt["win"] + year_wlt["loss"] + year_wlt["tie"] == 0:
year_wlt = None
template_values = { "explicit_year": explicit_year,
"team": team,
"participation": participation,
"year": year,
"years": years,
"year_wlt": year_wlt,
"current_event": current_event,
"matches_upcoming": matches_upcoming }
if short_cache:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__), '../templates/team_details.html')
return template.render(path, template_values)
def render_team_history(cls, handler, team, is_canonical):
event_team_keys_future = EventTeam.query(
EventTeam.team == team.key).fetch_async(1000, keys_only=True)
award_keys_future = Award.query(
Award.team_list == team.key).fetch_async(1000, keys_only=True)
event_teams_futures = ndb.get_multi_async(
event_team_keys_future.get_result())
awards_futures = ndb.get_multi_async(award_keys_future.get_result())
event_keys = [
event_team_future.get_result().event
for event_team_future in event_teams_futures
]
events_futures = ndb.get_multi_async(event_keys)
awards_by_event = {}
for award_future in awards_futures:
award = award_future.get_result()
if award.event.id() not in awards_by_event:
awards_by_event[award.event.id()] = [award]
else:
awards_by_event[award.event.id()].append(award)
event_awards = []
current_event = None
matches_upcoming = None
short_cache = False
for event_future in events_futures:
event = event_future.get_result()
if event.now:
current_event = event
team_matches_future = Match.query(Match.event == event.key, Match.team_key_names == team.key_name)\
.fetch_async(500, keys_only=True)
matches = ndb.get_multi(team_matches_future.get_result())
matches_upcoming = MatchHelper.upcomingMatches(matches)
if event.within_a_day:
short_cache = True
if event.key_name in awards_by_event:
sorted_awards = AwardHelper.organizeAwards(
awards_by_event[event.key_name])
else:
sorted_awards = []
event_awards.append((event, sorted_awards))
event_awards = sorted(
event_awards,
key=lambda (e, _): e.start_date
if e.start_date else datetime.datetime(e.year, 12, 31))
years = sorted(
set([
et.get_result().year for et in event_teams_futures
if et.get_result().year is not None
]))
handler.template_values.update({
'is_canonical': is_canonical,
'team': team,
'event_awards': event_awards,
'years': years,
'current_event': current_event,
'matches_upcoming': matches_upcoming
})
if short_cache:
handler._cache_expiration = handler.SHORT_CACHE_EXPIRATION
path = os.path.join(os.path.dirname(__file__),
'../templates/team_history.html')
return template.render(path, handler.template_values)
