christoph/flask-formula10
1
Fork 0
Code Issues 14 Actions Packages Activity

Bug: Fix duplicated place numbering in points model
All checks were successful
Build Formula10 Docker Image / build-docker (push) Successful in 14s
Details

Browse Source
This commit is contained in:
Christoph Urlacher
2024-10-19 14:01:46 +02:00
parent f38a5f2e6d
commit 61d247508f
1 changed files with 242 additions and 88 deletions
Download Patch File Download Diff File Expand all files Collapse all files

330
formula10/domain/points_model.py
View File

@ -14,12 +14,7 @@ from formula10.domain.model.user import User
# Guess points # Guess points
RACE_GUESS_OFFSET_POINTS: Dict[int, int] = { RACE_GUESS_OFFSET_POINTS: Dict[int, int] = {3: 1, 2: 3, 1: 6, 0: 10}
3: 1,
2: 3,
1: 6,
0: 10
}
RACE_GUESS_DNF_POINTS: int = 10 RACE_GUESS_DNF_POINTS: int = 10
SEASON_GUESS_HOT_TAKE_POINTS: int = 10 SEASON_GUESS_HOT_TAKE_POINTS: int = 10
SEASON_GUESS_P2_POINTS: int = 10 SEASON_GUESS_P2_POINTS: int = 10
@ -44,18 +39,9 @@ DRIVER_RACE_POINTS: Dict[int, int] = {
7: 6, 7: 6,
8: 4, 8: 4,
9: 2, 9: 2,
10: 1 10: 1,
}
DRIVER_SPRINT_POINTS: Dict[int, int] = {
1: 8,
2: 7,
3: 6,
4: 5,
5: 4,
6: 3,
7: 2,
8: 1
} }
DRIVER_SPRINT_POINTS: Dict[int, int] = {1: 8, 2: 7, 3: 6, 4: 5, 5: 4, 6: 3, 7: 2, 8: 1}
DRIVER_FASTEST_LAP_POINTS: int = 1 DRIVER_FASTEST_LAP_POINTS: int = 1
# Last season results # Last season results
@ -80,7 +66,7 @@ WDC_STANDING_2023: Dict[str, int] = {
"Daniel Ricciardo": 17, "Daniel Ricciardo": 17,
"Zhou Guanyu": 18, "Zhou Guanyu": 18,
"Kevin Magnussen": 19, "Kevin Magnussen": 19,
"Logan Sargeant": 21 "Logan Sargeant": 21,
} }
WCC_STANDING_2023: Dict[str, int] = { WCC_STANDING_2023: Dict[str, int] = {
"Red Bull": 1, "Red Bull": 1,
@ -92,11 +78,14 @@ WCC_STANDING_2023: Dict[str, int] = {
"Williams": 7, "Williams": 7,
"VCARB": 8, "VCARB": 8,
"Sauber": 9, "Sauber": 9,
"Haas": 10 "Haas": 10,
} }
def standing_points(race_guess: RaceGuess, race_result: RaceResult) -> int: def standing_points(race_guess: RaceGuess, race_result: RaceResult) -> int:
guessed_driver_position: int | None = race_result.driver_standing_position(driver=race_guess.pxx_guess) guessed_driver_position: int | None = race_result.driver_standing_position(
driver=race_guess.pxx_guess
)
if guessed_driver_position is None: if guessed_driver_position is None:
return 0 return 0
@ -106,6 +95,7 @@ def standing_points(race_guess: RaceGuess, race_result: RaceResult) -> int:
return RACE_GUESS_OFFSET_POINTS[position_offset] return RACE_GUESS_OFFSET_POINTS[position_offset]
def dnf_points(race_guess: RaceGuess, race_result: RaceResult) -> int: def dnf_points(race_guess: RaceGuess, race_result: RaceResult) -> int:
if race_guess.dnf_guess in race_result.initial_dnf: if race_guess.dnf_guess in race_result.initial_dnf:
return RACE_GUESS_DNF_POINTS return RACE_GUESS_DNF_POINTS
@ -115,6 +105,7 @@ def dnf_points(race_guess: RaceGuess, race_result: RaceResult) -> int:
return 0 return 0
class PointsModel(Model): class PointsModel(Model):
""" """
This class bundles all data + functionality required to do points calculations. This class bundles all data + functionality required to do points calculations.
@ -123,51 +114,76 @@ class PointsModel(Model):
def __init__(self): def __init__(self):
Model.__init__(self) Model.__init__(self)
@cache.cached(timeout=None, key_prefix="points_points_per_step") # Clear when adding/updating race results or users @cache.cached(
timeout=None, key_prefix="points_points_per_step"
) # Clear when adding/updating race results or users
def points_per_step(self) -> Dict[str, List[int]]: def points_per_step(self) -> Dict[str, List[int]]:
""" """
Returns a dictionary of lists, containing points per race for each user. Returns a dictionary of lists, containing points per race for each user.
""" """
points_per_step = dict() points_per_step = dict()
for user in self.all_users(): for user in self.all_users():
points_per_step[user.name] = [0] * (len(self.all_races()) + 1) # Start at index 1, like the race numbers points_per_step[user.name] = [0] * (
len(self.all_races()) + 1
) # Start at index 1, like the race numbers
for race_guess in self.all_race_guesses(): for race_guess in self.all_race_guesses():
user_name: str = race_guess.user.name user_name: str = race_guess.user.name
race_number: int = race_guess.race.number race_number: int = race_guess.race.number
race_result: RaceResult | None = self.race_result_by(race_name=race_guess.race.name) race_result: RaceResult | None = self.race_result_by(
race_name=race_guess.race.name
)
if race_result is None: if race_result is None:
continue continue
points_per_step[user_name][race_number] = standing_points(race_guess, race_result) + dnf_points(race_guess, race_result) points_per_step[user_name][race_number] = standing_points(
race_guess, race_result
) + dnf_points(race_guess, race_result)
return points_per_step return points_per_step
@cache.memoize(timeout=None, args_to_ignore=["self"]) # Clear when adding/updating race results @cache.memoize(
timeout=None, args_to_ignore=["self"]
) # Clear when adding/updating race results
def driver_points_per_step(self, *, include_inactive: bool) -> Dict[str, List[int]]: def driver_points_per_step(self, *, include_inactive: bool) -> Dict[str, List[int]]:
""" """
Returns a dictionary of lists, containing points per race for each driver. Returns a dictionary of lists, containing points per race for each driver.
""" """
driver_points_per_step = dict() driver_points_per_step = dict()
for driver in self.all_drivers(include_none=False, include_inactive=include_inactive): for driver in self.all_drivers(
driver_points_per_step[driver.name] = [0] * (len(self.all_races()) + 1) # Start at index 1, like the race numbers include_none=False, include_inactive=include_inactive
):
driver_points_per_step[driver.name] = [0] * (
len(self.all_races()) + 1
) # Start at index 1, like the race numbers
for race_result in self.all_race_results(): for race_result in self.all_race_results():
race_number: int = race_result.race.number race_number: int = race_result.race.number
for position, driver in race_result.standing.items(): for position, driver in race_result.standing.items():
driver_points_per_step[driver.name][race_number] = DRIVER_RACE_POINTS[int(position)] if int(position) in DRIVER_RACE_POINTS else 0 driver_points_per_step[driver.name][race_number] = (
driver_points_per_step[driver.name][race_number] += DRIVER_FASTEST_LAP_POINTS if race_result.fastest_lap_driver == driver else 0 DRIVER_RACE_POINTS[int(position)]
if int(position) in DRIVER_RACE_POINTS
else 0
)
driver_points_per_step[driver.name][race_number] += (
DRIVER_FASTEST_LAP_POINTS
if race_result.fastest_lap_driver == driver
else 0
)
for position, driver in race_result.sprint_standing.items(): for position, driver in race_result.sprint_standing.items():
driver_name: str = driver.name driver_name: str = driver.name
driver_points_per_step[driver_name][race_number] += DRIVER_SPRINT_POINTS[int(position)] if int(position) in DRIVER_SPRINT_POINTS else 0 driver_points_per_step[driver_name][race_number] += (
DRIVER_SPRINT_POINTS[int(position)]
if int(position) in DRIVER_SPRINT_POINTS
else 0
)
return driver_points_per_step return driver_points_per_step
@cache.cached(timeout=None, key_prefix="points_team_points_per_step") @cache.cached(timeout=None, key_prefix="points_team_points_per_step")
def team_points_per_step(self) -> Dict[str, List[int]]: def team_points_per_step(self) -> Dict[str, List[int]]:
""" """
@ -175,14 +191,20 @@ class PointsModel(Model):
""" """
team_points_per_step = dict() team_points_per_step = dict()
for team in self.all_teams(include_none=False): for team in self.all_teams(include_none=False):
team_points_per_step[team.name] = [0] * (len(self.all_races()) + 1) # Start at index 1, like the race numbers team_points_per_step[team.name] = [0] * (
len(self.all_races()) + 1
) # Start at index 1, like the race numbers
for race_result in self.all_race_results(): for race_result in self.all_race_results():
for driver in race_result.standing.values(): for driver in race_result.standing.values():
team_name: str = driver.team.name team_name: str = driver.team.name
race_number: int = race_result.race.number race_number: int = race_result.race.number
team_points_per_step[team_name][race_number] += self.driver_points_per_step(include_inactive=True)[driver.name][race_number] team_points_per_step[team_name][
race_number
] += self.driver_points_per_step(include_inactive=True)[driver.name][
race_number
]
return team_points_per_step return team_points_per_step
@ -206,48 +228,78 @@ class PointsModel(Model):
# Driver stats # Driver stats
# #
@cache.cached(timeout=None, key_prefix="points_driver_points_per_step_cumulative") # Cleanup when adding/updating race results @cache.cached(
timeout=None, key_prefix="points_driver_points_per_step_cumulative"
) # Cleanup when adding/updating race results
def driver_points_per_step_cumulative(self) -> Dict[str, List[int]]: def driver_points_per_step_cumulative(self) -> Dict[str, List[int]]:
""" """
Returns a dictionary of lists, containing cumulative points per race for each driver. Returns a dictionary of lists, containing cumulative points per race for each driver.
""" """
points_per_step_cumulative: Dict[str, List[int]] = dict() points_per_step_cumulative: Dict[str, List[int]] = dict()
for driver_name, points in self.driver_points_per_step(include_inactive=True).items(): for driver_name, points in self.driver_points_per_step(
include_inactive=True
).items():
points_per_step_cumulative[driver_name] = np.cumsum(points).tolist() points_per_step_cumulative[driver_name] = np.cumsum(points).tolist()
return points_per_step_cumulative return points_per_step_cumulative
@overload @overload
def driver_points_by(self, *, driver_name: str, include_inactive: bool) -> List[int]: def driver_points_by(
self, *, driver_name: str, include_inactive: bool
) -> List[int]:
""" """
Returns a list of points per race for a specific driver. Returns a list of points per race for a specific driver.
""" """
return self.driver_points_by(driver_name=driver_name, include_inactive=include_inactive) return self.driver_points_by(
driver_name=driver_name, include_inactive=include_inactive
)
@overload @overload
def driver_points_by(self, *, race_name: str, include_inactive: bool) -> Dict[str, int]: def driver_points_by(
self, *, race_name: str, include_inactive: bool
) -> Dict[str, int]:
""" """
Returns a dictionary of points per driver for a specific race. Returns a dictionary of points per driver for a specific race.
""" """
return self.driver_points_by(race_name=race_name, include_inactive=include_inactive) return self.driver_points_by(
race_name=race_name, include_inactive=include_inactive
)
@overload @overload
def driver_points_by(self, *, driver_name: str, race_name: str, include_inactive: bool) -> int: def driver_points_by(
self, *, driver_name: str, race_name: str, include_inactive: bool
) -> int:
""" """
Returns the points for a specific race for a specific driver. Returns the points for a specific race for a specific driver.
""" """
return self.driver_points_by(driver_name=driver_name, race_name=race_name, include_inactive=include_inactive) return self.driver_points_by(
driver_name=driver_name,
race_name=race_name,
include_inactive=include_inactive,
)
@cache.memoize(timeout=None, args_to_ignore=["self"]) # Cleanup when adding/updating race results @cache.memoize(
def driver_points_by(self, *, driver_name: str | None = None, race_name: str | None = None, include_inactive: bool) -> List[int] | Dict[str, int] | int: timeout=None, args_to_ignore=["self"]
) # Cleanup when adding/updating race results
def driver_points_by(
self,
*,
driver_name: str | None = None,
race_name: str | None = None,
include_inactive: bool
) -> List[int] | Dict[str, int] | int:
if driver_name is not None and race_name is None: if driver_name is not None and race_name is None:
return self.driver_points_per_step(include_inactive=include_inactive)[driver_name] return self.driver_points_per_step(include_inactive=include_inactive)[
driver_name
]
if driver_name is None and race_name is not None: if driver_name is None and race_name is not None:
race_number: int = self.race_by(race_name=race_name).number race_number: int = self.race_by(race_name=race_name).number
points_by_race: Dict[str, int] = dict() points_by_race: Dict[str, int] = dict()
for _driver_name, points in self.driver_points_per_step(include_inactive=include_inactive).items(): for _driver_name, points in self.driver_points_per_step(
include_inactive=include_inactive
).items():
points_by_race[_driver_name] = points[race_number] points_by_race[_driver_name] = points[race_number]
return points_by_race return points_by_race
@ -255,24 +307,42 @@ class PointsModel(Model):
if driver_name is not None and race_name is not None: if driver_name is not None and race_name is not None:
race_number: int = self.race_by(race_name=race_name).number race_number: int = self.race_by(race_name=race_name).number
return self.driver_points_per_step(include_inactive=include_inactive)[driver_name][race_number] return self.driver_points_per_step(include_inactive=include_inactive)[
driver_name
][race_number]
raise Exception("driver_points_by received an illegal combination of arguments") raise Exception("driver_points_by received an illegal combination of arguments")
@cache.memoize(timeout=None, args_to_ignore=["self"]) # Cleanup when adding/updating race results @cache.memoize(
timeout=None, args_to_ignore=["self"]
) # Cleanup when adding/updating race results
def total_driver_points_by(self, driver_name: str) -> int: def total_driver_points_by(self, driver_name: str) -> int:
return sum(self.driver_points_by(driver_name=driver_name, include_inactive=True)) return sum(
self.driver_points_by(driver_name=driver_name, include_inactive=True)
)
@cache.memoize(timeout=None, args_to_ignore=["self"]) # Cleanup when adding/updating race results @cache.memoize(
timeout=None, args_to_ignore=["self"]
) # Cleanup when adding/updating race results
def drivers_sorted_by_points(self, *, include_inactive: bool) -> List[Driver]: def drivers_sorted_by_points(self, *, include_inactive: bool) -> List[Driver]:
comparator: Callable[[Driver], int] = lambda driver: self.total_driver_points_by(driver.name) comparator: Callable[[Driver], int] = (
return sorted(self.all_drivers(include_none=False, include_inactive=include_inactive), key=comparator, reverse=True) lambda driver: self.total_driver_points_by(driver.name)
)
return sorted(
self.all_drivers(include_none=False, include_inactive=include_inactive),
key=comparator,
reverse=True,
)
@cache.cached(timeout=None, key_prefix="points_wdc_standing_by_position") # Cleanup when adding/updating race results @cache.cached(
timeout=None, key_prefix="points_wdc_standing_by_position"
) # Cleanup when adding/updating race results
def wdc_standing_by_position(self) -> Dict[int, List[str]]: def wdc_standing_by_position(self) -> Dict[int, List[str]]:
standing: Dict[int, List[str]] = dict() standing: Dict[int, List[str]] = dict()
for position in range(1, len(self.all_drivers(include_none=False, include_inactive=True)) + 1): for position in range(
1, len(self.all_drivers(include_none=False, include_inactive=True)) + 1
):
standing[position] = list() standing[position] = list()
position: int = 1 position: int = 1
@ -281,14 +351,18 @@ class PointsModel(Model):
for driver in self.drivers_sorted_by_points(include_inactive=True): for driver in self.drivers_sorted_by_points(include_inactive=True):
points: int = self.total_driver_points_by(driver.name) points: int = self.total_driver_points_by(driver.name)
if points < last_points: if points < last_points:
position += 1 # If multiple drivers have equal points, a place is shared.
# In this case, the next driver does not occupy the immediate next position.
position += len(standing[position])
standing[position].append(driver.name) standing[position].append(driver.name)
last_points = points last_points = points
return standing return standing
@cache.cached(timeout=None, key_prefix="points_wdc_standing_by_driver") # Cleanup when adding/updating race results @cache.cached(
timeout=None, key_prefix="points_wdc_standing_by_driver"
) # Cleanup when adding/updating race results
def wdc_standing_by_driver(self) -> Dict[str, int]: def wdc_standing_by_driver(self) -> Dict[str, int]:
standing: Dict[str, int] = dict() standing: Dict[str, int] = dict()
@ -298,7 +372,14 @@ class PointsModel(Model):
for driver in self.drivers_sorted_by_points(include_inactive=True): for driver in self.drivers_sorted_by_points(include_inactive=True):
points: int = self.total_driver_points_by(driver.name) points: int = self.total_driver_points_by(driver.name)
if points < last_points: if points < last_points:
position += 1 drivers_with_this_position = 0
for _driver, _position in standing.items():
if _position == position:
drivers_with_this_position += 1
# If multiple drivers have equal points, a place is shared.
# In this case, the next driver does not occupy the immediate next position.
position += drivers_with_this_position
standing[driver.name] = position standing[driver.name] = position
last_points = points last_points = points
@ -309,9 +390,13 @@ class PointsModel(Model):
if not driver_name in WDC_STANDING_2023: if not driver_name in WDC_STANDING_2023:
return 0 return 0
return WDC_STANDING_2023[driver_name] - self.wdc_standing_by_driver()[driver_name] return (
WDC_STANDING_2023[driver_name] - self.wdc_standing_by_driver()[driver_name]
)
@cache.cached(timeout=None, key_prefix="points_most_dnf_names") # Cleanup when adding/updating race results @cache.cached(
timeout=None, key_prefix="points_most_dnf_names"
) # Cleanup when adding/updating race results
def most_dnf_names(self) -> List[str]: def most_dnf_names(self) -> List[str]:
dnf_names: List[str] = list() dnf_names: List[str] = list()
most_dnfs: int = 0 most_dnfs: int = 0
@ -326,7 +411,9 @@ class PointsModel(Model):
return dnf_names return dnf_names
@cache.cached(timeout=None, key_prefix="points_most_gained_names") # Cleanup when adding/updating race results @cache.cached(
timeout=None, key_prefix="points_most_gained_names"
) # Cleanup when adding/updating race results
def most_gained_names(self) -> List[str]: def most_gained_names(self) -> List[str]:
most_gained_names: List[str] = list() most_gained_names: List[str] = list()
most_gained: int = 0 most_gained: int = 0
@ -345,7 +432,9 @@ class PointsModel(Model):
return most_gained_names return most_gained_names
@cache.cached(timeout=None, key_prefix="points_most_lost_names") # Cleanup when adding/updating race results @cache.cached(
timeout=None, key_prefix="points_most_lost_names"
) # Cleanup when adding/updating race results
def most_lost_names(self) -> List[str]: def most_lost_names(self) -> List[str]:
most_lost_names: List[str] = list() most_lost_names: List[str] = list()
most_lost: int = 100 most_lost: int = 100
@ -368,7 +457,9 @@ class PointsModel(Model):
# Team points # Team points
# #
@cache.cached(timeout=None, key_prefix="points_team_points_per_step_cumulative") # Cleanup when adding/updating race results @cache.cached(
timeout=None, key_prefix="points_team_points_per_step_cumulative"
) # Cleanup when adding/updating race results
def team_points_per_step_cumulative(self) -> Dict[str, List[int]]: def team_points_per_step_cumulative(self) -> Dict[str, List[int]]:
""" """
Returns a dictionary of lists, containing cumulative points per race for each team. Returns a dictionary of lists, containing cumulative points per race for each team.
@ -379,21 +470,34 @@ class PointsModel(Model):
return points_per_step_cumulative return points_per_step_cumulative
@cache.memoize(timeout=None, args_to_ignore=["self"]) # Cleanup when adding/updating race results @cache.memoize(
timeout=None, args_to_ignore=["self"]
) # Cleanup when adding/updating race results
def total_team_points_by(self, team_name: str) -> int: def total_team_points_by(self, team_name: str) -> int:
teammates: List[Driver] = self.drivers_by(team_name=team_name, include_inactive=True) teammates: List[Driver] = self.drivers_by(
return sum(sum(self.driver_points_by(driver_name=teammate.name, include_inactive=True)) for teammate in teammates) team_name=team_name, include_inactive=True
)
return sum(
sum(self.driver_points_by(driver_name=teammate.name, include_inactive=True))
for teammate in teammates
)
@cache.cached(timeout=None, key_prefix="points_teams_sorted_by_points") # Cleanup when adding/updating race results @cache.cached(
timeout=None, key_prefix="points_teams_sorted_by_points"
) # Cleanup when adding/updating race results
def teams_sorted_by_points(self) -> List[Team]: def teams_sorted_by_points(self) -> List[Team]:
comparator: Callable[[Team], int] = lambda team: self.total_team_points_by(team.name) comparator: Callable[[Team], int] = lambda team: self.total_team_points_by(
team.name
)
return sorted(self.all_teams(include_none=False), key=comparator, reverse=True) return sorted(self.all_teams(include_none=False), key=comparator, reverse=True)
@cache.cached(timeout=None, key_prefix="points_wcc_standing_by_position") # Cleanup when adding/updating race results @cache.cached(
timeout=None, key_prefix="points_wcc_standing_by_position"
) # Cleanup when adding/updating race results
def wcc_standing_by_position(self) -> Dict[int, List[str]]: def wcc_standing_by_position(self) -> Dict[int, List[str]]:
standing: Dict[int, List[str]] = dict() standing: Dict[int, List[str]] = dict()
for position in range (1, len(self.all_teams(include_none=False)) + 1): for position in range(1, len(self.all_teams(include_none=False)) + 1):
standing[position] = list() standing[position] = list()
position: int = 1 position: int = 1
@ -402,14 +506,18 @@ class PointsModel(Model):
for team in self.teams_sorted_by_points(): for team in self.teams_sorted_by_points():
points: int = self.total_team_points_by(team.name) points: int = self.total_team_points_by(team.name)
if points < last_points: if points < last_points:
position += 1 # If multiple teams have equal points, a place is shared.
# In this case, the next team does not occupy the immediate next position.
position += len(standing[position])
standing[position].append(team.name) standing[position].append(team.name)
last_points = points last_points = points
return standing return standing
@cache.cached(timeout=None, key_prefix="points_wcc_standing_by_team") # Cleanup when adding/updating race results @cache.cached(
timeout=None, key_prefix="points_wcc_standing_by_team"
) # Cleanup when adding/updating race results
def wcc_standing_by_team(self) -> Dict[str, int]: def wcc_standing_by_team(self) -> Dict[str, int]:
standing: Dict[str, int] = dict() standing: Dict[str, int] = dict()
@ -419,7 +527,14 @@ class PointsModel(Model):
for team in self.teams_sorted_by_points(): for team in self.teams_sorted_by_points():
points: int = self.total_team_points_by(team.name) points: int = self.total_team_points_by(team.name)
if points < last_points: if points < last_points:
position += 1 teams_with_this_position = 0
for _team, _position in standing.items():
if _position == position:
teams_with_this_position += 1
# If multiple teams have equal points, a place is shared.
# In this case, the next team does not occupy the immediate next position.
position += teams_with_this_position
standing[team.name] = position standing[team.name] = position
last_points = points last_points = points
@ -464,8 +579,12 @@ class PointsModel(Model):
""" """
return self.points_by(user_name=user_name, race_name=race_name) return self.points_by(user_name=user_name, race_name=race_name)
@cache.memoize(timeout=None, args_to_ignore=["self"]) # Cleanup when adding/updating race results or users @cache.memoize(
def points_by(self, *, user_name: str | None = None, race_name: str | None = None) -> List[int] | Dict[str, int] | int: timeout=None, args_to_ignore=["self"]
) # Cleanup when adding/updating race results or users
def points_by(
self, *, user_name: str | None = None, race_name: str | None = None
) -> List[int] | Dict[str, int] | int:
if user_name is not None and race_name is None: if user_name is not None and race_name is None:
return self.points_per_step()[user_name] return self.points_per_step()[user_name]
@ -498,15 +617,25 @@ class PointsModel(Model):
comparator: Callable[[User], int] = lambda user: self.total_points_by(user.name) comparator: Callable[[User], int] = lambda user: self.total_points_by(user.name)
return sorted(self.all_users(), key=comparator, reverse=True) return sorted(self.all_users(), key=comparator, reverse=True)
@cache.cached(timeout=None, key_prefix="points_user_standing") # Cleanup when adding/updating race results or users @cache.cached(
timeout=None, key_prefix="points_user_standing"
) # Cleanup when adding/updating race results or users
def user_standing(self) -> Dict[str, int]: def user_standing(self) -> Dict[str, int]:
standing: Dict[str, int] = dict() standing: Dict[str, int] = dict()
position: int = 1 position: int = 1
last_points: int = 0 last_points: int = 0
for user in self.users_sorted_by_points(): for user in self.users_sorted_by_points():
if self.total_points_by(user.name) < last_points: if self.total_points_by(user.name) < last_points:
position += 1 users_with_this_position = 0
for _user, _position in standing.items():
if _position == position:
users_with_this_position += 1
# If multiple users have equal points, a place is shared.
# In this case, the next user does not occupy the immediate next position.
position += users_with_this_position
standing[user.name] = position standing[user.name] = position
@ -518,12 +647,16 @@ class PointsModel(Model):
# Treat standing + dnf picks separately # Treat standing + dnf picks separately
return len(self.race_guesses_by(user_name=user_name)) * 2 return len(self.race_guesses_by(user_name=user_name)) * 2
@cache.memoize(timeout=None, args_to_ignore=["self"]) # Cleanup when adding/updating race results @cache.memoize(
timeout=None, args_to_ignore=["self"]
) # Cleanup when adding/updating race results
def picks_with_points_count(self, user_name: str) -> int: def picks_with_points_count(self, user_name: str) -> int:
count: int = 0 count: int = 0
for race_guess in self.race_guesses_by(user_name=user_name): for race_guess in self.race_guesses_by(user_name=user_name):
race_result: RaceResult | None = self.race_result_by(race_name=race_guess.race.name) race_result: RaceResult | None = self.race_result_by(
race_name=race_guess.race.name
)
if race_result is None: if race_result is None:
continue continue
@ -545,9 +678,15 @@ class PointsModel(Model):
# #
def hot_take_correct(self, user_name: str) -> bool: def hot_take_correct(self, user_name: str) -> bool:
season_guess_result: SeasonGuessResult | None = self.season_guess_result_by(user_name=user_name) season_guess_result: SeasonGuessResult | None = self.season_guess_result_by(
user_name=user_name
)
return season_guess_result.hot_take_correct if season_guess_result is not None else False return (
season_guess_result.hot_take_correct
if season_guess_result is not None
else False
)
def p2_constructor_correct(self, user_name: str) -> bool: def p2_constructor_correct(self, user_name: str) -> bool:
season_guess: SeasonGuess | None = self.season_guesses_by(user_name=user_name) season_guess: SeasonGuess | None = self.season_guesses_by(user_name=user_name)
@ -558,9 +697,15 @@ class PointsModel(Model):
return season_guess.p2_wcc.name in self.wcc_standing_by_position()[2] return season_guess.p2_wcc.name in self.wcc_standing_by_position()[2]
def overtakes_correct(self, user_name: str) -> bool: def overtakes_correct(self, user_name: str) -> bool:
season_guess_result: SeasonGuessResult | None = self.season_guess_result_by(user_name=user_name) season_guess_result: SeasonGuessResult | None = self.season_guess_result_by(
user_name=user_name
)
return season_guess_result.overtakes_correct if season_guess_result is not None else False return (
season_guess_result.overtakes_correct
if season_guess_result is not None
else False
)
def dnfs_correct(self, user_name: str) -> bool: def dnfs_correct(self, user_name: str) -> bool:
season_guess: SeasonGuess | None = self.season_guesses_by(user_name=user_name) season_guess: SeasonGuess | None = self.season_guesses_by(user_name=user_name)
@ -586,14 +731,23 @@ class PointsModel(Model):
return season_guess.most_wdc_lost.name in self.most_lost_names() return season_guess.most_wdc_lost.name in self.most_lost_names()
@cache.memoize(timeout=None, args_to_ignore=["self"]) # Cleanup when adding/updating race results @cache.memoize(
timeout=None, args_to_ignore=["self"]
) # Cleanup when adding/updating race results
def is_team_winner(self, driver: Driver) -> bool: def is_team_winner(self, driver: Driver) -> bool:
teammates: List[Driver] = self.drivers_by(team_name=driver.team.name, include_inactive=True) teammates: List[Driver] = self.drivers_by(
team_name=driver.team.name, include_inactive=True
)
teammate: Driver = teammates[0] if teammates[1] == driver else teammates[1] teammate: Driver = teammates[0] if teammates[1] == driver else teammates[1]
return self.wdc_standing_by_driver()[driver.name] <= self.wdc_standing_by_driver()[teammate.name] return (
self.wdc_standing_by_driver()[driver.name]
<= self.wdc_standing_by_driver()[teammate.name]
)
@cache.memoize(timeout=None, args_to_ignore=["self"]) # Cleanup when adding/updating race results @cache.memoize(
timeout=None, args_to_ignore=["self"]
) # Cleanup when adding/updating race results
def has_podium(self, driver: Driver) -> bool: def has_podium(self, driver: Driver) -> bool:
for race_result in self.all_race_results(): for race_result in self.all_race_results():
position: int | None = race_result.driver_standing_position(driver) position: int | None = race_result.driver_standing_position(driver)
@ -617,7 +771,7 @@ class PointsModel(Model):
{ {
"data": self.points_per_step_cumulative()[user.name], "data": self.points_per_step_cumulative()[user.name],
"label": user.name, "label": user.name,
"fill": False "fill": False,
} }
for user in self.all_users() for user in self.all_users()
] ]
@ -635,7 +789,7 @@ class PointsModel(Model):
{ {
"data": self.driver_points_per_step_cumulative()[driver.name], "data": self.driver_points_per_step_cumulative()[driver.name],
"label": driver.abbr, "label": driver.abbr,
"fill": False "fill": False,
} }
for driver in self.all_drivers(include_none=False, include_inactive=True) for driver in self.all_drivers(include_none=False, include_inactive=True)
] ]
@ -653,7 +807,7 @@ class PointsModel(Model):
{ {
"data": self.team_points_per_step_cumulative()[team.name], "data": self.team_points_per_step_cumulative()[team.name],
"label": team.name, "label": team.name,
"fill": False "fill": False,
} }
for team in self.all_teams(include_none=False) for team in self.all_teams(include_none=False)
] ]