def _apply_points(self):
"""
Apply points for Standings Report
"""
if self.date in Report.NON_POINTS_EVENT_DATES:
# Test & Tune, Hangover generally not pointed
return
if self._log_splitter.driver_type == RallyDriver:
# No Points for Rally Events
return
data = defaultdict(dict)
for driver in self.drivers:
dname = Canon(driver.name).name
if driver.primary_score() == GenericDriver.INF:
# No points unless you scored
print(f'{dname} did not score')
continue
pax_points = self._point(self.PAX_STRING)
if pax_points > 0:
data[self.PAX_STRING][dname] = pax_points
car_class = driver.car_class.lower()
car_class_points = self._point(car_class)
if car_class_points > 0:
data[car_class][dname] = car_class_points
print(
f'{dname} awarded {pax_points} (pax), {car_class_points} ({car_class})'
)
Shared.REDIS.set(f'points-from-{self.date}', json.dumps(data))
def test_name(self):
data = {'Hi There' : 'Hi There',
' Bona Fide ' : 'Bona Fide',
'Mr. Robinson': 'Mr Robinson',
'mr_tee' : 'Mr Tee'}
for name_or_slug, expected_name in data.items():
slug = Canon(name_or_slug).name
self.assertEqual(slug, expected_name)
def test_slug(self):
data = {'Hi There' : 'hi_there',
' Bona Fide ' : 'bona_fide',
'Mr. Robinson': 'mr_robinson',
'mr_tee' : 'mr_tee',
'Corey Pettet': 'corey_pettett',}
for name_or_slug, expected_slug in data.items():
slug = Canon(name_or_slug).slug
self.assertEqual(slug, expected_slug)
def driver_view(request):
slug_from_url = request.matchdict.get('slug')
canon = Canon(slug_from_url)
slug = canon.slug
name = canon.name
gossip = Gossip(slug)
photos = Photo.all_for_driver(slug)
event_dates_by_year = PublishedEvent.dates_by_year()
fond_memories = FondMemory.all_for_driver(slug)
return dict(name=name,
photos=photos,
gossip=gossip.html(),
event_dates_by_year=event_dates_by_year,
fond_memories=fond_memories)
def admin_generate_run_groups_view(request):
drivers_etc_json = REDIS.get(Shared.REDIS_KEY_LIVE_EVENT_DRIVERS)
drivers_etc = json.loads(drivers_etc_json)
data = defaultdict(list)
drivers = drivers_etc['drivers']
for driver in drivers:
driver_name = driver['name']
car_class = driver['car_class']
driver_slug = Canon(driver_name).slug
data[car_class].append((driver_name, driver_slug))
run_groups, counter = Util.randomize_run_groups(data)
redis_data = dict(run_groups=run_groups,
counter=counter,
num_drivers=len(drivers))
REDIS.set(Shared.REDIS_KEY_LIVE_EVENT_RUN_GROUPS, json.dumps(redis_data))
return HTTPFound(location='/admin/run_groups')
def _build(self):
# points for each event separately
# used for filling in the table
events = dict()
# points for all events together
# -- uses a defaultdict with inner defaultdict(int) --
totals = defaultdict(lambda: defaultdict(list))
for key in self._redis_keys():
json_data = Shared.REDIS.get(key)
data_for_one_event = json.loads(json_data)
date = key.replace(self.KEY_PREPEND, '')
events[date] = data_for_one_event
for pax_or_car_class, nested_data in data_for_one_event.items():
for driver_name, points in nested_data.items():
canonical_driver_name = Canon(driver_name).name
self._car_classes.add(pax_or_car_class)
totals[pax_or_car_class][canonical_driver_name].append(
points)
self._totals = totals
self._events = events
def slug_and_head_shot(cls, name):
slug = Canon(name).slug
head_shot = cls._head_shots_memoized().get(slug)
if not head_shot:
return {}
return dict(slug=slug, head_shot=head_shot)
def driver_name(self):
name = Canon(self.driver_slug).name
return name
def driver_slug(self):
"""
The url-friendly version of a driver's name
"""
return Canon(self.name).slug
def name(self):
"""
The driver's name. Example: 'Jonathan Hasty'
"""
return Canon(self._row_1[3]).name
def __redis_key(self):
driver_slug = Canon(self._driver.name).slug
key = f'{self.REDIS_KEY_PREPEND}--{driver_slug}--{self._event_date}'
return key