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

Author: pre-commit-ci[bot]

games/ff12/Archive/Loader.py

@@ -7,6 +7,7 @@
 
 class ArchiveLoader(QThread):
     """Background thread for loading archive."""
+
     finished = pyqtSignal(object)
     error = pyqtSignal(str)
 

games/ff12/Archive/Model.py

@@ -7,7 +7,7 @@
 
 
 class TreeNode:
-    def __init__(self, name: str, parent = None, is_dir = False, size = 0, entry = None):
+    def __init__(self, name: str, parent=None, is_dir=False, size=0, entry=None):
         self.name = name
         self.parent = parent
         self.is_dir = is_dir
@@ -21,7 +21,7 @@ def __init__(self, name: str, parent = None, is_dir = False, size = 0, entry = N
     def child_count(self) -> int:
         return len(self.children)
 
-    def child(self, row: int) -> 'TreeNode | None':
+    def child(self, row: int) -> "TreeNode | None":
         if 0 <= row < len(self.children):
             return self.children[row]
         return None
@@ -44,31 +44,41 @@ def sort_children(self, column: int, order: Qt.SortOrder):
         """
         dirs = [i for i in self.children if i.is_dir]
         if column == ArchiveColumn.NAME:
-            dirs.sort(key=lambda node: node.name.lower(),
-                    reverse=(order == Qt.SortOrder.DescendingOrder))
+            dirs.sort(
+                key=lambda node: node.name.lower(),
+                reverse=(order == Qt.SortOrder.DescendingOrder),
+            )
 
         files = [i for i in self.children if not i.is_dir]
         if column == ArchiveColumn.NAME:
-            files.sort(key=lambda node: node.name.lower(),
-                    reverse=(order == Qt.SortOrder.DescendingOrder))
+            files.sort(
+                key=lambda node: node.name.lower(),
+                reverse=(order == Qt.SortOrder.DescendingOrder),
+            )
         elif column == ArchiveColumn.TYPE:
-            files.sort(key=lambda node: QFileInfo(node.name).suffix().lower(),
-                    reverse=(order == Qt.SortOrder.DescendingOrder))
+            files.sort(
+                key=lambda node: QFileInfo(node.name).suffix().lower(),
+                reverse=(order == Qt.SortOrder.DescendingOrder),
+            )
         elif column == ArchiveColumn.SIZE:
-            files.sort(key=lambda node: node.size,
-                    reverse=(order == Qt.SortOrder.DescendingOrder))
+            files.sort(
+                key=lambda node: node.size,
+                reverse=(order == Qt.SortOrder.DescendingOrder),
+            )
 
         self.children = dirs + files
         for i in dirs:
             i.sort_children(column, order)
 
+
 class ArchiveColumn(IntEnum):
     NAME = 0
     TYPE = auto()
     SIZE = auto()
 
+
 class ArchiveModel(QAbstractItemModel):
-    def __init__(self, parent = None):
+    def __init__(self, parent=None):
         super().__init__(parent)
         self._reader = None
         self._icon_provider = QFileIconProvider()
@@ -86,10 +96,10 @@ def set_data(self, reader: ArchiveReader):
     def _build_tree(self):
         """Build the tree structure from archive entries."""
         dir_nodes: dict[str, TreeNode] = {"": self._root_node}
-        sorted_entries = sorted(self._reader._entries.items(), key = lambda x: x[0])
+        sorted_entries = sorted(self._reader._entries.items(), key=lambda x: x[0])
 
         for name, entry in sorted_entries:
-            path_parts = name.split('/')
+            path_parts = name.split("/")
             current_path = ""
             current_node = self._root_node
 
@@ -124,7 +134,9 @@ def sort(self, column: int, order: Qt.SortOrder):
             else:
                 old_nodes.append(None)
 
-        self.layoutAboutToBeChanged.emit([], QAbstractItemModel.LayoutChangeHint.VerticalSortHint)
+        self.layoutAboutToBeChanged.emit(
+            [], QAbstractItemModel.LayoutChangeHint.VerticalSortHint
+        )
 
         self._sort_column = column
         self._sort_order = order
@@ -141,7 +153,9 @@ def sort(self, column: int, order: Qt.SortOrder):
         for old_index, new_index in zip(persistent_indexes, new_indexes):
             self.changePersistentIndex(old_index, new_index)
 
-        self.layoutChanged.emit([], QAbstractItemModel.LayoutChangeHint.VerticalSortHint)
+        self.layoutChanged.emit(
+            [], QAbstractItemModel.LayoutChangeHint.VerticalSortHint
+        )
 
     def _find_index_for_node(self, target_node: TreeNode) -> QModelIndex:
         """Find the QModelIndex for a specific TreeNode after sorting"""
@@ -231,8 +245,16 @@ def data(self, index: QModelIndex, role: int = Qt.ItemDataRole.DisplayRole):
 
         return None
 
-    def headerData(self, section: int, orientation: Qt.Orientation, role: int = Qt.ItemDataRole.DisplayRole) -> str | None:
-        if orientation != Qt.Orientation.Horizontal or role != Qt.ItemDataRole.DisplayRole:
+    def headerData(
+        self,
+        section: int,
+        orientation: Qt.Orientation,
+        role: int = Qt.ItemDataRole.DisplayRole,
+    ) -> str | None:
+        if (
+            orientation != Qt.Orientation.Horizontal
+            or role != Qt.ItemDataRole.DisplayRole
+        ):
             return None
 
         match ArchiveColumn(section):
@@ -258,7 +280,7 @@ def _format_file_size(size: int) -> str:
             return f"{size} B"
 
         size_f = float(size)
-        for unit in ['KB', 'MB', 'GB']:
+        for unit in ["KB", "MB", "GB"]:
             size_f /= 1024.0
             if size_f < 1024.0:
                 if size_f < 10:

games/ff12/Archive/Reader.py

@@ -13,6 +13,7 @@ def __init__(self, original_size: int, data_offset: int, block_sizes: List[int])
         self.data_offset = data_offset
         self.block_sizes = block_sizes
 
+
 class ArchiveReader:
     _MAX_BLOCK_SIZE = 64 * 1024
 
@@ -74,15 +75,24 @@ def _load_metadata(self):
                 block_count = self._get_block_count(file_metadata)
                 global_block_sizes = self._read_block_sizes(file, block_count)
 
-                for block_sizes_start_index, original_size, data_offset, filepath_offset in file_metadata:
+                for (
+                    block_sizes_start_index,
+                    original_size,
+                    data_offset,
+                    filepath_offset,
+                ) in file_metadata:
                     name = self._read_null_string_lower(file_path_data, filepath_offset)
 
                     blocks = original_size // self._MAX_BLOCK_SIZE
                     if original_size % self._MAX_BLOCK_SIZE != 0:
                         blocks += 1
 
-                    file_block_sizes = global_block_sizes[block_sizes_start_index:block_sizes_start_index + blocks]
-                    self._entries[name] = ArchiveEntry(original_size, data_offset, file_block_sizes)
+                    file_block_sizes = global_block_sizes[
+                        block_sizes_start_index : block_sizes_start_index + blocks
+                    ]
+                    self._entries[name] = ArchiveEntry(
+                        original_size, data_offset, file_block_sizes
+                    )
 
             except Exception as e:
                 qWarning(f"Failed to load archive metadata: {e}")
@@ -97,8 +107,12 @@ def _read_file_metadata(self, file: BinaryIO, count: int) -> List[tuple]:
             if len(data) < file_struct.size:
                 raise EOFError("Unexpected EOF reading file metadata")
 
-            block_sizes_start_index, _, original_size, data_offset, filepath_offset = file_struct.unpack(data)
-            file_metadata.append((block_sizes_start_index, original_size, data_offset, filepath_offset))
+            block_sizes_start_index, _, original_size, data_offset, filepath_offset = (
+                file_struct.unpack(data)
+            )
+            file_metadata.append(
+                (block_sizes_start_index, original_size, data_offset, filepath_offset)
+            )
 
         return file_metadata
 
@@ -154,10 +168,12 @@ def unpack_file(self, file_path: str, out_path: str):
                 if len(block_data) < block_size:
                     raise EOFError("Unexpected EOF reading data block")
 
-                is_last_block = (block_count == len(entry.block_sizes) - 1)
+                is_last_block = block_count == len(entry.block_sizes) - 1
                 remaining_size = entry.original_size % self._MAX_BLOCK_SIZE
 
-                if (block_size == self._MAX_BLOCK_SIZE or (is_last_block and block_size == remaining_size)):
+                if block_size == self._MAX_BLOCK_SIZE or (
+                    is_last_block and block_size == remaining_size
+                ):
                     out_file.write(block_data)
                 else:
                     decompressed_data = zlib.decompress(block_data)
@@ -172,7 +188,8 @@ def _read_null_string_lower(data: bytes, offset: int) -> str:
         if end == -1:
             end = len(data)
 
-        return data[offset:end].decode("utf-8", errors = "replace").lower()
+        return data[offset:end].decode("utf-8", errors="replace").lower()
+
 
 def get_archives(folder: Path) -> list[Path]:
     """Return a list of all archives in the given folder."""

games/ff12/Archive/View.py

@@ -53,7 +53,9 @@ def _show_context_menu(self, position):
         selected_indexes = self._get_selected_indexes()
         if selected_indexes:
             export_action = QAction("Export", self)
-            export_action.triggered.connect(lambda: self._export_selection(selected_indexes))
+            export_action.triggered.connect(
+                lambda: self._export_selection(selected_indexes)
+            )
             menu.addAction(export_action)
 
         if menu.actions():
@@ -64,7 +66,9 @@ def _export_selection(self, indexes):
             QStandardPaths.StandardLocation.DesktopLocation
         )
 
-        export_dir = QFileDialog.getExistingDirectory(self, "Choose Export Directory", start_dir)
+        export_dir = QFileDialog.getExistingDirectory(
+            self, "Choose Export Directory", start_dir
+        )
         if not export_dir:
             return
 
@@ -76,7 +80,9 @@ def _export_selection(self, indexes):
             QMessageBox.information(self, "Export", "No files to export.")
             return
 
-        progress = QProgressDialog("Exporting files...", "Cancel", 0, len(files_to_export), self)
+        progress = QProgressDialog(
+            "Exporting files...", "Cancel", 0, len(files_to_export), self
+        )
         progress.setWindowModality(Qt.WindowModality.WindowModal)
         progress.show()
 
@@ -95,7 +101,7 @@ def _export_selection(self, indexes):
                 try:
                     relative_path = file_node.path()
                     output_file = export_path / Path(relative_path)
-                    output_file.parent.mkdir(parents = True, exist_ok = True)
+                    output_file.parent.mkdir(parents=True, exist_ok=True)
 
                     reader.unpack_file(relative_path, output_file)
 
@@ -106,17 +112,23 @@ def _export_selection(self, indexes):
         progress.close()
         if failed_files:
             log_path = export_path / "export.log"
-            with open(log_path, "w", encoding = "utf-8") as log_file:
+            with open(log_path, "w", encoding="utf-8") as log_file:
                 log_file.write("\n".join(failed_files))
 
             total_count = len(files_to_export)
             fail_count = len(failed_files)
-            QMessageBox.warning(self, "Export Complete",
-                                f"Only {total_count - fail_count} of {total_count} files were exported successfully.\n"
-                                f"See log for details: {log_path}")
+            QMessageBox.warning(
+                self,
+                "Export Complete",
+                f"Only {total_count - fail_count} of {total_count} files were exported successfully.\n"
+                f"See log for details: {log_path}",
+            )
         else:
-            QMessageBox.information(self, "Export Complete",
-                                    f"Successfully exported {exported_count} file(s) to:\n{export_path}")
+            QMessageBox.information(
+                self,
+                "Export Complete",
+                f"Successfully exported {exported_count} file(s) to:\n{export_path}",
+            )
 
     def _get_selected_indexes(self) -> list[QModelIndex]:
         indexes = self.selectionModel().selectedIndexes()
@@ -130,6 +142,7 @@ def _get_selected_indexes(self) -> list[QModelIndex]:
 
     def _get_selected_files(self, indexes) -> list[TreeNode]:
         files = []
+
         def collect(node):
             if node.is_dir:
                 for child in node.children:

games/ff12/Archive/Widget.py

@@ -31,7 +31,9 @@ def __init__(self, content_path: Path, parent: QWidget | None = None):
         h_layout.addWidget(label)
 
         self._combo_box = QComboBox(self)
-        self._combo_box.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed)
+        self._combo_box.setSizePolicy(
+            QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Fixed
+        )
         h_layout.addWidget(self._combo_box)
         v_layout.addLayout(h_layout)
 
@@ -44,7 +46,7 @@ def _reset_combo_box(self):
         self._combo_box.blockSignals(True)
         self._combo_box.clear()
         for p in sorted(get_archives(self._content_path)):
-            self._combo_box.addItem(p.name, userData = p)
+            self._combo_box.addItem(p.name, userData=p)
         self._combo_box.blockSignals(False)
 
     def _clear_current_content(self):
@@ -98,6 +100,7 @@ def hideEvent(self, event):
         super().hideEvent(event)
         self._clear_current_content()
 
+
 class ArchiveContentWidget(QWidget):
     def __init__(self, parent: QWidget | None = None):
         super().__init__(parent)