Reduce memory requirements for steam app id completion

rare/components/tabs/downloads/widgets.py

@@ -96,7 +96,13 @@ def __init__(self, imgmgr: ImageManager, game: Game, igame: InstalledGame, paren
     def update_game(self, auto: bool):
         self.ui.update_button.setDisabled(True)
         self.ui.settings_button.setDisabled(True)
-        self.enqueue.emit(InstallOptionsModel(app_name=self.game.app_name, update=True, silent=auto))  # True if settings
+        self.enqueue.emit(InstallOptionsModel(
+            app_name=self.game.app_name,
+            base_path=self.igame.install_path,
+            platform=self.igame.platform,
+            update=True,
+            silent=auto, # True if settings
+        ))
 
     def set_enabled(self, enabled: bool):
         self.ui.update_button.setEnabled(enabled)

rare/components/tabs/integrations/import_group.py

@@ -102,16 +102,16 @@ def run(self) -> None:
             for i, child in enumerate(folders):
                 if not child.is_dir():
                     continue
-                result = self.__try_import(child, None)
+                result = self._try_import(child, None)
                 result_list.append(result)
                 self.signals.progress.emit(result, int(100 * i // number_of_folders))
         else:
-            result = self.__try_import(self.path, self.app_name)
+            result = self._try_import(self.path, self.app_name)
             result_list.append(result)
             self.signals.progress.emit(result, 100)
         self.signals.result.emit(result_list)
 
-    def __try_import(self, path: Path, app_name: str = None) -> ImportedGame:
+    def _try_import(self, path: Path, app_name: str = None) -> ImportedGame:
         result = ImportedGame(ImportResult.ERROR)
         result.path = str(path)
         if app_name or (app_name := find_app_name(self.core, str(path))):
@@ -121,15 +121,15 @@ def __try_import(self, path: Path, app_name: str = None) -> ImportedGame:
             platform = self.platform
             if platform not in self.core.get_game(app_name, update_meta=False).asset_infos:
                 platform = "Windows"
-            success, message = self.__import_game(path, app_name, platform)
+            success, message = self._import_game(path, app_name, platform)
             if not success:
                 result.result = ImportResult.FAILED
                 result.message = message
             else:
                 result.result = ImportResult.SUCCESS
         return result
 
-    def __import_game(self, path: Path, app_name: str, platform: str):
+    def _import_game(self, path: Path, app_name: str, platform: str):
         cli = LegendaryCLI(self.core)
         status = LgndrIndirectStatus()
         args = LgndrImportGameArgs(
@@ -158,17 +158,17 @@ def __init__(self, rcore: RareCore, parent=None):
         self.worker: Optional[ImportWorker] = None
         self.threadpool = QThreadPool.globalInstance()
 
-        self.__app_names: Dict[str, str] = None
-        self.__app_titles: Dict[str, str] = None
-        self.__install_dirs: Set[str] = None
+        self._app_names: Dict[str, str] = {}
+        self._app_titles: Dict[str, str] = {}
+        self._install_dirs: Set[str] = set()
 
         self.path_edit = PathEdit(
             path=self.core.get_default_install_dir(self.core.default_platform),
             file_mode=QFileDialog.FileMode.Directory,
-            edit_func=self.__path_edit_callback,
+            edit_func=self._path_edit_callback,
             parent=self,
         )
-        self.path_edit.textChanged.connect(self.__path_changed)
+        self.path_edit.textChanged.connect(self._path_changed)
         self.ui.import_layout.setWidget(
             self.ui.import_layout.getWidgetPosition(self.ui.path_edit_label)[0],
             QFormLayout.ItemRole.FieldRole,
@@ -177,11 +177,11 @@ def __init__(self, rcore: RareCore, parent=None):
 
         self.app_name_edit = IndicatorLineEdit(
             placeholder=self.tr("Use in case the app name was not found automatically"),
-            edit_func=self.__app_name_edit_callback,
-            save_func=self.__app_name_save_callback,
+            edit_func=self._app_name_edit_callback,
+            save_func=self._app_name_save_callback,
             parent=self,
         )
-        self.app_name_edit.textChanged.connect(self.__app_name_changed)
+        self.app_name_edit.textChanged.connect(self._app_name_changed)
         self.ui.import_layout.setWidget(
             self.ui.import_layout.getWidgetPosition(self.ui.app_name_label)[0],
             QFormLayout.ItemRole.FieldRole,
@@ -194,7 +194,7 @@ def __init__(self, rcore: RareCore, parent=None):
 
         self.ui.import_button_label.setText("")
         self.ui.import_button.setEnabled(False)
-        self.ui.import_button.clicked.connect(lambda: self.__import(self.path_edit.text()))
+        self.ui.import_button.clicked.connect(lambda: self._import(self.path_edit.text()))
 
         self.button_info_stack = QStackedWidget(self)
         self.button_info_stack.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
@@ -210,11 +210,14 @@ def __init__(self, rcore: RareCore, parent=None):
     def showEvent(self, a0: QShowEvent) -> None:
         if a0.spontaneous():
             return super().showEvent(a0)
-        self.__app_names = {rgame.app_title: rgame.app_name for rgame in self.rcore.games}
-        self.__app_titles = {rgame.app_name: rgame.app_title for rgame in self.rcore.games}
-        self.__install_dirs = {rgame.folder_name for rgame in self.rcore.games if not rgame.is_dlc}
-        self.app_name_edit.setCompleter(ColumnCompleter(items=self.__app_names.items()))
-        super().showEvent(a0)
+        if not self._app_names:
+            self._app_names = {rgame.app_title: rgame.app_name for rgame in self.rcore.games}
+        if not self._app_titles:
+            self._app_titles = {rgame.app_name: rgame.app_title for rgame in self.rcore.games}
+        if not self._install_dirs:
+            self._install_dirs = {rgame.folder_name for rgame in self.rcore.games if not rgame.is_dlc}
+        self.app_name_edit.setCompleter(ColumnCompleter(items=self._app_names))
+        return super().showEvent(a0)
 
     def set_game(self, app_name: str):
         if app_name:
@@ -227,17 +230,17 @@ def set_game(self, app_name: str):
             )
             self.app_name_edit.setText(app_name)
 
-    def __path_edit_callback(self, path) -> Tuple[bool, str, int]:
+    def _path_edit_callback(self, path) -> Tuple[bool, str, int]:
         if not os.path.exists(path):
             return False, path, IndicatorReasonsCommon.DIR_NOT_EXISTS
         if os.path.exists(os.path.join(path, ".egstore")):
             return True, path, IndicatorReasonsCommon.VALID
-        elif os.path.basename(path) in self.__install_dirs:
+        elif os.path.basename(path) in self._install_dirs:
             return True, path, IndicatorReasonsCommon.VALID
         return False, path, IndicatorReasonsCommon.INVALID
 
     @Slot(str)
-    def __path_changed(self, path: str):
+    def _path_changed(self, path: str):
         self.info_label.setText("")
         self.ui.import_folder_check.setCheckState(Qt.CheckState.Unchecked)
         self.ui.import_force_check.setCheckState(Qt.CheckState.Unchecked)
@@ -246,26 +249,26 @@ def __path_changed(self, path: str):
         else:
             self.app_name_edit.setText("")
 
-    def __app_name_edit_callback(self, text) -> Tuple[bool, str, int]:
+    def _app_name_edit_callback(self, text) -> Tuple[bool, str, int]:
         self.app_name_edit.setInfo("")
         if not text:
             return False, text, IndicatorReasonsCommon.UNDEFINED
-        if text in self.__app_names.keys():
-            return True, self.__app_names[text], IndicatorReasonsCommon.VALID
-        if text in self.__app_titles.keys():
+        if text in self._app_names.keys():
+            return True, self._app_names[text], IndicatorReasonsCommon.VALID
+        if text in self._app_titles.keys():
             return True, text, IndicatorReasonsCommon.VALID
         else:
             return False, text, IndicatorReasonsCommon.GAME_NOT_EXISTS
 
-    def __app_name_save_callback(self, text) -> None:
+    def _app_name_save_callback(self, text) -> None:
         rgame = self.rcore.get_game(text)
         self.app_name_edit.setInfo(rgame.app_title)
         self.ui.platform_combo.clear()
         self.ui.platform_combo.addItems(rgame.platforms)
         self.ui.platform_combo.setCurrentText(rgame.default_platform)
 
     @Slot(str)
-    def __app_name_changed(self, app_name: str):
+    def _app_name_changed(self, app_name: str):
         self.info_label.setText("")
         self.ui.import_dlcs_check.setCheckState(Qt.CheckState.Unchecked)
         self.ui.import_force_check.setCheckState(Qt.CheckState.Unchecked)
@@ -303,7 +306,7 @@ def import_dlcs_changed(self, state: Qt.CheckState):
         )
 
     @Slot(str)
-    def __import(self, path: Optional[str] = None):
+    def _import(self, path: Optional[str] = None):
         self.ui.import_button.setDisabled(True)
         self.info_label.setText(self.tr("Status: Importing games"))
         self.info_progress.setValue(0)
@@ -320,20 +323,20 @@ def __import(self, path: Optional[str] = None):
             import_dlcs=self.ui.import_dlcs_check.isChecked(),
             import_force=self.ui.import_force_check.isChecked(),
         )
-        self.worker.signals.progress.connect(self.__on_import_progress)
-        self.worker.signals.result.connect(self.__on_import_result)
+        self.worker.signals.progress.connect(self._on_import_progress)
+        self.worker.signals.result.connect(self._on_import_result)
         self.threadpool.start(self.worker)
 
     @Slot(ImportedGame, int)
-    def __on_import_progress(self, imported: ImportedGame, progress: int):
+    def _on_import_progress(self, imported: ImportedGame, progress: int):
         self.info_progress.setValue(progress)
         if imported.result == ImportResult.SUCCESS:
             self.rcore.get_game(imported.app_name).set_installed(True)
         status = "error" if not imported.result else ("failed" if imported.result == ImportResult.FAILED else "successful")
         logger.info(f"Import {status}: {imported.app_title}: {imported.path} ({imported.message})")
 
     @Slot(list)
-    def __on_import_result(self, result: List[ImportedGame]):
+    def _on_import_result(self, result: List[ImportedGame]):
         self.worker = None
         self.button_info_stack.setCurrentWidget(self.info_label)
         if len(result) == 1:

rare/components/tabs/library/details/compat.py

@@ -3,7 +3,7 @@
 from typing import Tuple
 
 from PySide6.QtCore import QSignalBlocker, Qt, Slot
-from PySide6.QtGui import QShowEvent
+from PySide6.QtGui import QHideEvent, QShowEvent
 
 from rare.components.tabs.settings.compat import CompatSettingsBase
 from rare.components.tabs.settings.widgets.overlay import (
@@ -17,8 +17,8 @@
 from rare.models.settings import RareAppSettings, app_settings
 from rare.shared import RareCore
 from rare.utils import config_helper as config
-from rare.utils import steam_grades
 from rare.utils.paths import compat_shaders_dir, proton_compat_dir, wine_prefix_dir
+from rare.utils.steam_grades import SteamGrades
 from rare.widgets.indicator_edit import (
     ColumnCompleter,
     IndicatorLineEdit,
@@ -74,36 +74,44 @@ def __init__(self, settings: RareAppSettings, rcore: RareCore, parent=None):
             save_func=self.__steam_appid_save_callback,
             parent=self,
         )
-        self.__steam_appids, self.__steam_titles = steam_grades.load_steam_appids()
-        self.steam_appid_edit.setCompleter(ColumnCompleter(items=self.__steam_appids.items()))
         self.form_layout.addRow(self.tr("Steam AppID"), self.steam_appid_edit)
 
-    def showEvent(self, a0: QShowEvent):
-        if a0.spontaneous():
-            return super().showEvent(a0)
+        self.__grades = SteamGrades()
+
+    def showEvent(self, e: QShowEvent):
+        if e.spontaneous():
+            return super().showEvent(e)
         _ = QSignalBlocker(self.shader_cache_check)
         is_local_cache_enabled = self.settings.get_with_global(app_settings.local_shader_cache, self.rgame.app_name)
         has_local_cache_path = bool(config.get_envvar(self.app_name, "STEAM_COMPAT_SHADER_PATH", False))
         self.shader_cache_check.setChecked(is_local_cache_enabled or has_local_cache_path)
         self.shader_cache_check.setChecked(is_local_cache_enabled or has_local_cache_path)
         _ = QSignalBlocker(self.steam_appid_edit)
+        items = {k: v for k, v in self.__grades.steam_appids.items() if self.rgame.app_title.lower()[0:4] in k.lower()[0:4]}
+        self.steam_appid_edit.setCompleter(ColumnCompleter(items=items))
         self.steam_appid_edit.setText(self.rgame.steam_appid if self.rgame.steam_appid else "")
-        self.steam_appid_edit.setInfo(self.__steam_titles.get(self.rgame.steam_appid, ""))
-        return super().showEvent(a0)
+        self.steam_appid_edit.setInfo(self.__grades.steam_titles.get(self.rgame.steam_appid, ""))
+        return super().showEvent(e)
+
+    def hideEvent(self, e: QHideEvent):
+        if e.spontaneous():
+            return super().hideEvent(e)
+        self.steam_appid_edit.setCompleter(None)
+        return super().hideEvent(e)
 
     def __steam_appid_edit_callback(self, text: str) -> Tuple[bool, str, int]:
         self.steam_appid_edit.setInfo("")
-        if not text:
+        if not text or len(text) < 3:
             return True, text, IndicatorReasonsCommon.UNDEFINED
-        if text in self.__steam_appids.keys():
-            return True, self.__steam_appids[text], IndicatorReasonsCommon.VALID
-        if text in self.__steam_titles.keys():
+        if text in self.__grades.steam_appids.keys():
+            return True, self.__grades.steam_appids[text], IndicatorReasonsCommon.VALID
+        if text in self.__grades.steam_titles.keys():
             return True, text, IndicatorReasonsCommon.VALID
         else:
             return False, text, IndicatorReasonsCommon.GAME_NOT_EXISTS
 
     def __steam_appid_save_callback(self, text: str) -> None:
-        self.steam_appid_edit.setInfo(self.__steam_titles.get(text, ""))
+        self.steam_appid_edit.setInfo(self.__grades.steam_titles.get(text, ""))
         if text == self.rgame.steam_appid:
             return
         self.rgame.steam_appid = text

rare/models/game.py

@@ -20,7 +20,7 @@
 from rare.shared.image_manager import ImageManager
 from rare.utils import config_helper as config
 from rare.utils.paths import compat_shaders_dir, data_dir, get_rare_executable
-from rare.utils.steam_grades import get_rating
+from rare.utils.steam_grades import SteamGrades
 from rare.utils.workarounds import apply_workarounds
 
 
@@ -496,7 +496,7 @@ def get_steam_grade(self) -> str:
         return self.metadata.steam_grade
 
     def set_steam_grade(self) -> None:
-        appid, grade = get_rating(self.core, self.app_name, self.steam_appid)
+        appid, grade = SteamGrades().get_rating(self.core, self.app_name, self.steam_appid)
         if appid and self.steam_appid is None:
             self.steam_appid = appid
         self.metadata.steam_grade = grade

rare/shared/workers/fetch.py

@@ -7,8 +7,8 @@
 
 from rare.lgndr.core import LegendaryCore
 from rare.models.settings import RareAppSettings, app_settings
-from rare.utils import steam_grades
 from rare.utils.metrics import timelogger
+from rare.utils.steam_grades import SteamGrades
 
 from .worker import Worker
 
@@ -38,8 +38,7 @@ def run_real(self):
             self.signals.progress.emit(0, self.signals.tr("Updating Steam AppIds"))
             with timelogger(self.logger, "Request Steam AppIds"):
                 try:
-                    with timelogger(self.logger, "steam grades load: "):
-                        steam_grades.load_steam_appids()
+                    SteamGrades().load_steam_appids()
                 except Exception as e:
                     self.logger.warning(e)
         self.signals.result.emit((), FetchWorker.Result.STEAMAPPIDS)