From b4c459ffe7e72c0f0916d15af795a96344b0953d Mon Sep 17 00:00:00 2001 From: Christoph Urlacher Date: Fri, 30 Aug 2024 20:47:06 +0200 Subject: [PATCH] Allow specifying drivers as "inactive" and replace Logan Sargeant with Franco Colapinto --- formula10/database/model/db_driver.py | 3 +- formula10/database/validation.py | 13 +++ formula10/domain/domain_model.py | 64 +++++++---- formula10/domain/model/driver.py | 8 +- formula10/domain/model/race.py | 2 +- formula10/domain/model/race_guess.py | 2 +- formula10/domain/model/season_guess.py | 2 +- formula10/domain/model/season_guess_result.py | 2 +- formula10/domain/model/team.py | 2 +- formula10/domain/model/user.py | 2 +- formula10/domain/points_model.py | 107 +++++++++++------- formula10/domain/template_model.py | 18 +-- formula10/openf1/model/api_driver.py | 2 +- formula10/openf1/model/api_position.py | 2 +- formula10/openf1/model/api_session.py | 2 +- formula10/templates/base.jinja | 4 +- formula10/templates/result.jinja | 8 +- formula10/templates/season.jinja | 10 +- formula10/templates/statistics.jinja | 2 +- 19 files changed, 160 insertions(+), 95 deletions(-) diff --git a/formula10/database/model/db_driver.py b/formula10/database/model/db_driver.py index a2b50d9..9dbb8ed 100644 --- a/formula10/database/model/db_driver.py +++ b/formula10/database/model/db_driver.py @@ -1,4 +1,4 @@ -from sqlalchemy import Integer, String, ForeignKey +from sqlalchemy import Integer, String, ForeignKey, Boolean from sqlalchemy.orm import mapped_column, Mapped, relationship from formula10.database.model.db_team import DbTeam @@ -20,6 +20,7 @@ class DbDriver(db.Model): abbr: Mapped[str] = mapped_column(String(4), nullable=False, unique=True) team_id: Mapped[str] = mapped_column(ForeignKey("team.id"), nullable=False) country_code: Mapped[str] = mapped_column(String(2), nullable=False) # alpha-2 code + active: Mapped[bool] = mapped_column(Boolean, nullable=False) # Relationships team: Mapped[DbTeam] = relationship("DbTeam", foreign_keys=[team_id]) \ No newline at end of file diff --git a/formula10/database/validation.py b/formula10/database/validation.py index 186b908..b5e4f07 100644 --- a/formula10/database/validation.py +++ b/formula10/database/validation.py @@ -76,6 +76,19 @@ def find_multiple_strict(predicate: Callable[[_T], bool], iterable: Iterable[_T] return filtered +def find_atleast_strict(predicate: Callable[[_T], bool], iterable: Iterable[_T], count: int = 0) -> List[_T]: + """ + Finds at least elements in a sequence matching a predicate. + Throws exception if fewer elements were found than specified. + """ + filtered = list(filter(predicate, iterable)) + + if len(filtered) < count: + raise Exception(f"find_atleast found {len(filtered)} matching elements but expected at least {count}") + + return filtered + + def find_single_strict(predicate: Callable[[_T], bool], iterable: Iterable[_T]) -> _T: """ Find a single element in a sequence matching a predicate. diff --git a/formula10/domain/domain_model.py b/formula10/domain/domain_model.py index b8f0888..17d0185 100644 --- a/formula10/domain/domain_model.py +++ b/formula10/domain/domain_model.py @@ -9,7 +9,7 @@ from formula10.database.model.db_season_guess import DbSeasonGuess from formula10.database.model.db_season_guess_result import DbSeasonGuessResult from formula10.database.model.db_team import DbTeam from formula10.database.model.db_user import DbUser -from formula10.database.validation import find_multiple_strict, find_single_or_none_strict, find_single_strict +from formula10.database.validation import find_multiple_strict, find_single_or_none_strict, find_single_strict, find_atleast_strict from formula10.domain.model.driver import NONE_DRIVER, Driver from formula10.domain.model.race import Race from formula10.domain.model.race_guess import RaceGuess @@ -21,7 +21,7 @@ from formula10.domain.model.user import User from formula10 import db -class Model(): +class Model: _all_users: List[User] | None = None _all_race_results: List[RaceResult] | None = None _all_race_guesses: List[RaceGuess] | None = None @@ -29,6 +29,7 @@ class Model(): _all_season_guess_results: List[SeasonGuessResult] | None = None _all_races: List[Race] | None = None _all_drivers: List[Driver] | None = None + _all_active_drivers: List[Driver] | None = None _all_teams: List[Team] | None = None def all_users(self) -> List[User]: @@ -100,21 +101,34 @@ class Model(): return self._all_races - def all_drivers(self, *, include_none: bool) -> List[Driver]: + def all_drivers(self, *, include_none: bool, include_inactive: bool) -> List[Driver]: """ - Returns a list of all drivers. + Returns a list of all active drivers. """ - if self._all_drivers is None: - self._all_drivers = [ - Driver.from_db_driver(db_driver) - for db_driver in db.session.query(DbDriver).all() - ] + if include_inactive: + if self._all_drivers is None: + self._all_drivers = [ + Driver.from_db_driver(db_driver) + for db_driver in db.session.query(DbDriver).all() + ] - if include_none: - return self._all_drivers + if include_none: + return self._all_drivers + else: + predicate: Callable[[Driver], bool] = lambda driver: driver != NONE_DRIVER + return find_multiple_strict(predicate, self._all_drivers) else: - predicate: Callable[[Driver], bool] = lambda driver: driver != NONE_DRIVER - return find_multiple_strict(predicate, self._all_drivers) + if self._all_active_drivers is None: + self._all_active_drivers = [ + Driver.from_db_driver(db_driver) + for db_driver in db.session.query(DbDriver).filter_by(active=True).all() + ] + + if include_none: + return self._all_active_drivers + else: + predicate: Callable[[Driver], bool] = lambda driver: driver != NONE_DRIVER + return find_multiple_strict(predicate, self._all_active_drivers) def all_teams(self, *, include_none: bool) -> List[Team]: """ @@ -280,34 +294,40 @@ class Model(): # Team queries # - def none_team(self) -> Team: + @staticmethod + def none_team() -> Team: return NONE_TEAM # # Driver queries # - def none_driver(self) -> Driver: + @staticmethod + def none_driver() -> Driver: return NONE_DRIVER @overload - def drivers_by(self, *, team_name: str) -> List[Driver]: + def drivers_by(self, *, team_name: str, include_inactive: bool) -> List[Driver]: """ Returns a list of all drivers driving for a certain team. """ - return self.drivers_by(team_name=team_name) + return self.drivers_by(team_name=team_name, include_inactive=include_inactive) @overload - def drivers_by(self) -> Dict[str, List[Driver]]: + def drivers_by(self, *, include_inactive: bool) -> Dict[str, List[Driver]]: """ Returns a dictionary of drivers mapped to team names. """ - return self.drivers_by() + return self.drivers_by(include_inactive=include_inactive) - def drivers_by(self, *, team_name: str | None = None) -> List[Driver] | Dict[str, List[Driver]]: + def drivers_by(self, *, team_name: str | None = None, include_inactive: bool) -> List[Driver] | Dict[str, List[Driver]]: if team_name is not None: predicate: Callable[[Driver], bool] = lambda driver: driver.team.name == team_name - return find_multiple_strict(predicate, self.all_drivers(include_none=False), 2) + + if include_inactive: + return find_atleast_strict(predicate, self.all_drivers(include_none=False, include_inactive=True), 2) + else: + return find_multiple_strict(predicate, self.all_drivers(include_none=False, include_inactive=False), 2) if team_name is None: drivers_by: Dict[str, List[Driver]] = dict() @@ -316,7 +336,7 @@ class Model(): for team in self.all_teams(include_none=False): drivers_by[team.name] = [] - for driver in self.all_drivers(include_none=False): + for driver in self.all_drivers(include_none=False, include_inactive=include_inactive): drivers_by[driver.team.name] += [driver] return drivers_by diff --git a/formula10/domain/model/driver.py b/formula10/domain/model/driver.py index 71caa13..f86426b 100644 --- a/formula10/domain/model/driver.py +++ b/formula10/domain/model/driver.py @@ -4,7 +4,7 @@ from formula10.database.model.db_driver import DbDriver from formula10.domain.model.team import NONE_TEAM, Team -class Driver(): +class Driver: @classmethod def from_db_driver(cls, db_driver: DbDriver): driver: Driver = cls() @@ -13,6 +13,7 @@ class Driver(): driver.abbr = db_driver.abbr driver.country = db_driver.country_code driver.team = Team.from_db_team(db_driver.team) + driver.active = db_driver.active return driver def to_db_driver(self) -> DbDriver: @@ -21,6 +22,7 @@ class Driver(): db_driver.abbr = self.abbr db_driver.country_code = self.country db_driver.team_id = self.team.name + db_driver.active = self.active return db_driver def __eq__(self, __value: object) -> bool: @@ -37,6 +39,7 @@ class Driver(): abbr: str country: str team: Team + active: bool @property def name_sanitized(self) -> str: @@ -48,4 +51,5 @@ NONE_DRIVER.id = 0 NONE_DRIVER.name = "None" NONE_DRIVER.abbr = "None" NONE_DRIVER.country = "NO" -NONE_DRIVER.team = NONE_TEAM \ No newline at end of file +NONE_DRIVER.team = NONE_TEAM +NONE_DRIVER.active = False \ No newline at end of file diff --git a/formula10/domain/model/race.py b/formula10/domain/model/race.py index 6518cad..8302d9f 100644 --- a/formula10/domain/model/race.py +++ b/formula10/domain/model/race.py @@ -4,7 +4,7 @@ from urllib.parse import quote from formula10.database.model.db_race import DbRace -class Race(): +class Race: @classmethod def from_db_race(cls, db_race: DbRace): race: Race = cls() diff --git a/formula10/domain/model/race_guess.py b/formula10/domain/model/race_guess.py index fe46c5c..cd9c606 100644 --- a/formula10/domain/model/race_guess.py +++ b/formula10/domain/model/race_guess.py @@ -4,7 +4,7 @@ from formula10.domain.model.race import Race from formula10.domain.model.user import User -class RaceGuess(): +class RaceGuess: @classmethod def from_db_race_guess(cls, db_race_guess: DbRaceGuess): race_guess: RaceGuess = cls() diff --git a/formula10/domain/model/season_guess.py b/formula10/domain/model/season_guess.py index c0b458c..1b17e03 100644 --- a/formula10/domain/model/season_guess.py +++ b/formula10/domain/model/season_guess.py @@ -7,7 +7,7 @@ from formula10.domain.model.team import Team from formula10.domain.model.user import User -class SeasonGuess(): +class SeasonGuess: @classmethod def from_db_season_guess(cls, db_season_guess: DbSeasonGuess): season_guess: SeasonGuess = cls() diff --git a/formula10/domain/model/season_guess_result.py b/formula10/domain/model/season_guess_result.py index a478536..80071de 100644 --- a/formula10/domain/model/season_guess_result.py +++ b/formula10/domain/model/season_guess_result.py @@ -2,7 +2,7 @@ from formula10.database.model.db_season_guess_result import DbSeasonGuessResult from formula10.domain.model.user import User -class SeasonGuessResult(): +class SeasonGuessResult: @classmethod def from_db_season_guess_result(cls, db_season_guess_result: DbSeasonGuessResult): season_guess_result: SeasonGuessResult = cls() diff --git a/formula10/domain/model/team.py b/formula10/domain/model/team.py index f412775..dd647f8 100644 --- a/formula10/domain/model/team.py +++ b/formula10/domain/model/team.py @@ -3,7 +3,7 @@ from urllib.parse import quote from formula10.database.model.db_team import DbTeam -class Team(): +class Team: @classmethod def from_db_team(cls, db_team: DbTeam): team: Team = cls() diff --git a/formula10/domain/model/user.py b/formula10/domain/model/user.py index 4373448..621a522 100644 --- a/formula10/domain/model/user.py +++ b/formula10/domain/model/user.py @@ -3,7 +3,7 @@ from urllib.parse import quote from formula10.database.model.db_user import DbUser -class User(): +class User: @classmethod def from_db_user(cls, db_user: DbUser): user: User = cls() diff --git a/formula10/domain/points_model.py b/formula10/domain/points_model.py index a7378cb..cf5b1c2 100644 --- a/formula10/domain/points_model.py +++ b/formula10/domain/points_model.py @@ -121,6 +121,7 @@ class PointsModel(Model): _points_per_step: Dict[str, List[int]] | None = None _driver_points_per_step: Dict[str, List[int]] | None = None + _active_driver_points_per_step: Dict[str, List[int]] | None = None _team_points_per_step: Dict[str, List[int]] | None = None _dnfs: Dict[str, int] | None = None @@ -148,28 +149,49 @@ class PointsModel(Model): return self._points_per_step - def driver_points_per_step(self) -> 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. """ - if self._driver_points_per_step is None: - self._driver_points_per_step = dict() - for driver in self.all_drivers(include_none=False): - self._driver_points_per_step[driver.name] = [0] * (len(self.all_races()) + 1) # Start at index 1, like the race numbers + if include_inactive: + if self._driver_points_per_step is None: + self._driver_points_per_step = dict() + for driver in self.all_drivers(include_none=False, include_inactive=True): + self._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(): - race_number: int = race_result.race.number + for race_result in self.all_race_results(): + race_number: int = race_result.race.number - for position, driver in race_result.standing.items(): - self._driver_points_per_step[driver.name][race_number] = DRIVER_RACE_POINTS[int(position)] if int(position) in DRIVER_RACE_POINTS else 0 - self._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.standing.items(): + self._driver_points_per_step[driver.name][race_number] = DRIVER_RACE_POINTS[int(position)] if int(position) in DRIVER_RACE_POINTS else 0 + self._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(): - driver_name: str = driver.name + for position, driver in race_result.sprint_standing.items(): + driver_name: str = driver.name - self._driver_points_per_step[driver_name][race_number] += DRIVER_SPRINT_POINTS[int(position)] if int(position) in DRIVER_SPRINT_POINTS else 0 + self._driver_points_per_step[driver_name][race_number] += DRIVER_SPRINT_POINTS[int(position)] if int(position) in DRIVER_SPRINT_POINTS else 0 + + return self._driver_points_per_step + else: + if self._active_driver_points_per_step is None: + self._active_driver_points_per_step = dict() + for driver in self.all_drivers(include_none=False, include_inactive=False): + self._active_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(): + race_number: int = race_result.race.number + + for position, driver in race_result.standing.items(): + self._active_driver_points_per_step[driver.name][race_number] = DRIVER_RACE_POINTS[int(position)] if int(position) in DRIVER_RACE_POINTS else 0 + self._active_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(): + driver_name: str = driver.name + + self._active_driver_points_per_step[driver_name][race_number] += DRIVER_SPRINT_POINTS[int(position)] if int(position) in DRIVER_SPRINT_POINTS else 0 + + return self._active_driver_points_per_step - return self._driver_points_per_step def team_points_per_step(self) -> Dict[str, List[int]]: """ @@ -185,7 +207,7 @@ class PointsModel(Model): team_name: str = driver.team.name race_number: int = race_result.race.number - self._team_points_per_step[team_name][race_number] += self.driver_points_per_step()[driver.name][race_number] + self._team_points_per_step[team_name][race_number] += self.driver_points_per_step(include_inactive=True)[driver.name][race_number] return self._team_points_per_step @@ -193,7 +215,7 @@ class PointsModel(Model): if self._dnfs is None: self._dnfs = dict() - for driver in self.all_drivers(include_none=False): + for driver in self.all_drivers(include_none=False, include_inactive=True): self._dnfs[driver.name] = 0 for race_result in self.all_race_results(): @@ -214,41 +236,41 @@ class PointsModel(Model): Returns a dictionary of lists, containing cumulative points per race for each driver. """ points_per_step_cumulative: Dict[str, List[int]] = dict() - for driver_name, points in self.driver_points_per_step().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() return points_per_step_cumulative @overload - def driver_points_by(self, *, driver_name: str) -> 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. """ - return self.driver_points_by(driver_name=driver_name) + return self.driver_points_by(driver_name=driver_name, include_inactive=include_inactive) @overload - def driver_points_by(self, *, race_name: str) -> 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. """ - return self.driver_points_by(race_name=race_name) + return self.driver_points_by(race_name=race_name, include_inactive=include_inactive) @overload - def driver_points_by(self, *, driver_name: str, race_name: str) -> 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. """ - return self.driver_points_by(driver_name=driver_name, race_name=race_name) + return self.driver_points_by(driver_name=driver_name, race_name=race_name, include_inactive=include_inactive) - def driver_points_by(self, *, driver_name: str | None = None, race_name: str | None = None) -> List[int] | Dict[str, int] | int: + 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: - return self.driver_points_per_step()[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: race_number: int = self.race_by(race_name=race_name).number points_by_race: Dict[str, int] = dict() - for _driver_name, points in self.driver_points_per_step().items(): + for _driver_name, points in self.driver_points_per_step(include_inactive=include_inactive).items(): points_by_race[_driver_name] = points[race_number] return points_by_race @@ -256,27 +278,27 @@ class PointsModel(Model): if driver_name is not None and race_name is not None: race_number: int = self.race_by(race_name=race_name).number - return self.driver_points_per_step()[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") def total_driver_points_by(self, driver_name: str) -> int: - return sum(self.driver_points_by(driver_name=driver_name)) + return sum(self.driver_points_by(driver_name=driver_name, include_inactive=True)) - def drivers_sorted_by_points(self) -> 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) - return sorted(self.all_drivers(include_none=False), key=comparator, reverse=True) + return sorted(self.all_drivers(include_none=False, include_inactive=include_inactive), key=comparator, reverse=True) def wdc_standing_by_position(self) -> Dict[int, List[str]]: standing: Dict[int, List[str]] = dict() - for position in range(1, len(self.all_drivers(include_none=False)) + 1): + for position in range(1, len(self.all_drivers(include_none=False, include_inactive=True)) + 1): standing[position] = list() position: int = 1 last_points: int = 0 - for driver in self.drivers_sorted_by_points(): + for driver in self.drivers_sorted_by_points(include_inactive=True): points: int = self.total_driver_points_by(driver.name) if points < last_points: position += 1 @@ -292,7 +314,7 @@ class PointsModel(Model): position: int = 1 last_points: int = 0 - for driver in self.drivers_sorted_by_points(): + for driver in self.drivers_sorted_by_points(include_inactive=True): points: int = self.total_driver_points_by(driver.name) if points < last_points: position += 1 @@ -303,6 +325,9 @@ class PointsModel(Model): return standing def wdc_diff_2023_by(self, driver_name: str) -> int: + if not driver_name in WDC_STANDING_2023: + return 0 + return WDC_STANDING_2023[driver_name] - self.wdc_standing_by_driver()[driver_name] def most_dnf_names(self) -> List[str]: @@ -323,13 +348,13 @@ class PointsModel(Model): most_gained_names: List[str] = list() most_gained: int = 0 - for driver in self.all_drivers(include_none=False): + for driver in self.all_drivers(include_none=False, include_inactive=True): gained: int = self.wdc_diff_2023_by(driver.name) if gained > most_gained: most_gained = gained - for driver in self.all_drivers(include_none=False): + for driver in self.all_drivers(include_none=False, include_inactive=True): gained: int = self.wdc_diff_2023_by(driver.name) if gained == most_gained: @@ -341,13 +366,13 @@ class PointsModel(Model): most_lost_names: List[str] = list() most_lost: int = 100 - for driver in self.all_drivers(include_none=False): + for driver in self.all_drivers(include_none=False, include_inactive=True): lost: int = self.wdc_diff_2023_by(driver.name) if lost < most_lost: most_lost = lost - for driver in self.all_drivers(include_none=False): + for driver in self.all_drivers(include_none=False, include_inactive=True): lost: int = self.wdc_diff_2023_by(driver.name) if lost == most_lost: @@ -370,8 +395,8 @@ class PointsModel(Model): return points_per_step_cumulative def total_team_points_by(self, team_name: str) -> int: - teammates: List[Driver] = self.drivers_by(team_name=team_name) - return sum(self.driver_points_by(driver_name=teammates[0].name)) + sum(self.driver_points_by(driver_name=teammates[1].name)) + teammates: List[Driver] = self.drivers_by(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) def teams_sorted_by_points(self) -> List[Team]: comparator: Callable[[Team], int] = lambda team: self.total_team_points_by(team.name) @@ -570,7 +595,7 @@ class PointsModel(Model): return season_guess.most_wdc_lost.name in self.most_lost_names() def is_team_winner(self, driver: Driver) -> bool: - teammates: List[Driver] = self.drivers_by(team_name=driver.team.name) + 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] print(f"{driver.name} standing: {self.wdc_standing_by_driver()[driver.name]}, {teammate.name} standing: {self.wdc_standing_by_driver()[teammate.name]}") @@ -620,7 +645,7 @@ class PointsModel(Model): "label": driver.abbr, "fill": False } - for driver in self.all_drivers(include_none=False) + for driver in self.all_drivers(include_none=False, include_inactive=True) ] return json.dumps(data) diff --git a/formula10/domain/template_model.py b/formula10/domain/template_model.py index e1433fe..c69ecdd 100644 --- a/formula10/domain/template_model.py +++ b/formula10/domain/template_model.py @@ -29,10 +29,12 @@ class TemplateModel(Model): if active_result_race_name is not None: self.active_result = self.race_result_by(race_name=active_result_race_name) - def race_guess_open(self, race: Race) -> bool: + @staticmethod + def race_guess_open(race: Race) -> bool: return not race_has_started(race=race) if ENABLE_TIMING else True - def season_guess_open(self) -> bool: + @staticmethod + def season_guess_open() -> bool: return not race_has_started(race_id=1) if ENABLE_TIMING else True def race_result_open(self, race_name: str) -> bool: @@ -93,12 +95,12 @@ class TemplateModel(Model): else: return self.all_races()[0].name_sanitized - def all_drivers_or_active_result_standing_drivers(self) -> List[Driver]: - return self.active_result.ordered_standing_list() if self.active_result is not None else self.all_drivers(include_none=False) + def all_active_drivers_or_active_result_standing_drivers(self) -> List[Driver]: + return self.active_result.ordered_standing_list() if self.active_result is not None else self.all_drivers(include_none=False, include_inactive=False) - def all_drivers_or_active_result_sprint_standing_drivers(self) -> List[Driver]: - return self.active_result.ordered_sprint_standing_list() if self.active_result is not None else self.all_drivers(include_none=False) + def all_active_drivers_or_active_result_sprint_standing_drivers(self) -> List[Driver]: + return self.active_result.ordered_sprint_standing_list() if self.active_result is not None else self.all_drivers(include_none=False, include_inactive=False) - def drivers_for_wdc_gained(self) -> List[Driver]: + def active_drivers_for_wdc_gained(self) -> List[Driver]: predicate: Callable[[Driver], bool] = lambda driver: driver.abbr not in self._wdc_gained_excluded_abbrs - return find_multiple_strict(predicate, self.all_drivers(include_none=False)) + return find_multiple_strict(predicate, self.all_drivers(include_none=False, include_inactive=False)) diff --git a/formula10/openf1/model/api_driver.py b/formula10/openf1/model/api_driver.py index 62cb9b2..3e69841 100644 --- a/formula10/openf1/model/api_driver.py +++ b/formula10/openf1/model/api_driver.py @@ -1,7 +1,7 @@ from typing import Any, Callable, Dict -class ApiDriver(): +class ApiDriver: __type_conversion_map__: Dict[str, Callable[[Any], Any]] = { "session_key": int, "meeting_key": int, diff --git a/formula10/openf1/model/api_position.py b/formula10/openf1/model/api_position.py index 2899170..c9ac20a 100644 --- a/formula10/openf1/model/api_position.py +++ b/formula10/openf1/model/api_position.py @@ -2,7 +2,7 @@ from datetime import datetime from typing import Any, Callable, Dict -class ApiPosition(): +class ApiPosition: __type_conversion_map__: Dict[str, Callable[[Any], Any]] = { "session_key": int, "meeting_key": int, diff --git a/formula10/openf1/model/api_session.py b/formula10/openf1/model/api_session.py index 0f59889..3d97d1b 100644 --- a/formula10/openf1/model/api_session.py +++ b/formula10/openf1/model/api_session.py @@ -2,7 +2,7 @@ from datetime import datetime, time from typing import Any, Callable, Dict -class ApiSession(): +class ApiSession: __type_conversion_map__: Dict[str, Callable[[Any], Any]] = { "location": str, "country_key": int, diff --git a/formula10/templates/base.jinja b/formula10/templates/base.jinja index 3941954..2ad0eab 100644 --- a/formula10/templates/base.jinja +++ b/formula10/templates/base.jinja @@ -30,7 +30,7 @@ {% if drivers == none %} - {% set drivers = model.all_drivers(include_none=include_none) %} + {% set drivers = model.all_drivers(include_none=include_none, include_inactive=False) %} {% endif %} {% for driver in drivers %} @@ -49,7 +49,7 @@ {% set user_has_chosen = namespace(driverpre=false) %} {% if drivers == none %} - {% set drivers = model.all_drivers(include_none=include_none) %} + {% set drivers = model.all_drivers(include_none=include_none, include_inactive=False) %} {% endif %} {% for driver in drivers %} diff --git a/formula10/templates/result.jinja b/formula10/templates/result.jinja index e4d5081..415f367 100644 --- a/formula10/templates/result.jinja +++ b/formula10/templates/result.jinja @@ -78,7 +78,7 @@ {# Place numbers #}