RareGame: Resolve and cache steam grade

rare/models/game.py

@@ -1,5 +1,6 @@
 import json
 import os
+import platform
 from abc import abstractmethod
 from dataclasses import dataclass, field
 from datetime import datetime
@@ -7,7 +8,7 @@ from enum import IntEnum
 from logging import getLogger
 from typing import List, Optional, Dict
 
-from PyQt5.QtCore import QObject, pyqtSignal, QRunnable, pyqtSlot, QProcess
+from PyQt5.QtCore import QObject, pyqtSignal, QRunnable, pyqtSlot, QProcess, QThreadPool
 from PyQt5.QtGui import QPixmap
 from legendary.models.game import Game, InstalledGame, SaveGameFile
 
@@ -16,6 +17,7 @@ from rare.models.install import InstallOptionsModel, UninstallOptionsModel
 from rare.shared.game_process import GameProcess
 from rare.shared.image_manager import ImageManager
 from rare.utils.paths import data_dir, get_rare_executable
+from rare.utils.steam_grades import get_rating
 
 logger = getLogger("RareGame")
 
@@ -217,7 +219,8 @@ class RareGame(RareGameSlim):
         self.game_process.finished.connect(self.__game_finished)
         if self.is_installed and not self.is_dlc:
             self.game_process.connect_to_server(on_startup=True)
-        # self.grant_date(True)
+
+        self.__steam_grade: Optional[str] = None
 
     def __on_progress_update(self, progress: int):
         self.progress = progress
@@ -512,6 +515,21 @@ class RareGame(RareGameSlim):
             return self.game.metadata.get("customAttributes", {}).get("CloudSaveFolder", {}).get("value")
         return ""
 
+    def steam_grade(self) -> str:
+        if platform.system() == "Windows" or self.is_unreal:
+            return "na"
+        if self.__steam_grade is not None:
+            return self.__steam_grade
+        worker = QRunnable.create(
+            lambda: self.set_steam_grade(get_rating(self.core, self.app_name))
+        )
+        QThreadPool.globalInstance().start(worker)
+        return "pending"
+
+    def set_steam_grade(self, grade: str) -> None:
+        self.__steam_grade = grade
+        self.signals.widget.update.emit()
+
     def grant_date(self, force=False) -> datetime:
         if self.metadata.grant_date is None or force:
             entitlements = self.core.lgd.entitlements

rare/utils/steam_grades.py

@@ -7,15 +7,13 @@ import requests
 from PyQt5.QtCore import pyqtSignal, QRunnable, QObject, QCoreApplication
 
 from rare.lgndr.core import LegendaryCore
-from rare.shared import LegendaryCoreSingleton, ArgumentsSingleton
-from rare.shared.workers import Worker
 from rare.utils.paths import data_dir, cache_dir
 
 replace_chars = ",;.:-_ "
 url = "https://api.steampowered.com/ISteamApps/GetAppList/v2/"
 
 
-class SteamWorker(Worker):
+class SteamWorker(QRunnable):
     class Signals(QObject):
         rating = pyqtSignal(str)
 
@@ -31,23 +29,22 @@ class SteamWorker(Worker):
             "silver": _tr("SteamWorker", "Silver"),
             "bronze": _tr("SteamWorker", "Bronze"),
             "fail": _tr("SteamWorker", "Could not get grade"),
-            "borked": _tr("SteamWorker", "unplayable"),
-            "pending": _tr("SteamWorker", "Could not get grade"),
+            "borked": _tr("SteamWorker", "Borked"),
+            "pending": _tr("SteamWorker", "Loading..."),
         }
 
-    def run_real(self) -> None:
+    def run(self) -> None:
         self.signals.rating.emit(
-            self.ratings.get(get_rating(self.app_name), self.ratings["fail"])
+            self.ratings.get(get_rating(self.core, self.app_name), self.ratings["fail"])
         )
+        self.signals.deleteLater()
 
 
 __steam_ids_json = None
 __grades_json = None
 
 
-def get_rating(app_name: str):
-    core = LegendaryCoreSingleton()
-    args = ArgumentsSingleton()
+def get_rating(core: LegendaryCore, app_name: str):
     global __grades_json
     if __grades_json is None:
         if os.path.exists(p := os.path.join(data_dir(), "steam_ids.json")):
@@ -60,12 +57,12 @@ def get_rating(app_name: str):
         grades = __grades_json
 
     if not grades.get(app_name):
-        if args.offline:
-            return "pending"
         game = core.get_game(app_name)
-
-        steam_id = get_steam_id(game.app_title)
-        grade = get_grade(steam_id)
+        try:
+            steam_id = get_steam_id(game.app_title)
+            grade = get_grade(steam_id)
+        except:
+            return "fail"
         grades[app_name] = {"steam_id": steam_id, "grade": grade}
         with open(os.path.join(data_dir(), "steam_ids.json"), "w") as f:
             f.write(json.dumps(grades))