[pre-commit.ci] Auto fixes from pre-commit.com hooks.

Author: pre-commit-ci[bot]

games/game_stalker2heartofchornobyl.py

@@ -1,18 +1,21 @@
-from typing import List
+import os
 from enum import IntEnum, auto
-from pathlib import Path
-from PyQt6.QtCore import QDir, QFileInfo
+from typing import List
+
+from PyQt6.QtCore import QDir
 from PyQt6.QtWidgets import QMainWindow, QTabWidget, QWidget
+
 import mobase
-import os
+
+from ..basic_features import BasicLocalSavegames, BasicModDataChecker, GlobPatterns
 from ..basic_game import BasicGame
-from ..basic_features import BasicModDataChecker, GlobPatterns, BasicLocalSavegames
 
 
 class Problems(IntEnum):
     """
     Enums for IPluginDiagnose.
     """
+
     # PAK files placed in incorrect locations
     MISPLACED_PAK_FILES = auto()
     # Missing mod directory structure
@@ -39,7 +42,7 @@ class S2HoCGame(BasicGame, mobase.IPluginFileMapper, mobase.IPluginDiagnose):
     GameIniFiles = [
         "%GAME_DOCUMENTS%/Saved/Config/Windows/Game.ini",
         "%GAME_DOCUMENTS%/Saved/Config/Windows/GameUserSettings.ini",
-        "%GAME_DOCUMENTS%/Saved/Config/Windows/Engine.ini"
+        "%GAME_DOCUMENTS%/Saved/Config/Windows/Engine.ini",
     ]
 
     _main_window: QMainWindow
@@ -64,7 +67,7 @@ def init(self, organizer: mobase.IOrganizer) -> bool:
         self._register_feature(
             BasicLocalSavegames(QDir(self.resolve_path(self.GameSavesDirectory)))
         )
-        
+
         # Create the directory more reliably
         if (
             self._organizer.managedGame()
@@ -80,10 +83,10 @@ def init(self, organizer: mobase.IOrganizer) -> bool:
                     print(f"Warning: Failed to create directory: {mod_path}")
             except Exception as e:
                 print(f"Error creating mod directory: {e}")
-        
+
         # Initialize PAK tab when UI is ready
         organizer.onUserInterfaceInitialized(self.init_tab)
-    
+
         return True
 
     def init_tab(self, main_window: QMainWindow):
@@ -102,6 +105,7 @@ def init_tab(self, main_window: QMainWindow):
 
             # Import here to avoid circular imports
             from .stalker2heartofchornobyl.paks import S2HoCPaksTabWidget
+
             self._paks_tab = S2HoCPaksTabWidget(main_window, self._organizer)
 
             # Insert after the last tab (like Oblivion Remastered)
@@ -110,6 +114,7 @@ def init_tab(self, main_window: QMainWindow):
         except Exception as e:
             print(f"Error initializing PAK tab: {e}")
             import traceback
+
             traceback.print_exc()
 
     def mappings(self) -> List[mobase.Mapping]:
@@ -130,46 +135,48 @@ def mappings(self) -> List[mobase.Mapping]:
 
     def gameDirectory(self) -> QDir:
         return QDir(self._gamePath)
-    
+
     def paksDirectory(self) -> QDir:
         return QDir(self.gameDirectory().absolutePath() + "/Stalker2/Content/Paks")
-    
+
     def paksModsDirectory(self) -> QDir:
         # Use os.path.join for more reliable path construction
         path = os.path.join(self.paksDirectory().absolutePath(), "~mods")
         return QDir(path)
-    
+
     def logicModsDirectory(self) -> QDir:
         # Update path to place LogicMods under Paks
-        return QDir(self.gameDirectory().absolutePath() + "/Stalker2/Content/Paks/LogicMods")
-    
+        return QDir(
+            self.gameDirectory().absolutePath() + "/Stalker2/Content/Paks/LogicMods"
+        )
+
     def binariesDirectory(self) -> QDir:
         return QDir(self.gameDirectory().absolutePath() + "/Stalker2/Binaries/Win64")
-    
+
     def getModMappings(self) -> dict[str, list[str]]:
         return {
             "Content/Paks/~mods": [self.paksModsDirectory().absolutePath()],
         }
-    
+
     def activeProblems(self) -> list[int]:
         problems = set()
         if self._organizer.managedGame() == self:
-            
             # More reliable directory check using os.path
             mod_path = self.paksModsDirectory().absolutePath()
             if not os.path.isdir(mod_path):
                 problems.add(Problems.MISSING_MOD_DIRECTORIES)
                 print(f"Missing mod directory: {mod_path}")
-            
+
             # Check for misplaced PAK files
             for mod in self._organizer.modList().allMods():
                 mod_info = self._organizer.modList().getMod(mod)
                 filetree = mod_info.fileTree()
-                
+
                 # Check for PAK files at the root level (remove LogicMods paths)
                 for entry in filetree:
-                    if entry.name().endswith(('.pak', '.utoc', '.ucas')) and not any(
-                        entry.path().startswith(p) for p in ['Content/Paks/~mods', 'Paks', '~mods']
+                    if entry.name().endswith((".pak", ".utoc", ".ucas")) and not any(
+                        entry.path().startswith(p)
+                        for p in ["Content/Paks/~mods", "Paks", "~mods"]
                     ):
                         problems.add(Problems.MISPLACED_PAK_FILES)
                         break
@@ -228,7 +235,7 @@ def __init__(self, patterns: GlobPatterns = GlobPatterns()):
         move_patterns = {
             "*.pak": "Content/Paks/~mods/",
             "*.utoc": "Content/Paks/~mods/",
-            "*.ucas": "Content/Paks/~mods/"
+            "*.ucas": "Content/Paks/~mods/",
         }
         # Define valid mod roots - remove LogicMods
         valid_roots = ["Content", "Paks", "~mods"]
@@ -238,4 +245,4 @@ def __init__(self, patterns: GlobPatterns = GlobPatterns()):
 
 
 def createPlugin():
-    return S2HoCGame()
+    return S2HoCGame()

games/stalker2heartofchornobyl/__init__.py

@@ -1,8 +1,3 @@
+from .paks import S2HoCPaksModel, S2HoCPaksTabWidget, S2HoCPaksView
 
-from .paks import S2HoCPaksTabWidget, S2HoCPaksModel, S2HoCPaksView
-
-__all__ = [
-    "S2HoCPaksTabWidget", 
-    "S2HoCPaksModel", 
-    "S2HoCPaksView"
-]
+__all__ = ["S2HoCPaksTabWidget", "S2HoCPaksModel", "S2HoCPaksView"]

games/stalker2heartofchornobyl/paks/__init__.py

@@ -1,5 +1,5 @@
 from .model import S2HoCPaksModel
-from .view import S2HoCPaksView  
+from .view import S2HoCPaksView
 from .widget import S2HoCPaksTabWidget
 
-__all__ = ["S2HoCPaksTabWidget", "S2HoCPaksModel", "S2HoCPaksView"]
+__all__ = ["S2HoCPaksTabWidget", "S2HoCPaksModel", "S2HoCPaksView"]

games/stalker2heartofchornobyl/paks/model.py

@@ -250,4 +250,4 @@ def dropMimeData(
                 index -= 1
 
         self.set_paks(new_paks)
-        return False
+        return False

games/stalker2heartofchornobyl/paks/view.py

@@ -30,4 +30,4 @@ def dataChanged(
         self, topLeft: QModelIndex, bottomRight: QModelIndex, roles: Iterable[int] = ()
     ):
         super().dataChanged(topLeft, bottomRight, roles)
-        self.repaint()
+        self.repaint()

games/stalker2heartofchornobyl/paks/widget.py

@@ -1,7 +1,6 @@
-import os
 from functools import cmp_to_key
 from pathlib import Path
-from typing import List, Tuple, cast
+from typing import cast
 
 from PyQt6.QtCore import QDir, QFileInfo
 from PyQt6.QtWidgets import QGridLayout, QWidget
@@ -124,26 +123,32 @@ def _parse_pak_files(self):
         pak_paths: dict[str, tuple[str, str]] = {}
         pak_source: dict[str, str] = {}
         existing_folders: set[int] = set()
-        
+
         print(f"[PAK Debug] Starting scan of {len(mods)} mods")
-        print(f"[PAK Debug] ONLY scanning ~mods directories, EXCLUDING LogicMods")
-        
+        print("[PAK Debug] ONLY scanning ~mods directories, EXCLUDING LogicMods")
+
         # First, scan what numbered folders already exist to avoid double-assignment
         game = self._organizer.managedGame()
         if isinstance(game, S2HoCGame):
             pak_mods_dir = QFileInfo(game.paksModsDirectory().absolutePath())
             if pak_mods_dir.exists() and pak_mods_dir.isDir():
-                print(f"[PAK Debug] Scanning existing folders in: {pak_mods_dir.absoluteFilePath()}")
+                print(
+                    f"[PAK Debug] Scanning existing folders in: {pak_mods_dir.absoluteFilePath()}"
+                )
                 for entry in QDir(pak_mods_dir.absoluteFilePath()).entryInfoList(
                     QDir.Filter.Dirs | QDir.Filter.NoDotAndDotDot
                 ):
                     try:
                         folder_num = int(entry.completeBaseName())
                         existing_folders.add(folder_num)
-                        print(f"[PAK Debug] Found existing numbered folder: {folder_num}")
+                        print(
+                            f"[PAK Debug] Found existing numbered folder: {folder_num}"
+                        )
                     except ValueError:
-                        print(f"[PAK Debug] Skipping non-numbered folder: {entry.completeBaseName()}")
-        
+                        print(
+                            f"[PAK Debug] Skipping non-numbered folder: {entry.completeBaseName()}"
+                        )
+
         # Scan mods for PAK files ONLY in Content/Paks/~mods structure (exclude LogicMods)
         for mod in mods:
             mod_item = self._organizer.modList().getMod(mod)
@@ -152,11 +157,13 @@ def _parse_pak_files(self):
             filetree = mod_item.fileTree()
 
             # If this mod contains a LogicMods directory, skip it entirely for the PAK tab
-            has_logicmods = (
-                filetree.find("Content/Paks/LogicMods") or filetree.find("Paks/LogicMods")
+            has_logicmods = filetree.find("Content/Paks/LogicMods") or filetree.find(
+                "Paks/LogicMods"
             )
             if isinstance(has_logicmods, mobase.IFileTree):
-                print(f"[PAK Debug] Skipping mod '{mod_item.name()}' because it contains a LogicMods directory.")
+                print(
+                    f"[PAK Debug] Skipping mod '{mod_item.name()}' because it contains a LogicMods directory."
+                )
                 continue
 
             # ONLY look for ~mods directories
@@ -172,16 +179,22 @@ def _parse_pak_files(self):
                                 sub_entry.isFile()
                                 and sub_entry.suffix().casefold() == "pak"
                             ):
-                                pak_name = sub_entry.name()[: -1 - len(sub_entry.suffix())]
+                                pak_name = sub_entry.name()[
+                                    : -1 - len(sub_entry.suffix())
+                                ]
                                 paks[pak_name] = entry.name()
                                 pak_paths[pak_name] = (
                                     mod_item.absolutePath()
                                     + "/"
-                                    + cast(mobase.IFileTree, sub_entry.parent()).path("/"),
-                                    mod_item.absolutePath() + "/" + pak_mods.path("/")
+                                    + cast(mobase.IFileTree, sub_entry.parent()).path(
+                                        "/"
+                                    ),
+                                    mod_item.absolutePath() + "/" + pak_mods.path("/"),
                                 )
                                 pak_source[pak_name] = mod_item.name()
-                                print(f"[PAK Debug]   ✅ Added PAK from ~mods numbered folder: {pak_name} in {entry.name()}")
+                                print(
+                                    f"[PAK Debug]   ✅ Added PAK from ~mods numbered folder: {pak_name} in {entry.name()}"
+                                )
                     else:
                         if entry.suffix().casefold() == "pak":
                             pak_name = entry.name()[: -1 - len(entry.suffix())]
@@ -190,36 +203,40 @@ def _parse_pak_files(self):
                                 mod_item.absolutePath()
                                 + "/"
                                 + cast(mobase.IFileTree, entry.parent()).path("/"),
-                                mod_item.absolutePath() + "/" + pak_mods.path("/")
+                                mod_item.absolutePath() + "/" + pak_mods.path("/"),
                             )
                             pak_source[pak_name] = mod_item.name()
-                            print(f"[PAK Debug]   ✅ Added loose PAK from ~mods: {pak_name}")
+                            print(
+                                f"[PAK Debug]   ✅ Added loose PAK from ~mods: {pak_name}"
+                            )
             else:
                 # Check if this mod has LogicMods (for debugging purposes)
                 logic_mods = filetree.find("Content/Paks/LogicMods")
                 if not logic_mods:
                     logic_mods = filetree.find("Paks/LogicMods")
                 if isinstance(logic_mods, mobase.IFileTree):
-                    print(f"[PAK Debug]   Mod {mod_item.name()} has LogicMods (not included in PAK tab)")
+                    print(
+                        f"[PAK Debug]   Mod {mod_item.name()} has LogicMods (not included in PAK tab)"
+                    )
 
         # NOTE: Removed game directory scanning to prevent LogicMods PAKs from appearing
         # We only want PAKs from mod files, not from game directory
-        print(f"[PAK Debug] Skipping game directory scan to prevent LogicMods inclusion")
+        print("[PAK Debug] Skipping game directory scan to prevent LogicMods inclusion")
 
         # Sort PAKs and shake them (preserve order from paks.txt if it exists)
         sorted_paks = dict(sorted(paks.items(), key=cmp_to_key(pak_sort)))
         shaken_paks: list[str] = self._shake_paks(sorted_paks)
-        
+
         # Assign target directories with numbered folders (like Oblivion Remastered)
         # Skip numbers that already exist, use next available number starting from 8999
         final_paks: dict[str, tuple[str, str, str]] = {}
         pak_index = 8999
-        
+
         for pak in shaken_paks:
             # Find next available number (skip existing folders)
             while pak_index in existing_folders:
                 pak_index -= 1
-            
+
             # If PAK is already in a numbered folder, keep its current assignment
             current_folder = paks[pak]
             if current_folder.isdigit():
@@ -232,16 +249,16 @@ def _parse_pak_files(self):
                 existing_folders.add(pak_index)
                 print(f"[PAK Debug] Assigning {pak} to new folder {pak_index}")
                 pak_index -= 1
-            
+
             final_paks[pak] = (pak_source[pak], pak_paths[pak][0], target_dir)
-        
+
         # Convert to model format (4-tuple matching Oblivion Remastered)
         new_data_paks: dict[int, tuple[str, str, str, str]] = {}
         i = 0
         for pak, data in final_paks.items():
             source, current_path, target_path = data
             new_data_paks[i] = (pak, source, current_path, target_path)
             i += 1
-        
+
         print(f"[PAK Debug] Final PAK count: {len(new_data_paks)}")
         self._model.set_paks(new_data_paks)