add bg3 tool plugins for conveniently invoking quick actions in ui

Author: daescha

__init__.py

@@ -3,10 +3,14 @@
 import glob
 import importlib
 import os
+import pathlib
 import site
 import sys
 import typing
 
+from PyQt6.QtCore import qWarning
+from mobase import IPlugin
+
 from .basic_game import BasicGame
 from .basic_game_ini import BasicIniGame
 
@@ -18,7 +22,7 @@
 
 def createPlugins():
     # List of game class from python:
-    game_plugins: typing.List[BasicGame] = []
+    game_plugins: typing.List[IPlugin] = []
 
     # We are going to list all game plugins:
     curpath = os.path.abspath(os.path.dirname(__file__))
@@ -58,5 +62,21 @@ def createPlugins():
                             "Failed to instantiate {}: {}".format(name, e),
                             file=sys.stderr,
                         )
+    for path in pathlib.Path(escaped_games_path).rglob("plugins/__init__.py"):
+        module_path = "." + os.path.relpath(path.parent, curpath).replace(os.sep, ".")
+        try:
+            module = importlib.import_module(module_path, __package__)
+            if hasattr(module, "createPlugins") and callable(
+                getattr(module, "createPlugins")
+            ):
+                game_plugins.extend(getattr(module, "createPlugins")())
+            if hasattr(module, "createPlugin") and callable(
+                getattr(module, "createPlugin")
+            ):
+                game_plugins.append(getattr(module, "createPlugin")())
+        except ImportError as e:
+            qWarning(f"Error importing module {module_path}: {e}")
+        except Exception as e:
+            qWarning(f"Error calling function createPlugin(s) in {module_path}: {e}")
 
     return game_plugins

games/baldursgate3/bg3_utils.py

@@ -1,12 +1,9 @@
 import functools
-import json
-import os
 import shutil
 import typing
 from pathlib import Path
 
 import mobase
-import yaml
 from PyQt6.QtCore import (
     QCoreApplication,
     QDir,
@@ -59,7 +56,7 @@ def __init__(self, name: str):
         self._name = name
         from . import lslib_retriever, pak_parser
 
-        self._lslib_retriever = lslib_retriever.LSLibRetriever(self)
+        self.lslib_retriever = lslib_retriever.LSLibRetriever(self)
         self._pak_parser = pak_parser.BG3PakParser(self)
 
     def init(self, organizer: mobase.IOrganizer):
@@ -150,7 +147,6 @@ def create_progress_window(
 
     def on_user_interface_initialized(self, window: QMainWindow) -> None:
         self.main_window = window
-        pass
 
     def on_settings_changed(
         self,
@@ -161,24 +157,7 @@ def on_settings_changed(
     ) -> None:
         if self._name != plugin_name:
             return
-        if new and setting == "check_for_lslib_updates":
-            try:
-                self._lslib_retriever.download_lslib_if_missing()
-            finally:
-                self._set_setting(setting, False)
-        elif new and setting == "force_reparse_metadata":
-            try:
-                self.construct_modsettings_xml(
-                    exec_path="bin/bg3", force_reparse_metadata=True
-                )
-            finally:
-                self._set_setting(setting, False)
-        elif new and setting == "convert_jsons_to_yaml":
-            try:
-                self._convert_jsons_to_yaml()
-            finally:
-                self._set_setting(setting, False)
-        elif setting in {
+        if setting in {
             "extract_full_package",
             "autobuild_paks",
             "remove_extracted_metadata",
@@ -197,7 +176,7 @@ def construct_modsettings_xml(
     ) -> bool:
         if (
             "bin/bg3" not in exec_path
-            or not self._lslib_retriever.download_lslib_if_missing()
+            or not self.lslib_retriever.download_lslib_if_missing()
         ):
             return True
         active_mods = self.active_mods()
@@ -257,41 +236,6 @@ def retrieve_mod_metadata_in_new_thread(mod: mobase.IModInterface):
         shutil.copy(self.modsettings_path, self.modsettings_backup)
         return True
 
-    def _convert_jsons_to_yaml(self):
-        qInfo("converting all json files to yaml")
-        active_mods = self.active_mods()
-        progress = self.create_progress_window(
-            "Converting all json files to yaml", len(active_mods) + 1
-        )
-        for mod in active_mods:
-            _convert_jsons_in_dir_to_yaml(Path(mod.absolutePath()))
-            progress.setValue(progress.value() + 1)
-            QApplication.processEvents()
-            if progress.wasCanceled():
-                qWarning("conversion canceled by user")
-                return
-        _convert_jsons_in_dir_to_yaml(self.overwrite_path)
-        progress.setValue(len(active_mods) + 1)
-        QApplication.processEvents()
-        progress.close()
-
     def on_mod_installed(self, mod: mobase.IModInterface) -> None:
-        if self._lslib_retriever.download_lslib_if_missing():
+        if self.lslib_retriever.download_lslib_if_missing():
             self._pak_parser.get_metadata_for_files_in_mod(mod, True)
-
-
-def _convert_jsons_in_dir_to_yaml(path: Path):
-    for file in list(path.rglob("*.json")):
-        converted_path = file.parent / file.name.replace(".json", ".yaml")
-        try:
-            if not converted_path.exists() or os.path.getmtime(file) > os.path.getmtime(
-                converted_path
-            ):
-                with open(file, "r") as json_file:
-                    with open(converted_path, "w") as yaml_file:
-                        yaml.dump(
-                            json.load(json_file), yaml_file, indent=2, sort_keys=False
-                        )
-                qInfo(f"Converted {file} to YAML")
-        except OSError as e:
-            qWarning(f"Error accessing file {converted_path}: {e}")

games/baldursgate3/lslib_retriever.py

@@ -33,10 +33,8 @@ def _needed_lslib_files(self):
             }
         }
 
-    def download_lslib_if_missing(self):
-        if not self._utils.get_setting("check_for_lslib_updates") and all(
-            x.exists() for x in self._needed_lslib_files
-        ):
+    def download_lslib_if_missing(self, force: bool = False) -> bool:
+        if not force and all(x.exists() for x in self._needed_lslib_files):
             return True
         try:
             self._utils.tools_dir.mkdir(exist_ok=True, parents=True)
@@ -110,7 +108,11 @@ def reporthook(block_num: int, block_size: int, total_size: int) -> None:
             qDebug(f"Download failed: {e}")
             err = QMessageBox(self._utils.main_window)
             err.setIcon(QMessageBox.Icon.Critical)
-            err.setText(f"Failed to download LSLib tools:\n{traceback.format_exc()}")
+            err.setText(
+                self._utils.tr(
+                    f"Failed to download LSLib tools:\n{traceback.format_exc()}"
+                )
+            )
             err.exec()
             return False
         try:
@@ -145,7 +147,11 @@ def reporthook(block_num: int, block_size: int, total_size: int) -> None:
             qDebug(f"Extraction failed: {e}")
             err = QMessageBox(self._utils.main_window)
             err.setIcon(QMessageBox.Icon.Critical)
-            err.setText(f"Failed to extract LSLib tools:\n{traceback.format_exc()}")
+            err.setText(
+                self._utils.tr(
+                    f"Failed to extract LSLib tools:\n{traceback.format_exc()}"
+                )
+            )
             err.exec()
             return False
         return True

games/baldursgate3/plugins/__init__.py

@@ -0,0 +1,13 @@
+import mobase
+
+from .check_for_lslib_updates_plugin import BG3ToolCheckForLsLibUpdates
+from .convert_jsons_to_yaml_plugin import BG3ToolConvertJsonsToYaml
+from .reparse_pak_metadata_plugin import BG3ToolReparsePakMetadata
+
+
+def createPlugins() -> list[mobase.IPluginTool]:
+    return [
+        BG3ToolCheckForLsLibUpdates(),
+        BG3ToolReparsePakMetadata(),
+        BG3ToolConvertJsonsToYaml(),
+    ]

games/baldursgate3/plugins/bg3_tool_plugin.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+
+import mobase
+from PyQt6.QtCore import QCoreApplication
+from PyQt6.QtGui import QIcon
+
+
+class BG3ToolPlugin(mobase.IPluginTool):
+    icon_file = desc = sub_name = ""
+
+    def __init__(self):
+        super().__init__()
+        self._pluginName = self._displayName = "BG3 Tools"
+        self._pluginVersion = mobase.VersionInfo(1, 0, 0)
+
+    def init(self, organizer: mobase.IOrganizer) -> bool:
+        self._organizer = organizer
+        return True
+
+    def version(self):
+        return self._pluginVersion
+
+    def author(self):
+        return "daescha"
+
+    def name(self):
+        return f"{self._pluginName}: {self.sub_name}"
+
+    def displayName(self):
+        return f"{self._displayName}/{self.sub_name}"
+
+    def tooltip(self):
+        return self.description()
+
+    def enabledByDefault(self):
+        return self._organizer.managedGame().name() == "Baldur's Gate 3 Plugin"
+
+    def settings(self) -> list[mobase.PluginSetting]:
+        return []
+
+    def display(self):
+        pass
+
+    def icon(self) -> QIcon:
+        return QIcon(str(Path(__file__).parent / "icons" / self.icon_file))
+
+    def description(self) -> str:
+        return QCoreApplication.translate(self._pluginName, self.desc)

games/baldursgate3/plugins/check_for_lslib_updates_plugin.py

@@ -0,0 +1,14 @@
+from .bg3_tool_plugin import BG3ToolPlugin
+
+
+class BG3ToolCheckForLsLibUpdates(BG3ToolPlugin):
+    icon_file = "ui-update.ico"
+    sub_name = "Check For LsLib Updates"
+    desc = "Check to see if there has been a new release of LSLib and create download dialog if so."
+
+    def display(self):
+        from ...game_baldursgate3 import BG3Game
+
+        game_plugin = self._organizer.managedGame()
+        if isinstance(game_plugin, BG3Game):
+            game_plugin.utils.lslib_retriever.download_lslib_if_missing(True)

games/baldursgate3/plugins/convert_jsons_to_yaml_plugin.py

@@ -0,0 +1,57 @@
+import json
+import os
+from pathlib import Path
+
+from PyQt6.QtCore import qWarning, qInfo
+from PyQt6.QtWidgets import QApplication
+
+from .bg3_tool_plugin import BG3ToolPlugin
+
+
+class BG3ToolConvertJsonsToYaml(BG3ToolPlugin):
+    icon_file = "ui-next.ico"
+    sub_name = "Convert JSONS to YAML"
+    desc = "Convert all jsons in active mods to yaml immediately."
+
+    def display(self):
+        from ...game_baldursgate3 import BG3Game
+
+        game_plugin = self._organizer.managedGame()
+        if not isinstance(game_plugin, BG3Game):
+            return
+        utils = game_plugin.utils
+        qInfo("converting all json files to yaml")
+        active_mods = utils.active_mods()
+        progress = utils.create_progress_window(
+            "Converting all json files to yaml", len(active_mods) + 1
+        )
+        for mod in active_mods:
+            _convert_jsons_in_dir_to_yaml(Path(mod.absolutePath()))
+            progress.setValue(progress.value() + 1)
+            QApplication.processEvents()
+            if progress.wasCanceled():
+                qWarning("conversion canceled by user")
+                return
+        _convert_jsons_in_dir_to_yaml(utils.overwrite_path)
+        progress.setValue(len(active_mods) + 1)
+        QApplication.processEvents()
+        progress.close()
+
+
+def _convert_jsons_in_dir_to_yaml(path: Path):
+    import yaml
+
+    for file in list(path.rglob("*.json")):
+        converted_path = file.parent / file.name.replace(".json", ".yaml")
+        try:
+            if not converted_path.exists() or os.path.getmtime(file) > os.path.getmtime(
+                converted_path
+            ):
+                with open(file, "r") as json_file:
+                    with open(converted_path, "w") as yaml_file:
+                        yaml.dump(
+                            json.load(json_file), yaml_file, indent=2, sort_keys=False
+                        )
+                qInfo(f"Converted {file} to YAML")
+        except OSError as e:
+            qWarning(f"Error accessing file {converted_path}: {e}")