flask-formula10/model.py

from typing import ClassVar, List, Dict

from flask_sqlalchemy import SQLAlchemy
from sqlalchemy import Integer, String, Boolean, DateTime, ForeignKey, PickleType
from sqlalchemy.orm import Mapped, mapped_column, relationship
from datetime import datetime
import json

db = SQLAlchemy()

####################################
# Static Data (Defined in Backend) #
####################################


class Race(db.Model):
    """
    A single race at a certain date and GrandPrix in the calendar.
    It stores the place to guess for this race.
    """
    __tablename__ = "race"

    def from_csv(self, row):
        self.id = int(row[0])
        self.grandprix = str(row[1])
        self.number = int(row[2])
        self.date = datetime.strptime(row[3], "%Y-%m-%d")
        self.pxx = int(row[4])  # This is the place that has to be guessed for this race
        return self

    id: Mapped[int] = mapped_column(Integer, primary_key=True)
    grandprix: Mapped[str] = mapped_column(String(32))
    number: Mapped[int] = mapped_column(Integer)
    date: Mapped[datetime] = mapped_column(DateTime)
    pxx: Mapped[int] = mapped_column(Integer)


class Team(db.Model):
    """
    A constructor/team (name only).
    """
    __tablename__ = "team"

    def from_csv(self, row):
        self.name = str(row[0])
        return self

    name: Mapped[str] = mapped_column(String(32), primary_key=True)


class Driver(db.Model):
    """
    A F1 driver.
    It stores the corresponding team + name abbreviation.
    """
    __tablename__ = "driver"

    def from_csv(self, row):
        self.name = str(row[0])
        self.abbr = str(row[1])
        self.team_id = str(row[2])
        self.country_code = str(row[3])
        return self

    name: Mapped[str] = mapped_column(String(32), primary_key=True)
    abbr: Mapped[str] = mapped_column(String(3))
    team_id: Mapped[str] = mapped_column(ForeignKey("team.name"))
    country_code: Mapped[str] = mapped_column(String(2))  # alpha-2 code

    # Relationships
    team: Mapped["Team"] = relationship("Team", foreign_keys=[team_id])


######################################
# Dynamic Data (Defined in Frontend) #
######################################


class User(db.Model):
    """
    A user that can guess races (name only).
    """
    __tablename__ = "user"
    __csv_header__ = ["name"]

    def from_csv(self, row):
        self.name = str(row[0])
        return self

    def to_csv(self):
        return [
            self.name
        ]

    name: Mapped[str] = mapped_column(String(32), primary_key=True)


class RaceResult(db.Model):
    """
    The result of a past race.
    It stores the corresponding race and dictionaries of place-/dnf-order and a list of drivers that are excluded from the standings for this race.
    """
    __tablename__ = "raceresult"
    __allow_unmapped__ = True
    __csv_header__ = ["id", "race_id", "pxx_ids_json", "dnf_ids_json", "exclude_ids_json"]

    def from_csv(self, row):
        self.id = int(row[0])
        self.race_id = int(row[1])
        self.pxx_ids_json = str(row[2])
        self.dnf_ids_json = str(row[3])
        self.exclude_ids_json = str(row[4])
        return self

    def to_csv(self):
        return [
            self.id,
            self.race_id,
            self.pxx_ids_json,
            self.dnf_ids_json,
            self.exclude_ids_json
        ]

    id: Mapped[int] = mapped_column(Integer, primary_key=True)
    race_id: Mapped[int] = mapped_column(ForeignKey("race.id"))
    pxx_ids_json: Mapped[str] = mapped_column(String(1024))
    dnf_ids_json: Mapped[str] = mapped_column(String(1024))
    exclude_ids_json: Mapped[str] = mapped_column(String(1024))

    @property
    def pxx_ids(self) -> Dict[str, str]:
        return json.loads(self.pxx_ids_json)

    @pxx_ids.setter
    def pxx_ids(self, new_pxx_ids: Dict[str, str]):
        self.pxx_ids_json = json.dumps(new_pxx_ids)

    @property
    def dnf_ids(self) -> Dict[str, str]:
        return json.loads(self.dnf_ids_json)

    @dnf_ids.setter
    def dnf_ids(self, new_dnf_ids: Dict[str, str]):
        self.dnf_ids_json = json.dumps(new_dnf_ids)

    @property
    def exclude_ids(self) -> List[str]:
        return json.loads(self.exclude_ids_json)

    @exclude_ids.setter
    def exclude_ids(self, new_exclude_ids: List[str]):
        self.exclude_ids_json = json.dumps(new_exclude_ids)

    # Relationships
    race: Mapped["Race"] = relationship("Race", foreign_keys=[race_id])
    _pxxs: Dict[str, Driver] | None = None
    _dnfs: Dict[str, Driver] | None = None
    _excludes: List[Driver] | None = None

    @property
    def pxxs(self) -> Dict[str, Driver]:
        if self._pxxs is None:
            self._pxxs = dict()
            for position, driver_id in self.pxx_ids.items():
                driver = Driver.query.filter_by(name=driver_id).first()
                if driver is None:
                    raise Exception(f"Error: Couldn't find driver with id {driver_id}")

                self._pxxs[position] = driver

        return self._pxxs

    @property
    def dnfs(self) -> Dict[str, Driver]:
        if self._dnfs is None:
            self._dnfs = dict()
            for position, driver_id in self.dnf_ids.items():
                driver = Driver.query.filter_by(name=driver_id).first()
                if driver is None:
                    raise Exception(f"Error: Couldn't find driver with id {driver_id}")

                self._dnfs[position] = driver

        return self._dnfs

    @property
    def excludes(self) -> List[Driver]:
        if self._excludes is None:
            self._excludes = []
            for driver_id in self.exclude_ids:
                driver = Driver.query.filter_by(name=driver_id).first()
                if driver is None:
                    raise Exception(f"Error: Couldn't find driver with id {driver_id}")

                self._excludes += [driver]

        return self._excludes

    @property
    def pxx(self) -> Driver:
        pxx_num: str = str(self.race.pxx)
        if pxx_num not in self.pxxs:
            print(self.pxxs)
            raise Exception(f"Error: Position {self.race.pxx} not contained in race result")

        return self.pxxs[pxx_num]

    @property
    def dnf(self) -> Driver:
        return sorted(self.dnfs.items(), reverse=True)[0][1]


class RaceGuess(db.Model):
    """
    A guess a user made for a race.
    It stores the corresponding race and the guessed drivers for PXX and DNF.
    """
    __tablename__ = "raceguess"
    __csv_header__ = ["id", "user_id", "race_id", "pxx_id", "dnf_id"]

    def from_csv(self, row):
        self.id = int(row[0])
        self.user_id = str(row[1])
        self.race_id = int(row[2])
        self.pxx_id = str(row[3])
        self.dnf_id = str(row[4])
        return self

    def to_csv(self):
        return [
            self.id,
            self.user_id,
            self.race_id,
            self.pxx_id,
            self.dnf_id
        ]

    id: Mapped[int] = mapped_column(Integer, primary_key=True)
    user_id: Mapped[str] = mapped_column(ForeignKey("user.name"))
    race_id: Mapped[int] = mapped_column(ForeignKey("race.id"))
    pxx_id: Mapped[str] = mapped_column(ForeignKey("driver.name"))
    dnf_id: Mapped[str] = mapped_column(ForeignKey("driver.name"))

    # Relationships
    user: Mapped["User"] = relationship("User", foreign_keys=[user_id])
    race: Mapped["Race"] = relationship("Race", foreign_keys=[race_id])
    pxx: Mapped["Driver"] = relationship("Driver", foreign_keys=[pxx_id])
    dnf: Mapped["Driver"] = relationship("Driver", foreign_keys=[dnf_id])


class TeamWinners(db.Model):
    """
    A guessed list of each best driver per team.
    """
    __tablename__ = "teamwinners"
    __allow_unmapped__ = True
    __csv_header__ = ["id", "user_id", "winner_ids_json"]

    def from_csv(self, row):
        self.id = int(row[0])
        self.user_id = str(row[1])
        self.winner_ids_json = str(row[2])
        return self

    def to_csv(self):
        return [
            self.id,
            self.user_id,
            self.winner_ids_json
        ]

    id: Mapped[int] = mapped_column(Integer, primary_key=True)
    user_id: Mapped[str] = mapped_column(ForeignKey("user.name"))
    winner_ids_json: Mapped[str] = mapped_column(String(512))

    @property
    def winner_ids(self) -> List[str]:
        return json.loads(self.winner_ids_json)

    @winner_ids.setter
    def winner_ids(self, new_winner_ids: List[str]):
        self.winner_ids_json = json.dumps(new_winner_ids)

    # Relationships
    user: Mapped["User"] = relationship("User", foreign_keys=[user_id])
    _winners: List[Driver] | None = None

    @property
    def winners(self) -> List[Driver]:
        if self._winners is None:
            self._winners = []
            for driver_id in self.winner_ids:
                driver = Driver.query.filter_by(name=driver_id).first()
                if driver is None:
                    raise Exception(f"Error: Couldn't find driver with id {driver_id}")

                self._winners += [driver]


        return self._winners


class PodiumDrivers(db.Model):
    """
    A guessed list of each driver that will reach at least a single podium.
    """
    __tablename__ = "podiumdrivers"
    __allow_unmapped__ = True
    __csv_header__ = ["id", "user_id", "podium_ids_json"]

    def from_csv(self, row):
        self.id = int(row[0])
        self.user_id = str(row[1])
        self.podium_ids_json = str(row[2])
        return self

    def to_csv(self):
        return [
            self.id,
            self.user_id,
            self.podium_ids_json
        ]

    id: Mapped[int] = mapped_column(Integer, primary_key=True)
    user_id: Mapped[str] = mapped_column(ForeignKey("user.name"))
    podium_ids_json: Mapped[str] = mapped_column(String(512))

    @property
    def podium_ids(self) -> List[str]:
        return json.loads(self.podium_ids_json)

    @podium_ids.setter
    def podium_ids(self, new_podium_ids: List[str]):
        self.podium_ids_json = json.dumps(new_podium_ids)

    # Relationships
    user: Mapped["User"] = relationship("User", foreign_keys=[user_id])
    _podiums: List[Driver] | None = None

    @property
    def podiums(self) -> List[Driver]:
        if self._podiums is None:
            self._podiums = []
            for driver_id in self.podium_ids:
                driver = Driver.query.filter_by(name=driver_id).first()
                if driver is None:
                    raise Exception(f"Error: Couldn't find driver with id {driver_id}")

                self._podiums += [driver]

        return self._podiums


class SeasonGuess(db.Model):
    """
    A collection of bonus guesses for the entire season.
    """
    __tablename__ = "seasonguess"
    __csv_header__ = ["id", "user_id",
                      "hot_take", "p2_constructor_id", "most_overtakes_id", "most_dnfs_id", "most_gained_id",
                      "most_lost_id", "team_winners_id", "podium_drivers_id"]

    def from_csv(self, row):
        self.id = int(row[0])
        self.user_id = str(row[1])
        self.hot_take = str(row[2])
        self.p2_constructor_id = str(row[3])
        self.most_overtakes_id = str(row[4])
        self.most_dnfs_id = str(row[5])
        self.most_gained_id = str(row[6])
        self.most_lost_id = str(row[6])
        self.team_winners_id = int(row[8])
        self.podium_drivers_id = int(row[9])
        return self

    def to_csv(self):
        return [
            self.id,
            self.user_id,
            self.hot_take,
            self.p2_constructor_id,
            self.most_overtakes_id,
            self.most_dnfs_id,
            self.most_gained_id,
            self.most_lost_id,
            self.team_winners_id,
            self.podium_drivers_id
        ]

    id: Mapped[int] = mapped_column(Integer, primary_key=True)
    user_id: Mapped[str] = mapped_column(ForeignKey("user.name"))
    hot_take: Mapped[str] = mapped_column(String(512))
    p2_constructor_id: Mapped[str] = mapped_column(ForeignKey("team.name"))
    most_overtakes_id: Mapped[str] = mapped_column(ForeignKey("driver.name"))
    most_dnfs_id: Mapped[str] = mapped_column(ForeignKey("driver.name"))
    most_gained_id: Mapped[str] = mapped_column(ForeignKey("driver.name"))
    most_lost_id: Mapped[str] = mapped_column(ForeignKey("driver.name"))
    team_winners_id: Mapped[int] = mapped_column(ForeignKey("teamwinners.id"))
    podium_drivers_id: Mapped[int] = mapped_column(ForeignKey("podiumdrivers.id"))

    # Relationships
    user: Mapped["User"] = relationship("User", foreign_keys=[user_id])
    p2_constructor: Mapped["Team"] = relationship("Team", foreign_keys=[p2_constructor_id])
    most_overtakes: Mapped["Driver"] = relationship("Driver", foreign_keys=[most_overtakes_id])
    most_dnfs: Mapped["Driver"] = relationship("Driver", foreign_keys=[most_dnfs_id])
    most_gained: Mapped["Driver"] = relationship("Driver", foreign_keys=[most_gained_id])
    most_lost: Mapped["Driver"] = relationship("Driver", foreign_keys=[most_lost_id])
    team_winners: Mapped["TeamWinners"] = relationship("TeamWinners", foreign_keys=[team_winners_id])
    podium_drivers: Mapped["PodiumDrivers"] = relationship("PodiumDrivers", foreign_keys=[podium_drivers_id])