Large database migration

formula10/domain/model/driver.py

@@ -8,6 +8,7 @@ class Driver():
     @classmethod
     def from_db_driver(cls, db_driver: DbDriver):
         driver: Driver = cls()
+        driver.id = db_driver.id
         driver.name = db_driver.name
         driver.abbr = db_driver.abbr
         driver.country = db_driver.country_code
@@ -15,18 +16,23 @@ class Driver():
         return driver
 
     def to_db_driver(self) -> DbDriver:
-        db_driver: DbDriver = DbDriver(name=self.name)
+        db_driver: DbDriver = DbDriver(id=self.id)
+        db_driver.name = self.name
         db_driver.abbr = self.abbr
         db_driver.country_code = self.country
-        db_driver.team_name = self.team.name
+        db_driver.team_id = self.team.name
         return db_driver
 
     def __eq__(self, __value: object) -> bool:
         if isinstance(__value, Driver):
-            return self.name == __value.name
+            return self.id == __value.id
 
         return NotImplemented
 
+    def __hash__(self) -> int:
+        return hash(self.id)
+
+    id: int
     name: str
     abbr: str
     country: str
@@ -38,6 +44,7 @@ class Driver():
 
 
 NONE_DRIVER: Driver = Driver()
+NONE_DRIVER.id = 0
 NONE_DRIVER.name = "None"
 NONE_DRIVER.abbr = "None"
 NONE_DRIVER.country = "NO"

formula10/domain/model/race.py

@@ -8,6 +8,7 @@ class Race():
     @classmethod
     def from_db_race(cls, db_race: DbRace):
         race: Race = cls()
+        race.id = db_race.id
         race.name = db_race.name
         race.number = db_race.number
         race.date = db_race.date
@@ -15,18 +16,23 @@ class Race():
         return race
 
     def to_db_race(self) -> DbRace:
-        db_race: DbRace = DbRace(name=self.name,
-                                 number=self.number,
-                                 date=self.date,
-                                 pxx=self.place_to_guess)
+        db_race: DbRace = DbRace(id=self.id)
+        db_race.name = self.name
+        db_race.number = self.number
+        db_race.date = self.date
+        db_race.pxx = self.place_to_guess
         return db_race
 
     def __eq__(self, __value: object) -> bool:
         if isinstance(__value, Race):
-            return self.name == __value.name
+            return self.id == __value.id
 
         return NotImplemented
 
+    def __hash__(self) -> int:
+        return hash(self.id)
+
+    id: int
     name: str
     number: int
     date: datetime

formula10/domain/model/race_guess.py

@@ -15,10 +15,9 @@ class RaceGuess():
         return race_guess
 
     def to_db_race_guess(self) -> DbRaceGuess:
-        db_race_guess: DbRaceGuess = DbRaceGuess(user_name=self.user.name,
-                                                 race_name=self.race.name,
-                                                 pxx_driver_name=self.pxx_guess.name,
-                                                 dnf_driver_name=self.dnf_guess.name)
+        db_race_guess: DbRaceGuess = DbRaceGuess(user_id=self.user.id, race_id=self.race.id)
+        db_race_guess.pxx_driver_id = self.pxx_guess.id
+        db_race_guess.dnf_driver_id = self.dnf_guess.id
         return db_race_guess
 
     def __eq__(self, __value: object) -> bool:
@@ -27,6 +26,9 @@ class RaceGuess():
 
         return NotImplemented
 
+    def __hash__(self) -> int:
+        return hash((self.user, self.race))
+
     user: User
     race: Race
     pxx_guess: Driver

formula10/domain/model/race_result.py

@@ -14,27 +14,27 @@ class RaceResult:
         race_result.race = Race.from_db_race(db_race_result.race)
 
         # Deserialize from json
-        standing: Dict[str, str] = json.loads(db_race_result.pxx_driver_names_json)
-        initial_dnf: List[str] = json.loads(db_race_result.first_dnf_driver_names_json)
-        all_dnfs: List[str] = json.loads(db_race_result.dnf_driver_names_json)
-        standing_exclusions: List[str] = json.loads(db_race_result.excluded_driver_names_json)
+        standing: Dict[str, str] = json.loads(db_race_result.pxx_driver_ids_json)
+        initial_dnf: List[str] = json.loads(db_race_result.first_dnf_driver_ids_json)
+        all_dnfs: List[str] = json.loads(db_race_result.dnf_driver_ids_json)
+        standing_exclusions: List[str] = json.loads(db_race_result.excluded_driver_ids_json)
 
         # Populate relationships
         race_result.standing = {
-            position: Driver.from_db_driver(find_single_driver_strict(driver_name))
-            for position, driver_name in standing.items()
+            position: Driver.from_db_driver(find_single_driver_strict(int(driver_id)))
+            for position, driver_id in standing.items()
         }
         race_result.initial_dnf = [
-            Driver.from_db_driver(find_single_driver_strict(driver_name))
-            for driver_name in initial_dnf
+            Driver.from_db_driver(find_single_driver_strict(int(driver_id)))
+            for driver_id in initial_dnf
         ]
         race_result.all_dnfs = [
-            Driver.from_db_driver(find_single_driver_strict(driver_name))
-            for driver_name in all_dnfs
+            Driver.from_db_driver(find_single_driver_strict(int(driver_id)))
+            for driver_id in all_dnfs
         ]
         race_result.standing_exclusions = [
-            Driver.from_db_driver(find_single_driver_strict(driver_name))
-            for driver_name in standing_exclusions
+            Driver.from_db_driver(find_single_driver_strict(int(driver_id)))
+            for driver_id in standing_exclusions
         ]
 
         return race_result
@@ -45,21 +45,21 @@ class RaceResult:
             position: driver.name for position, driver in self.standing.items()
         }
         initial_dnf: List[str] = [
-            driver.name for driver in self.initial_dnf if driver
+            str(driver.id) for driver in self.initial_dnf if driver
         ]
         all_dnfs: List[str] = [
-            driver.name for driver in self.all_dnfs if driver
+            str(driver.id) for driver in self.all_dnfs if driver
         ]
         standing_exclusions: List[str] = [
-            driver.name for driver in self.standing_exclusions if driver
+            str(driver.id) for driver in self.standing_exclusions if driver
         ]
 
         # Serialize to json
-        db_race_result: DbRaceResult = DbRaceResult(race_name=self.race.name,
-                                                    pxx_driver_names_json=json.dumps(standing),
-                                                    first_dnf_driver_names_json=json.dumps(initial_dnf),
-                                                    dnf_driver_names_json=json.dumps(all_dnfs),
-                                                    excluded_driver_names_json=json.dumps(standing_exclusions))
+        db_race_result: DbRaceResult = DbRaceResult(race_id=self.race.id)
+        db_race_result.pxx_driver_ids_json = json.dumps(standing)
+        db_race_result.first_dnf_driver_ids_json = json.dumps(initial_dnf)
+        db_race_result.dnf_driver_ids_json = json.dumps(all_dnfs)
+        db_race_result.excluded_driver_ids_json = json.dumps(standing_exclusions)
 
         return db_race_result
 
@@ -69,6 +69,9 @@ class RaceResult:
 
         return NotImplemented
 
+    def __hash__(self) -> int:
+        return hash(self.race)
+
     race: Race
     standing: Dict[str, Driver]  # Always contains all 20 drivers, even if DNF'ed or excluded
     initial_dnf: List[Driver]  # initial_dnf is empty if no-one DNF'ed

formula10/domain/model/season_guess.py

@@ -20,17 +20,17 @@ class SeasonGuess():
         season_guess.most_wdc_lost = Driver.from_db_driver(db_season_guess.lost_driver) if db_season_guess.lost_driver is not None else None
 
         # Deserialize from json
-        team_winners: List[str | None] = json.loads(db_season_guess.team_winners_driver_names_json)
-        podiums: List[str] = json.loads(db_season_guess.podium_drivers_driver_names_json)
+        team_winners: List[str | None] = json.loads(db_season_guess.team_winners_driver_ids_json)
+        podiums: List[str] = json.loads(db_season_guess.podium_drivers_driver_ids_json)
 
         # Populate relationships
         season_guess.team_winners = [
-            Driver.from_db_driver(find_single_driver_strict(driver_name)) if driver_name is not None else None
-            for driver_name in team_winners
+            Driver.from_db_driver(find_single_driver_strict(int(driver_id))) if driver_id is not None else None
+            for driver_id in team_winners
         ]
         season_guess.podiums = [
-            Driver.from_db_driver(find_single_driver_strict(driver_name))
-            for driver_name in podiums
+            Driver.from_db_driver(find_single_driver_strict(int(driver_id)))
+            for driver_id in podiums
         ]
 
         return season_guess
@@ -46,16 +46,15 @@ class SeasonGuess():
         ]
 
         # Serialize to json
-        db_season_guess: DbSeasonGuess = DbSeasonGuess(user_name=self.user.name,
-                                                       team_winners_driver_names_json=json.dumps(team_winners),
-                                                       podium_drivers_driver_names_json=json.dumps(podiums))
-        db_season_guess.user_name = self.user.name
+        db_season_guess: DbSeasonGuess = DbSeasonGuess(user_id=self.user.id)
         db_season_guess.hot_take = self.hot_take
-        db_season_guess.p2_team_name = self.p2_wcc.name if self.p2_wcc is not None else None
-        db_season_guess.overtake_driver_name = self.most_overtakes.name if self.most_overtakes is not None else None
-        db_season_guess.dnf_driver_name = self.most_dnfs.name if self.most_dnfs is not None else None
-        db_season_guess.gained_driver_name = self.most_wdc_gained.name if self.most_wdc_gained is not None else None
-        db_season_guess.lost_driver_name = self.most_wdc_lost.name if self.most_wdc_lost is not None else None
+        db_season_guess.p2_team_id = self.p2_wcc.id if self.p2_wcc is not None else None
+        db_season_guess.overtake_driver_id = self.most_overtakes.id if self.most_overtakes is not None else None
+        db_season_guess.dnf_driver_id = self.most_dnfs.id if self.most_dnfs is not None else None
+        db_season_guess.gained_driver_id = self.most_wdc_gained.id if self.most_wdc_gained is not None else None
+        db_season_guess.lost_driver_id = self.most_wdc_lost.id if self.most_wdc_lost is not None else None
+        db_season_guess.team_winners_driver_ids_json=json.dumps(team_winners)
+        db_season_guess.podium_drivers_driver_ids_json=json.dumps(podiums)
 
         return db_season_guess
 

formula10/domain/model/season_guess_result.py

@@ -12,6 +12,12 @@ class SeasonGuessResult():
 
         return season_guess_result
 
+    def to_db_season_guess_result(self) -> DbSeasonGuessResult:
+        db_season_guess_result: DbSeasonGuessResult = DbSeasonGuessResult(user_id=self.user.id)
+        db_season_guess_result.hot_take_correct = self.hot_take_correct
+        db_season_guess_result.overtakes_correct = self.overtakes_correct
+        return db_season_guess_result
+
     user: User
     hot_take_correct: bool
     overtakes_correct: bool

formula10/domain/model/team.py

@@ -7,19 +7,25 @@ class Team():
     @classmethod
     def from_db_team(cls, db_team: DbTeam):
         team: Team = cls()
+        team.id = db_team.id
         team.name = db_team.name
         return team
 
     def to_db_team(self) -> DbTeam:
-        db_team: DbTeam = DbTeam(name=self.name)
+        db_team: DbTeam = DbTeam(id=self.id)
+        db_team.name = self.name
         return db_team
 
     def __eq__(self, __value: object) -> bool:
         if isinstance(__value, Team):
-            return self.name == __value.name
+            return self.id == __value.id
 
         return NotImplemented
 
+    def __hash__(self) -> int:
+        return hash(self.id)
+
+    id: int
     name: str
 
     @property
@@ -27,4 +33,5 @@ class Team():
         return quote(self.name)
 
 NONE_TEAM: Team = Team()
+NONE_TEAM.id = 0
 NONE_TEAM.name = "None"

formula10/domain/model/user.py

@@ -7,20 +7,27 @@ class User():
     @classmethod
     def from_db_user(cls, db_user: DbUser):
         user: User = cls()
+        user.id = db_user.id
         user.name = db_user.name
         user.enabled = db_user.enabled
         return user
 
     def to_db_user(self) -> DbUser:
-        db_user: DbUser = DbUser(name=self.name, enabled=self.enabled)
+        db_user: DbUser = DbUser(id=self.id)
+        db_user.name = self.name
+        db_user.enabled = self.enabled
         return db_user
 
     def __eq__(self, __value: object) -> bool:
         if isinstance(__value, User):
-            return self.name == __value.name
+            return self.id == __value.id
 
         return NotImplemented
 
+    def __hash__(self) -> int:
+        return hash(self.id)
+
+    id: int
     name: str
     enabled: bool
 

formula10/domain/points_model.py

@@ -51,14 +51,14 @@ WDC_STANDING_2023: Dict[str, int] = {
     "Charles Leclerc": 5,
     "Lando Norris": 6,
     "Carlos Sainz": 7,
-    "George Russel": 8,  # @todo typo
+    "George Russell": 8,
     "Oscar Piastri": 9,
     "Lance Stroll": 10,
     "Pierre Gasly": 11,
     "Esteban Ocon": 12,
     "Alexander Albon": 13,
     "Yuki Tsunoda": 14,
-    "Valteri Bottas": 15,  # @todo typo
+    "Valtteri Bottas": 15,
     "Nico Hulkenberg": 16,
     "Daniel Ricciardo": 17,
     "Zhou Guanyu": 18,

formula10/domain/template_model.py

@@ -6,7 +6,7 @@ from formula10.domain.model.driver import Driver
 from formula10.domain.model.race import Race
 from formula10.domain.model.race_result import RaceResult
 from formula10.domain.model.user import User
-from formula10.database.validation import find_first_else_none, find_multiple_strict, race_has_started
+from formula10.database.validation import find_first_else_none, find_multiple_strict, find_single_strict, race_has_started
 
 
 class TemplateModel(Model):
@@ -33,10 +33,12 @@ class TemplateModel(Model):
         return not race_has_started(race=race) if ENABLE_TIMING else True
 
     def season_guess_open(self) -> bool:
-        return not race_has_started(race_name="Bahrain") if ENABLE_TIMING else True
+        return not race_has_started(race_id=1) if ENABLE_TIMING else True
 
     def race_result_open(self, race_name: str) -> bool:
-        return race_has_started(race_name=race_name) if ENABLE_TIMING else True
+        predicate: Callable[[Race], bool] = lambda race: race.name == race_name
+        race: Race = find_single_strict(predicate, self.all_races())
+        return race_has_started(race_id=race.id) if ENABLE_TIMING else True
 
     def active_user_name_or_everyone(self) -> str:
         return self.active_user.name if self.active_user is not None else "Everyone"