def _render(self, year=None, explicit_year=False):
event_keys = Event.query(Event.year == year).fetch(1000,
keys_only=True)
events = ndb.get_multi(event_keys)
EventHelper.sort_events(events)
week_events = EventHelper.groupByWeek(events)
district_enums = set()
for event in events:
if event.event_district_enum is not None and event.event_district_enum != DistrictType.NO_DISTRICT:
district_enums.add(event.event_district_enum)
districts = [] # a tuple of (district abbrev, district name)
for district_enum in district_enums:
districts.append((DistrictType.type_abbrevs[district_enum],
DistrictType.type_names[district_enum]))
districts = sorted(districts, key=lambda d: d[1])
self.template_values.update({
"events": events,
"explicit_year": explicit_year,
"selected_year": year,
"valid_years": self.VALID_YEARS,
"week_events": week_events,
"districts": districts,
})
path = os.path.join(os.path.dirname(__file__),
'../templates/event_list.html')
return template.render(path, self.template_values)
def _render(self, year=None, explicit_year=False):
events = event_query.EventListQuery(year).fetch()
EventHelper.sort_events(events)
week_events = EventHelper.groupByWeek(events)
district_enums = set()
for event in events:
if event.event_district_enum is not None and event.event_district_enum != DistrictType.NO_DISTRICT:
district_enums.add(event.event_district_enum)
districts = [] # a tuple of (district abbrev, district name)
for district_enum in district_enums:
districts.append((DistrictType.type_abbrevs[district_enum],
DistrictType.type_names[district_enum]))
districts = sorted(districts, key=lambda d: d[1])
self.template_values.update({
"events": events,
"explicit_year": explicit_year,
"selected_year": year,
"valid_years": self.VALID_YEARS,
"week_events": week_events,
"districts": districts,
})
return jinja2_engine.render('event_list.html', self.template_values)
def doMatchInsights(self, year):
"""
Calculate match insights for a given year. Returns a list of Insights.
"""
# Only fetch from DB once
official_events = Event.query(Event.year == year).order(Event.start_date).fetch(1000)
events_by_week = EventHelper.groupByWeek(official_events)
week_event_matches = [] # Tuples of: (week, events) where events are tuples of (event, matches)
for week, events in events_by_week.items():
if week == OFFSEASON_EVENTS_LABEL:
continue
week_events = []
for event in events:
if not event.official:
continue
matches = event.matches
week_events.append((event, matches))
week_event_matches.append((week, week_events))
insights = []
insights += self._calculateHighscoreMatchesByWeek(week_event_matches, year)
insights += self._calculateHighscoreMatches(week_event_matches, year)
insights += self._calculateMatchAveragesByWeek(week_event_matches, year)
insights += self._calculateScoreDistribution(week_event_matches, year)
insights += self._calculateNumMatches(week_event_matches, year)
return insights
def _render(self, year=None, explicit_year=False):
events = event_query.EventListQuery(year).fetch()
EventHelper.sort_events(events)
week_events = EventHelper.groupByWeek(events)
district_enums = set()
for event in events:
if event.event_district_enum is not None and event.event_district_enum != DistrictType.NO_DISTRICT:
district_enums.add(event.event_district_enum)
districts = [] # a tuple of (district abbrev, district name)
for district_enum in district_enums:
districts.append((DistrictType.type_abbrevs[district_enum],
DistrictType.type_names[district_enum]))
districts = sorted(districts, key=lambda d: d[1])
self.template_values.update({
"events": events,
"explicit_year": explicit_year,
"selected_year": year,
"valid_years": self.VALID_YEARS,
"week_events": week_events,
"districts": districts,
})
path = os.path.join(os.path.dirname(__file__), '../templates/event_list.html')
return template.render(path, self.template_values)
def doMatchInsights(self, year):
"""
Calculate match insights for a given year. Returns a list of Insights.
"""
# Only fetch from DB once
official_events = Event.query(Event.year == year).order(
Event.start_date).fetch(1000)
events_by_week = EventHelper.groupByWeek(official_events)
week_event_matches = [
] # Tuples of: (week, events) where events are tuples of (event, matches)
for week, events in events_by_week.items():
if week in {OFFSEASON_EVENTS_LABEL, PRESEASON_EVENTS_LABEL}:
continue
week_events = []
for event in events:
if not event.official:
continue
matches = event.matches
week_events.append((event, matches))
week_event_matches.append((week, week_events))
insights = []
insights += self._calculateHighscoreMatchesByWeek(
week_event_matches, year)
insights += self._calculateHighscoreMatches(week_event_matches, year)
insights += self._calculateMatchAveragesByWeek(week_event_matches,
year)
insights += self._calculateScoreDistribution(week_event_matches, year)
insights += self._calculateNumMatches(week_event_matches, year)
insights += self._calculateYearSpecific(week_event_matches, year)
return insights
def _render(self, year=None, explicit_year=False):
state_prov = self.request.get('state_prov', None)
districts_future = DistrictsInYearQuery(year).fetch_async()
all_events_future = event_query.EventListQuery(
year).fetch_async() # Needed for state_prov
if state_prov:
events_future = Event.query(
Event.year == year,
Event.state_prov == state_prov).fetch_async()
else:
events_future = all_events_future
events = events_future.get_result()
if state_prov == '' or (state_prov and not events):
self.redirect(self.request.path, abort=True)
EventHelper.sort_events(events)
week_events = EventHelper.groupByWeek(events)
districts = [] # a tuple of (district abbrev, district name)
for district in districts_future.get_result():
districts.append((district.abbreviation, district.display_name))
districts = sorted(districts, key=lambda d: d[1])
valid_state_provs = set()
for event in all_events_future.get_result():
if event.state_prov:
valid_state_provs.add(event.state_prov)
valid_state_provs = sorted(valid_state_provs)
self.template_values.update({
"events": events,
"explicit_year": explicit_year,
"selected_year": year,
"valid_years": self.VALID_YEARS,
"week_events": week_events,
"districts": districts,
"state_prov": state_prov,
"valid_state_provs": valid_state_provs,
})
if year == datetime.datetime.now().year:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('event_list.html', self.template_values)
def _render(self, year=None, explicit_year=False):
event_keys = Event.query(Event.year == year).fetch(1000, keys_only=True)
events = ndb.get_multi(event_keys)
events.sort(key=EventHelper.distantFutureIfNoStartDate)
week_events = EventHelper.groupByWeek(events)
template_values = {
"events": events,
"explicit_year": explicit_year,
"selected_year": year,
"valid_years": self.VALID_YEARS,
"week_events": week_events,
}
path = os.path.join(os.path.dirname(__file__), '../templates/event_list.html')
return template.render(path, template_values)
def _render(self, year=None, explicit_year=False):
state_prov = self.request.get('state_prov', None)
all_events_future = event_query.EventListQuery(year).fetch_async() # Needed for state_prov
if state_prov:
events_future = Event.query(Event.year==year, Event.state_prov==state_prov).fetch_async()
else:
events_future = all_events_future
events = events_future.get_result()
if state_prov == '' or (state_prov and not events):
self.redirect(self.request.path, abort=True)
EventHelper.sort_events(events)
week_events = EventHelper.groupByWeek(events)
district_enums = set()
for event in events:
if event.event_district_enum is not None and event.event_district_enum != DistrictType.NO_DISTRICT:
district_enums.add(event.event_district_enum)
districts = [] # a tuple of (district abbrev, district name)
for district_enum in district_enums:
districts.append((DistrictType.type_abbrevs[district_enum],
DistrictType.type_names[district_enum]))
districts = sorted(districts, key=lambda d: d[1])
valid_state_provs = set()
for event in all_events_future.get_result():
if event.state_prov:
valid_state_provs.add(event.state_prov)
valid_state_provs = sorted(valid_state_provs)
self.template_values.update({
"events": events,
"explicit_year": explicit_year,
"selected_year": year,
"valid_years": self.VALID_YEARS,
"week_events": week_events,
"districts": districts,
"state_prov": state_prov,
"valid_state_provs": valid_state_provs,
})
return jinja2_engine.render('event_list.html', self.template_values)
def _render(self, year=None, explicit_year=False):
state_prov = self.request.get('state_prov', None)
districts_future = DistrictsInYearQuery(year).fetch_async()
all_events_future = event_query.EventListQuery(year).fetch_async() # Needed for state_prov
if state_prov:
events_future = Event.query(Event.year==year, Event.state_prov==state_prov).fetch_async()
else:
events_future = all_events_future
events = events_future.get_result()
if state_prov == '' or (state_prov and not events):
self.redirect(self.request.path, abort=True)
EventHelper.sort_events(events)
week_events = EventHelper.groupByWeek(events)
districts = [] # a tuple of (district abbrev, district name)
for district in districts_future.get_result():
districts.append((district.abbreviation, district.display_name))
districts = sorted(districts, key=lambda d: d[1])
valid_state_provs = set()
for event in all_events_future.get_result():
if event.state_prov:
valid_state_provs.add(event.state_prov)
valid_state_provs = sorted(valid_state_provs)
self.template_values.update({
"events": events,
"explicit_year": explicit_year,
"selected_year": year,
"valid_years": self.VALID_YEARS,
"week_events": week_events,
"districts": districts,
"state_prov": state_prov,
"valid_state_provs": valid_state_provs,
})
if year == datetime.datetime.now().year:
self._cache_expiration = self.SHORT_CACHE_EXPIRATION
return jinja2_engine.render('event_list.html', self.template_values)
def _render(self, year=None, explicit_year=False):
event_keys = Event.query(Event.year == year).fetch(1000,
keys_only=True)
events = ndb.get_multi(event_keys)
EventHelper.sort_events(events)
week_events = EventHelper.groupByWeek(events)
template_values = {
"events": events,
"explicit_year": explicit_year,
"selected_year": year,
"valid_years": self.VALID_YEARS,
"week_events": week_events,
}
path = os.path.join(os.path.dirname(__file__),
'../templates/event_list.html')
return template.render(path, template_values)
def _render(self, year=None, explicit_year=False):
show_upcoming = (year == datetime.datetime.now().year)
events = Event.query(Event.year == year).order(Event.start_date).fetch(1000)
week_events = None
if year >= 2005:
week_events = EventHelper.groupByWeek(events)
template_values = {
"show_upcoming": show_upcoming,
"events": events,
"week_events": week_events,
"explicit_year": explicit_year,
"selected_year": year,
"valid_years": self.VALID_YEARS,
}
path = os.path.join(os.path.dirname(__file__), '../templates/event_list.html')
return template.render(path, template_values)
def test_group_by_week(self):
"""
All events that start in the same span of Wednesday-Tuesday
should be considered as being in the same week.
"""
events_by_week = {} # we will use this as the "answer key"
# Generate random regional events
seed = int(time.time())
state = random.Random()
state.seed(seed)
event_id_counter = 0
week_start = datetime.datetime(2013, 2, 27)
for i in range(1, 7): # test for 6 weeks
for _ in range(state.randint(
1, 15)): # random number of events per week
week_label = REGIONAL_EVENTS_LABEL.format(i)
start_date = week_start + datetime.timedelta(
days=state.randint(0, 6))
end_date = start_date + datetime.timedelta(
days=state.randint(0, 3))
event = Event(id='2013tst{}'.format(event_id_counter),
event_short='tst{}'.format(event_id_counter),
start_date=start_date,
end_date=end_date,
official=True,
event_type_enum=state.choice([
EventType.REGIONAL, EventType.DISTRICT,
EventType.DISTRICT_CMP
]))
if week_label in events_by_week:
events_by_week[week_label].append(event)
else:
events_by_week[week_label] = [event]
event_id_counter += 1
week_start = week_start + datetime.timedelta(days=7)
# Generate Championship events
week_start += datetime.timedelta(days=7)
events_by_week[CHAMPIONSHIP_EVENTS_LABEL] = [
Event(id='2013arc'.format(event_id_counter),
event_short='arc',
start_date=week_start,
end_date=week_start + datetime.timedelta(days=2),
official=True,
event_type_enum=EventType.CMP_DIVISION),
Event(id='2013gal'.format(event_id_counter),
event_short='gal',
start_date=week_start,
end_date=week_start + datetime.timedelta(days=2),
official=True,
event_type_enum=EventType.CMP_DIVISION),
Event(id='2013cmp'.format(event_id_counter),
event_short='cmp',
start_date=week_start + datetime.timedelta(days=2),
end_date=week_start + datetime.timedelta(days=2),
official=True,
event_type_enum=EventType.CMP_FINALS)
]
# Generate official events with no dates
events_by_week[WEEKLESS_EVENTS_LABEL] = [
Event(id='2013weekless1'.format(event_id_counter),
event_short='weekless1',
official=True,
event_type_enum=state.choice([
EventType.REGIONAL, EventType.DISTRICT,
EventType.DISTRICT_CMP
])),
Event(id='2013weekless2'.format(event_id_counter),
event_short='weekless2',
official=True,
event_type_enum=state.choice([
EventType.REGIONAL, EventType.DISTRICT,
EventType.DISTRICT_CMP
])),
Event(id='2013weekless3'.format(event_id_counter),
event_short='weekless3',
official=True,
event_type_enum=state.choice([
EventType.REGIONAL, EventType.DISTRICT,
EventType.DISTRICT_CMP
])),
Event(id='2013weekless4'.format(event_id_counter),
event_short='weekless4',
start_date=datetime.datetime(2013, 12, 31),
end_date=datetime.datetime(2013, 12, 31),
official=True,
event_type_enum=state.choice([
EventType.REGIONAL, EventType.DISTRICT,
EventType.DISTRICT_CMP
]))
]
# Generate preseason events
events_by_week[PRESEASON_EVENTS_LABEL] = [
Event(id='2013preseason1'.format(event_id_counter),
event_short='preseason1',
official=False,
event_type_enum=EventType.PRESEASON),
Event(id='2013preseason2'.format(event_id_counter),
event_short='preseason2',
start_date=datetime.datetime(2013, 1, 18),
end_date=datetime.datetime(2013, 1, 20),
official=False,
event_type_enum=EventType.PRESEASON),
Event(id='2013preseason3'.format(event_id_counter),
event_short='preseason3',
start_date=datetime.datetime(2013, 7, 11),
end_date=datetime.datetime(2013, 7, 12),
official=False,
event_type_enum=EventType.PRESEASON)
]
# Generate offseason events. Offseason events are any event that doesn't fall under one of the above categories.
events_by_week[OFFSEASON_EVENTS_LABEL] = [
Event(id='2013offseason1'.format(event_id_counter),
event_short='offseason1',
official=False,
event_type_enum=EventType.OFFSEASON),
Event(id='2013offseason2'.format(event_id_counter),
event_short='offseason2',
start_date=datetime.datetime(2013, 8, 18),
end_date=datetime.datetime(2013, 8, 20),
official=False,
event_type_enum=EventType.OFFSEASON),
Event(id='2013offseason3'.format(event_id_counter),
event_short='offseason3',
start_date=datetime.datetime(2013, 12, 30),
end_date=datetime.datetime(2013, 12, 31),
official=False,
event_type_enum=EventType.OFFSEASON),
Event(id='2013offseason4'.format(event_id_counter),
event_short='offseason4',
start_date=datetime.datetime(2013, 11, 13),
end_date=datetime.datetime(2013, 11, 14),
official=False,
event_type_enum=EventType.REGIONAL)
]
# Combine all events and shufle randomly
events = []
for week_events in events_by_week.values():
events.extend(week_events)
state.shuffle(events)
# Begin testing
events.sort(key=EventHelper.distantFutureIfNoStartDate)
week_events = EventHelper.groupByWeek(events)
for key in events_by_week.keys():
try:
self.assertEqual(
set([e.key.id() for e in events_by_week[key]]),
set([e.key.id() for e in week_events[key]]))
except AssertionError, e:
logging.warning("\n\nseed: {}".format(seed))
logging.warning("\n\nkey: {}".format(key))
logging.warning("\n\nevents_by_week: {}".format(
events_by_week[key]))
logging.warning("\n\nweek_events: {}".format(week_events[key]))
raise e
def _render(self, district_abbrev, year=None, explicit_year=False):
district = DistrictQuery('{}{}'.format(year, district_abbrev)).fetch()
if not district:
self.abort(404)
events_future = DistrictEventsQuery(district.key_name).fetch_async()
# needed for district teams
district_teams_future = DistrictTeamsQuery(district.key_name).fetch_async()
# needed for valid_years
history_future = DistrictHistoryQuery(district.abbreviation).fetch_async()
# needed for valid_districts
districts_in_year_future = DistrictsInYearQuery(district.year).fetch_async()
# Temp disabled on 2017-02-18 -fangeugene
# # Needed for active team statuses
# live_events = []
# if year == datetime.datetime.now().year: # Only show active teams for current year
# live_events = EventHelper.getWeekEvents()
# live_eventteams_futures = []
# for event in live_events:
# live_eventteams_futures.append(EventTeamsQuery(event.key_name).fetch_async())
events = events_future.get_result()
EventHelper.sort_events(events)
events_by_key = {}
for event in events:
events_by_key[event.key.id()] = event
week_events = EventHelper.groupByWeek(events)
valid_districts = set()
districts_in_year = districts_in_year_future.get_result()
for dist in districts_in_year:
valid_districts.add((dist.display_name, dist.abbreviation))
valid_districts = sorted(valid_districts, key=lambda (name, _): name)
teams = TeamHelper.sortTeams(district_teams_future.get_result())
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:]
# Temp disabled on 2017-02-18 -fangeugene
# # Currently Competing Team Status
# live_events_with_teams = EventTeamStatusHelper.buildEventTeamStatus(live_events, live_eventteams_futures, teams)
# live_events_with_teams.sort(key=lambda x: x[0].name)
# Get valid years
district_history = history_future.get_result()
valid_years = map(lambda d: d.year, district_history)
valid_years = sorted(valid_years)
self.template_values.update({
'explicit_year': explicit_year,
'year': year,
'valid_years': valid_years,
'valid_districts': valid_districts,
'district_name': district.display_name,
'district_abbrev': district_abbrev,
'week_events': week_events,
'events_by_key': events_by_key,
'rankings': district.rankings,
'teams_a': teams_a,
'teams_b': teams_b,
# 'live_events_with_teams': live_events_with_teams, # Temp disabled on 2017-02-18 -fangeugene
})
return jinja2_engine.render('district_details.html', self.template_values)
def test_group_by_week(self):
"""
All events that start in the same span of Wednesday-Tuesday
should be considered as being in the same week.
"""
events_by_week = {} # we will use this as the "answer key"
# Generate random regional events
seed = int(time.time())
state = random.Random()
state.seed(seed)
event_id_counter = 0
week_start = datetime.datetime(2013, 2, 27)
for i in range(1, 7): # test for 6 weeks
for _ in range(state.randint(1, 15)): # random number of events per week
week_label = REGIONAL_EVENTS_LABEL.format(i)
start_date = week_start + datetime.timedelta(days=state.randint(0, 6))
end_date = start_date + datetime.timedelta(days=state.randint(0, 3))
event = Event(
id='2013tst{}'.format(event_id_counter),
event_short='tst{}'.format(event_id_counter),
start_date=start_date,
end_date=end_date,
official=True,
event_type_enum=state.choice([EventType.REGIONAL, EventType.DISTRICT, EventType.DISTRICT_CMP])
)
if week_label in events_by_week:
events_by_week[week_label].append(event)
else:
events_by_week[week_label] = [event]
event_id_counter += 1
week_start = week_start + datetime.timedelta(days=7)
# Generate Championship events
week_start += datetime.timedelta(days=7)
events_by_week[CHAMPIONSHIP_EVENTS_LABEL] = [
Event(
id='2013arc'.format(event_id_counter),
event_short='arc',
start_date=week_start,
end_date=week_start + datetime.timedelta(days=2),
official=True,
event_type_enum=EventType.CMP_DIVISION
),
Event(
id='2013gal'.format(event_id_counter),
event_short='gal',
start_date=week_start,
end_date=week_start + datetime.timedelta(days=2),
official=True,
event_type_enum=EventType.CMP_DIVISION
),
Event(
id='2013cmp'.format(event_id_counter),
event_short='cmp',
start_date=week_start + datetime.timedelta(days=2),
end_date=week_start + datetime.timedelta(days=2),
official=True,
event_type_enum=EventType.CMP_FINALS
)
]
# Generate official events with no dates
events_by_week[WEEKLESS_EVENTS_LABEL] = [
Event(
id='2013weekless1'.format(event_id_counter),
event_short='weekless1',
official=True,
event_type_enum=state.choice([EventType.REGIONAL, EventType.DISTRICT, EventType.DISTRICT_CMP])
),
Event(
id='2013weekless2'.format(event_id_counter),
event_short='weekless2',
official=True,
event_type_enum=state.choice([EventType.REGIONAL, EventType.DISTRICT, EventType.DISTRICT_CMP])
),
Event(
id='2013weekless3'.format(event_id_counter),
event_short='weekless3',
official=True,
event_type_enum=state.choice([EventType.REGIONAL, EventType.DISTRICT, EventType.DISTRICT_CMP])
),
Event(
id='2013weekless4'.format(event_id_counter),
event_short='weekless4',
start_date=datetime.datetime(2013, 12, 31),
end_date=datetime.datetime(2013, 12, 31),
official=True,
event_type_enum=state.choice([EventType.REGIONAL, EventType.DISTRICT, EventType.DISTRICT_CMP])
)
]
# Generate preseason events
events_by_week[PRESEASON_EVENTS_LABEL] = [
Event(
id='2013preseason1'.format(event_id_counter),
event_short='preseason1',
official=False,
event_type_enum=EventType.PRESEASON
),
Event(
id='2013preseason2'.format(event_id_counter),
event_short='preseason2',
start_date=datetime.datetime(2013, 1, 18),
end_date=datetime.datetime(2013, 1, 20),
official=False,
event_type_enum=EventType.PRESEASON
),
Event(
id='2013preseason3'.format(event_id_counter),
event_short='preseason3',
start_date=datetime.datetime(2013, 7, 11),
end_date=datetime.datetime(2013, 7, 12),
official=False,
event_type_enum=EventType.PRESEASON
)
]
# Generate offseason events. Offseason events are any event that doesn't fall under one of the above categories.
events_by_week[OFFSEASON_EVENTS_LABEL] = [
Event(
id='2013offseason1'.format(event_id_counter),
event_short='offseason1',
official=False,
event_type_enum=EventType.OFFSEASON
),
Event(
id='2013offseason2'.format(event_id_counter),
event_short='offseason2',
start_date=datetime.datetime(2013, 8, 18),
end_date=datetime.datetime(2013, 8, 20),
official=False,
event_type_enum=EventType.OFFSEASON
),
Event(
id='2013offseason3'.format(event_id_counter),
event_short='offseason3',
start_date=datetime.datetime(2013, 12, 30),
end_date=datetime.datetime(2013, 12, 31),
official=False,
event_type_enum=EventType.OFFSEASON
),
Event(
id='2013offseason4'.format(event_id_counter),
event_short='offseason4',
start_date=datetime.datetime(2013, 11, 13),
end_date=datetime.datetime(2013, 11, 14),
official=False,
event_type_enum=EventType.REGIONAL
)
]
# Combine all events and shufle randomly
events = []
for week_events in events_by_week.values():
events.extend(week_events)
state.shuffle(events)
# Begin testing
events.sort(key=EventHelper.distantFutureIfNoStartDate)
week_events = EventHelper.groupByWeek(events)
for key in events_by_week.keys():
try:
self.assertEqual(set([e.key.id() for e in events_by_week[key]]),
set([e.key.id() for e in week_events[key]]))
except AssertionError, e:
logging.warning("\n\nseed: {}".format(seed))
logging.warning("\n\nkey: {}".format(key))
logging.warning("\n\nevents_by_week: {}".format(events_by_week[key]))
logging.warning("\n\nweek_events: {}".format(week_events[key]))
raise e
def _render(self, district_abbrev, year=None, explicit_year=False):
district = DistrictQuery('{}{}'.format(year, district_abbrev)).fetch()
if not district:
self.abort(404)
events_future = DistrictEventsQuery(district.key_name).fetch_async()
# needed for district teams
district_teams_future = DistrictTeamsQuery(
district.key_name).fetch_async()
# needed for valid_years
history_future = DistrictHistoryQuery(
district.abbreviation).fetch_async()
# needed for valid_districts
districts_in_year_future = DistrictsInYearQuery(
district.year).fetch_async()
# needed for active team statuses
live_events = []
if year == datetime.datetime.now(
).year: # Only show active teams for current year
live_events = EventHelper.getWeekEvents()
live_eventteams_futures = []
for event in live_events:
live_eventteams_futures.append(
EventTeamsQuery(event.key_name).fetch_async())
events = events_future.get_result()
EventHelper.sort_events(events)
events_by_key = {}
for event in events:
events_by_key[event.key.id()] = event
week_events = EventHelper.groupByWeek(events)
valid_districts = set()
districts_in_year = districts_in_year_future.get_result()
for dist in districts_in_year:
valid_districts.add((dist.display_name, dist.abbreviation))
valid_districts = sorted(valid_districts, key=lambda (name, _): name)
teams = TeamHelper.sortTeams(district_teams_future.get_result())
team_keys = set([t.key.id() for t in 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:]
# Currently Competing Team Status
event_team_keys = []
for event, teams_future in zip(live_events, live_eventteams_futures):
for team in teams_future.get_result():
if team.key.id() in team_keys:
event_team_keys.append(
ndb.Key(EventTeam, '{}_{}'.format(
event.key.id(),
team.key.id()))) # Should be in context cache
ndb.get_multi(event_team_keys) # Warms context cache
live_events_with_teams = []
for event, teams_future in zip(live_events, live_eventteams_futures):
teams_and_statuses = []
has_teams = False
for team in teams_future.get_result():
if team.key.id() in team_keys:
has_teams = True
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))
if has_teams:
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]))
# Get valid years
district_history = history_future.get_result()
valid_years = map(lambda d: d.year, district_history)
valid_years = sorted(valid_years)
self.template_values.update({
'explicit_year':
explicit_year,
'year':
year,
'valid_years':
valid_years,
'valid_districts':
valid_districts,
'district_name':
district.display_name,
'district_abbrev':
district_abbrev,
'week_events':
week_events,
'events_by_key':
events_by_key,
'rankings':
district.rankings,
'advancement':
district.advancement,
'teams_a':
teams_a,
'teams_b':
teams_b,
'live_events_with_teams':
live_events_with_teams,
})
return jinja2_engine.render('district_details.html',
self.template_values)
def _render(self, district_abbrev, year=None, explicit_year=False):
district_type = DistrictType.abbrevs[district_abbrev]
event_keys = Event.query(
Event.year == year,
Event.event_district_enum == district_type).fetch(None,
keys_only=True)
if not event_keys:
self.abort(404)
# needed for district teams
district_key = '{}{}'.format(year, district_abbrev)
district_teams_future = DistrictTeamsQuery(district_key).fetch_async()
# needed for valid_years
all_cmp_event_keys_future = Event.query(
Event.event_district_enum == district_type,
Event.event_type_enum == EventType.DISTRICT_CMP).fetch_async(
None, keys_only=True)
# needed for valid_districts
district_cmp_keys_future = Event.query(
Event.year == year,
Event.event_type_enum == EventType.DISTRICT_CMP).fetch_async(
None, keys_only=True) # to compute valid_districts
# Needed for active team statuses
live_events = []
if year == datetime.datetime.now(
).year: # Only show active teams for current year
live_events = EventHelper.getWeekEvents()
live_eventteams_futures = []
for event in live_events:
live_eventteams_futures.append(
EventTeamsQuery(event.key_name).fetch_async())
event_futures = ndb.get_multi_async(event_keys)
event_team_keys_future = EventTeam.query(
EventTeam.event.IN(event_keys)).fetch_async(None, keys_only=True)
team_futures = ndb.get_multi_async(
set([
ndb.Key(Team,
et_key.id().split('_')[1])
for et_key in event_team_keys_future.get_result()
]))
events = [event_future.get_result() for event_future in event_futures]
EventHelper.sort_events(events)
week_events = EventHelper.groupByWeek(events)
district_cmp_futures = ndb.get_multi_async(
district_cmp_keys_future.get_result())
team_totals = DistrictHelper.calculate_rankings(
events, team_futures, year)
valid_districts = set()
for district_cmp_future in district_cmp_futures:
district_cmp = district_cmp_future.get_result()
cmp_dis_type = district_cmp.event_district_enum
if cmp_dis_type is None:
logging.warning(
"District event {} has unknown district type!".format(
district_cmp.key.id()))
else:
valid_districts.add((DistrictType.type_names[cmp_dis_type],
DistrictType.type_abbrevs[cmp_dis_type]))
valid_districts = sorted(valid_districts, key=lambda (name, _): name)
teams = TeamHelper.sortTeams(district_teams_future.get_result())
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:]
# Currently Competing Team Status
live_events_with_teams = EventTeamStatusHelper.buildEventTeamStatus(
live_events, live_eventteams_futures, teams)
live_events_with_teams.sort(key=lambda x: x[0].name)
self.template_values.update({
'explicit_year':
explicit_year,
'year':
year,
'valid_years':
sorted(
set([
int(event_key.id()[:4])
for event_key in all_cmp_event_keys_future.get_result()
])),
'valid_districts':
valid_districts,
'district_name':
DistrictType.type_names[district_type],
'district_abbrev':
district_abbrev,
'week_events':
week_events,
'team_totals':
team_totals,
'teams_a':
teams_a,
'teams_b':
teams_b,
'live_events_with_teams':
live_events_with_teams,
})
return jinja2_engine.render('district_details.html',
self.template_values)
def _render(self, district_abbrev, year=None, explicit_year=False):
district = DistrictQuery('{}{}'.format(year, district_abbrev)).fetch()
if not district:
self.abort(404)
events_future = DistrictEventsQuery(district.key_name).fetch_async()
# needed for district teams
district_teams_future = DistrictTeamsQuery(district.key_name).fetch_async()
# needed for valid_years
history_future = DistrictHistoryQuery(district.abbreviation).fetch_async()
# needed for valid_districts
districts_in_year_future = DistrictsInYearQuery(district.year).fetch_async()
# needed for active team statuses
live_events = []
if year == datetime.datetime.now().year: # Only show active teams for current year
live_events = EventHelper.getWeekEvents()
live_eventteams_futures = []
for event in live_events:
live_eventteams_futures.append(EventTeamsQuery(event.key_name).fetch_async())
events = events_future.get_result()
EventHelper.sort_events(events)
events_by_key = {}
for event in events:
events_by_key[event.key.id()] = event
week_events = EventHelper.groupByWeek(events)
valid_districts = set()
districts_in_year = districts_in_year_future.get_result()
for dist in districts_in_year:
valid_districts.add((dist.display_name, dist.abbreviation))
valid_districts = sorted(valid_districts, key=lambda (name, _): name)
teams = TeamHelper.sortTeams(district_teams_future.get_result())
team_keys = set([t.key.id() for t in 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:]
# Currently Competing Team Status
event_team_keys = []
for event, teams_future in zip(live_events, live_eventteams_futures):
for team in teams_future.get_result():
if team.key.id() in team_keys:
event_team_keys.append(ndb.Key(EventTeam, '{}_{}'.format(event.key.id(), team.key.id()))) # Should be in context cache
ndb.get_multi(event_team_keys) # Warms context cache
live_events_with_teams = []
for event, teams_future in zip(live_events, live_eventteams_futures):
teams_and_statuses = []
has_teams = False
for team in teams_future.get_result():
if team.key.id() in team_keys:
has_teams = True
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
))
if has_teams:
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]))
# Get valid years
district_history = history_future.get_result()
valid_years = map(lambda d: d.year, district_history)
valid_years = sorted(valid_years)
self.template_values.update({
'explicit_year': explicit_year,
'year': year,
'valid_years': valid_years,
'valid_districts': valid_districts,
'district_name': district.display_name,
'district_abbrev': district_abbrev,
'week_events': week_events,
'events_by_key': events_by_key,
'rankings': district.rankings,
'advancement': district.advancement,
'teams_a': teams_a,
'teams_b': teams_b,
'live_events_with_teams': live_events_with_teams,
})
return jinja2_engine.render('district_details.html', self.template_values)
def _render(self, district_abbrev, year=None, explicit_year=False):
district_type = DistrictType.abbrevs[district_abbrev]
event_keys = Event.query(Event.year == year, Event.event_district_enum == district_type).fetch(None, keys_only=True)
if not event_keys:
self.abort(404)
# needed for district teams
district_key = '{}{}'.format(year, district_abbrev)
district_teams_future = DistrictTeamsQuery(district_key).fetch_async()
# needed for valid_years
all_cmp_event_keys_future = Event.query(Event.event_district_enum == district_type, Event.event_type_enum == EventType.DISTRICT_CMP).fetch_async(None, keys_only=True)
# needed for valid_districts
district_cmp_keys_future = Event.query(Event.year == year, Event.event_type_enum == EventType.DISTRICT_CMP).fetch_async(None, keys_only=True) # to compute valid_districts
# Needed for active team statuses
live_events = []
if year == datetime.datetime.now().year: # Only show active teams for current year
live_events = EventHelper.getWeekEvents()
live_eventteams_futures = []
for event in live_events:
live_eventteams_futures.append(EventTeamsQuery(event.key_name).fetch_async())
event_futures = ndb.get_multi_async(event_keys)
event_team_keys_future = EventTeam.query(EventTeam.event.IN(event_keys)).fetch_async(None, keys_only=True)
team_futures = ndb.get_multi_async(set([ndb.Key(Team, et_key.id().split('_')[1]) for et_key in event_team_keys_future.get_result()]))
events = [event_future.get_result() for event_future in event_futures]
EventHelper.sort_events(events)
week_events = EventHelper.groupByWeek(events)
district_cmp_futures = ndb.get_multi_async(district_cmp_keys_future.get_result())
team_totals = DistrictHelper.calculate_rankings(events, team_futures, year)
valid_districts = set()
for district_cmp_future in district_cmp_futures:
district_cmp = district_cmp_future.get_result()
cmp_dis_type = district_cmp.event_district_enum
if cmp_dis_type is None:
logging.warning("District event {} has unknown district type!".format(district_cmp.key.id()))
else:
valid_districts.add((DistrictType.type_names[cmp_dis_type], DistrictType.type_abbrevs[cmp_dis_type]))
valid_districts = sorted(valid_districts, key=lambda (name, _): name)
teams = TeamHelper.sortTeams(district_teams_future.get_result())
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:]
# Currently Competing Team Status
live_events_with_teams = EventTeamStatusHelper.buildEventTeamStatus(live_events, live_eventteams_futures, teams)
live_events_with_teams.sort(key=lambda x: x[0].name)
self.template_values.update({
'explicit_year': explicit_year,
'year': year,
'valid_years': sorted(set([int(event_key.id()[:4]) for event_key in all_cmp_event_keys_future.get_result()])),
'valid_districts': valid_districts,
'district_name': DistrictType.type_names[district_type],
'district_abbrev': district_abbrev,
'week_events': week_events,
'team_totals': team_totals,
'teams_a': teams_a,
'teams_b': teams_b,
'live_events_with_teams': live_events_with_teams,
})
return jinja2_engine.render('district_details.html', self.template_values)
