Add a shitload of caching

formula10/domain/domain_model.py

@@ -18,133 +18,97 @@ from formula10.domain.model.season_guess import SeasonGuess
 from formula10.domain.model.season_guess_result import SeasonGuessResult
 from formula10.domain.model.team import NONE_TEAM, Team
 from formula10.domain.model.user import User
-from formula10 import db
+from formula10 import db, cache
 
 
 class Model:
-    _all_users: List[User] | None = None
-    _all_race_results: List[RaceResult] | None = None
-    _all_race_guesses: List[RaceGuess] | None = None
-    _all_season_guesses: List[SeasonGuess] | None = None
-    _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]:
+    @staticmethod
+    @cache.cached(timeout=None, key_prefix="domain_all_users") # Clear when adding/deleting users
+    def all_users() -> List[User]:
         """
         Returns a list of all enabled users.
         """
-        if self._all_users is None:
-            self._all_users = [
-                User.from_db_user(db_user)
-                for db_user in db.session.query(DbUser).filter_by(enabled=True).all()
-            ]
+        db_users = db.session.query(DbUser).filter_by(enabled=True).all()
+        return [User.from_db_user(db_user) for db_user in db_users]
 
-        return self._all_users
-
-    def all_race_results(self) -> List[RaceResult]:
+    @staticmethod
+    @cache.cached(timeout=None, key_prefix="domain_all_race_results") # Clear when adding/updating results
+    def all_race_results() -> List[RaceResult]:
         """
         Returns a list of all race results, in descending order (most recent first).
         """
-        if self._all_race_results is None:
-            self._all_race_results = [
-                RaceResult.from_db_race_result(db_race_result)
-                for db_race_result in db.session.query(DbRaceResult).join(DbRaceResult.race).order_by(desc("number")).all()
-            ]
+        db_race_results = db.session.query(DbRaceResult).join(DbRaceResult.race).order_by(desc("number")).all()
+        return [RaceResult.from_db_race_result(db_race_result) for db_race_result in db_race_results]
 
-        return self._all_race_results
-
-    def all_race_guesses(self) -> List[RaceGuess]:
+    @staticmethod
+    @cache.cached(timeout=None, key_prefix="domain_all_race_guesses") # Clear when adding/updating race guesses or users
+    def all_race_guesses() -> List[RaceGuess]:
         """
         Returns a list of all race guesses (of enabled users).
         """
-        if self._all_race_guesses is None:
-            self._all_race_guesses = [
-                RaceGuess.from_db_race_guess(db_race_guess)
-                for db_race_guess in db.session.query(DbRaceGuess).join(DbRaceGuess.user).filter_by(enabled=True).all()  # Ignore disabled users
-            ]
+        db_race_guesses = db.session.query(DbRaceGuess).join(DbRaceGuess.user).filter_by(enabled=True).all()
+        return [RaceGuess.from_db_race_guess(db_race_guess) for db_race_guess in db_race_guesses]
 
-        return self._all_race_guesses
-
-    def all_season_guesses(self) -> List[SeasonGuess]:
+    @staticmethod
+    @cache.cached(timeout=None, key_prefix="domain_all_season_guesses") # Clear when adding/updating season guesses or users
+    def all_season_guesses() -> List[SeasonGuess]:
         """
         Returns a list of all season guesses (of enabled users).
         """
-        if self._all_season_guesses is None:
-            self._all_season_guesses = [
-                SeasonGuess.from_db_season_guess(db_season_guess)
-                for db_season_guess in db.session.query(DbSeasonGuess).join(DbSeasonGuess.user).filter_by(enabled=True).all()  # Ignore disabled users
-            ]
+        db_season_guesses = db.session.query(DbSeasonGuess).join(DbSeasonGuess.user).filter_by(enabled=True).all()
+        return [SeasonGuess.from_db_season_guess(db_season_guess) for db_season_guess in db_season_guesses]
 
-        return self._all_season_guesses
+    @staticmethod
+    @cache.cached(timeout=None, key_prefix="domain_all_season_guess_results") # No cleanup, bc entered manually
+    def all_season_guess_results() -> List[SeasonGuessResult]:
+        """
+        Returns a list of all season guess results (of enabled users).
+        """
+        db_season_guess_results = db.session.query(DbSeasonGuessResult).join(DbSeasonGuessResult.user).filter_by(enabled=True).all()
+        return [SeasonGuessResult.from_db_season_guess_result(db_season_guess_result) for db_season_guess_result in db_season_guess_results]
 
-    def all_season_guess_results(self) -> List[SeasonGuessResult]:
-        if self._all_season_guess_results is None:
-            self._all_season_guess_results = [
-                SeasonGuessResult.from_db_season_guess_result(db_season_guess_result)
-                for db_season_guess_result in db.session.query(DbSeasonGuessResult).join(DbSeasonGuessResult.user).filter_by(enabled=True).all()  # Ignore disabled users
-            ]
-
-        return self._all_season_guess_results
-
-    def all_races(self) -> List[Race]:
+    @staticmethod
+    @cache.cached(timeout=None, key_prefix="domain_all_races") # No cleanup, bc entered manually
+    def all_races() -> List[Race]:
         """
         Returns a list of all races, in descending order (last race first).
         """
-        if self._all_races is None:
-            self._all_races = [
-                Race.from_db_race(db_race)
-                for db_race in db.session.query(DbRace).order_by(desc("number")).all()
-            ]
+        db_races = db.session.query(DbRace).order_by(desc("number")).all()
+        return [Race.from_db_race(db_race) for db_race in db_races]
 
-        return self._all_races
-
-    def all_drivers(self, *, include_none: bool, include_inactive: bool) -> List[Driver]:
+    @staticmethod
+    @cache.memoize(timeout=None) # No cleanup, bc entered manually
+    def all_drivers(*, include_none: bool, include_inactive: bool) -> List[Driver]:
         """
         Returns a list of all active drivers.
         """
-        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()
-                ]
+        db_drivers = db.session.query(DbDriver).all()
+        drivers = [Driver.from_db_driver(db_driver) for db_driver in db_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:
-            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 not include_inactive:
+            predicate: Callable[[Driver], bool] = lambda driver: driver.active
+            drivers = find_multiple_strict(predicate, drivers)
 
-            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)
+        if not include_none:
+            predicate: Callable[[Driver], bool] = lambda driver: driver != NONE_DRIVER
+            drivers = find_multiple_strict(predicate, drivers)
 
-    def all_teams(self, *, include_none: bool) -> List[Team]:
+        return drivers
+
+    @staticmethod
+    @cache.memoize(timeout=None) # No cleanup, bc entered manually
+    def all_teams(*, include_none: bool) -> List[Team]:
         """
         Returns a list of all teams.
         """
-        if self._all_teams is None:
-            self._all_teams = [
-                Team.from_db_team(db_team)
-                for db_team in db.session.query(DbTeam).all()
-            ]
+        db_teams = db.session.query(DbTeam).all()
+        teams = [Team.from_db_team(db_team) for db_team in db_teams]
 
-        if include_none:
-            return self._all_teams
-        else:
+        if not include_none:
             predicate: Callable[[Team], bool] = lambda team: team != NONE_TEAM
-            return find_multiple_strict(predicate, self._all_teams)
+            return find_multiple_strict(predicate, teams)
+
+        return teams
 
     #
     # User queries
@@ -217,6 +181,7 @@ class Model:
         """
         return self.race_guesses_by()
 
+    @cache.memoize(timeout=None, args_to_ignore=["self"]) # Cleanup when adding/updating race guesses or users
     def race_guesses_by(self, *, user_name: str | None = None, race_name: str | None = None) -> RaceGuess | List[RaceGuess] | Dict[str, Dict[str, RaceGuess]] | None:
         # List of all guesses by a single user
         if user_name is not None and race_name is None:
@@ -266,6 +231,7 @@ class Model:
         """
         return self.season_guesses_by()
 
+    @cache.memoize(timeout=None, args_to_ignore=["self"]) # Cleanup when adding/updating season guesses or users
     def season_guesses_by(self, *, user_name: str | None = None) -> SeasonGuess | Dict[str, SeasonGuess] | None:
         if user_name is not None:
             predicate: Callable[[SeasonGuess], bool] = lambda guess: guess.user.name == user_name
@@ -320,6 +286,7 @@ class Model:
         """
         return self.drivers_by(include_inactive=include_inactive)
 
+    @cache.memoize(timeout=None, args_to_ignore=["self"]) # No Cleanup, data added manually
     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