Fix type issues (pyright)

Author: ffgriever-pl

games/ff12/Archive/Model.py

@@ -1,4 +1,5 @@
 from enum import IntEnum, auto
+from typing import Any, cast
 
 from PyQt6.QtCore import QAbstractItemModel, QFileInfo, QModelIndex, Qt
 from PyQt6.QtWidgets import QFileIconProvider
@@ -7,15 +8,22 @@
 
 
 class TreeNode:
-    def __init__(self, name: str, parent=None, is_dir=False, size=0, entry=None):
+    def __init__(
+        self,
+        name: str,
+        parent: "TreeNode | None" = None,
+        is_dir: bool = False,
+        size: int = 0,
+        entry: Any | None = None,
+    ):
         self.name = name
         self.parent = parent
         self.is_dir = is_dir
         self.size = size
-        self.children = []
+        self.children: list[TreeNode] = []
         self.entry = entry
 
-        if parent:
+        if parent is not None:
             parent.children.append(self)
 
     def child_count(self) -> int:
@@ -37,19 +45,19 @@ def path(self) -> str:
             return self.parent.path() + "/" + self.name
         return self.name
 
-    def sort_children(self, column: int, order: Qt.SortOrder):
+    def sort_children(self, column: int, order: Qt.SortOrder) -> None:
         """Sort children by the specified column and order.
         Directories always come before files.
         Directories only reorder when column == NAME.
         """
-        dirs = [i for i in self.children if i.is_dir]
+        dirs: list[TreeNode] = [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),
             )
 
-        files = [i for i in self.children if not i.is_dir]
+        files: list[TreeNode] = [i for i in self.children if not i.is_dir]
         if column == ArchiveColumn.NAME:
             files.sort(
                 key=lambda node: node.name.lower(),
@@ -78,25 +86,28 @@ class ArchiveColumn(IntEnum):
 
 
 class ArchiveModel(QAbstractItemModel):
-    def __init__(self, parent=None):
+    def __init__(self, parent: Any | None = None):
         super().__init__(parent)
-        self._reader = None
+        self._reader: ArchiveReader | None = None
         self._icon_provider = QFileIconProvider()
         self._root_node = TreeNode("", None, True)
         self._sort_column = ArchiveColumn.NAME
         self._sort_order = Qt.SortOrder.AscendingOrder
 
-    def set_data(self, reader: ArchiveReader):
+    def set_data(self, reader: ArchiveReader) -> None:
         self.beginResetModel()
         self._reader = reader
         self._build_tree()
         self._sort_tree()
         self.endResetModel()
 
-    def _build_tree(self):
+    def _build_tree(self) -> None:
         """Build the tree structure from archive entries."""
+        if self._reader is None:
+            return
+
         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])  # pyright: ignore[reportPrivateUsage]
 
         for name, entry in sorted_entries:
             path_parts = name.split("/")
@@ -119,18 +130,22 @@ def _build_tree(self):
             filename = path_parts[-1]
             TreeNode(filename, current_node, False, entry.original_size, entry)
 
-    def _sort_tree(self):
+    def _sort_tree(self) -> None:
         """Sort the entire tree."""
         self._root_node.sort_children(self._sort_column, self._sort_order)
 
-    def sort(self, column: int, order: Qt.SortOrder):
+    def sort(
+        self,
+        column: int,
+        order: Qt.SortOrder = Qt.SortOrder.AscendingOrder,
+    ) -> None:
         """Implement sorting with proper persistent index handling"""
         persistent_indexes = self.persistentIndexList()
 
-        old_nodes = []
+        old_nodes: list[TreeNode | None] = []
         for index in persistent_indexes:
             if index.isValid():
-                old_nodes.append(index.internalPointer())
+                old_nodes.append(cast(TreeNode, index.internalPointer()))
             else:
                 old_nodes.append(None)
 
@@ -142,7 +157,7 @@ def sort(self, column: int, order: Qt.SortOrder):
         self._sort_order = order
         self._sort_tree()
 
-        new_indexes = []
+        new_indexes: list[QModelIndex] = []
         for node in old_nodes:
             if node is not None:
                 new_index = self._find_index_for_node(node)
@@ -162,9 +177,9 @@ def _find_index_for_node(self, target_node: TreeNode) -> QModelIndex:
         if target_node == self._root_node:
             return QModelIndex()
 
-        path = []
-        current = target_node
-        while current and current != self._root_node:
+        path: list[TreeNode] = []
+        current: TreeNode | None = target_node
+        while current is not None and current != self._root_node:
             path.append(current)
             current = current.parent
 
@@ -176,49 +191,54 @@ def _find_index_for_node(self, target_node: TreeNode) -> QModelIndex:
 
         return current_index
 
-    def rowCount(self, parent: QModelIndex) -> int:
+    def rowCount(self, parent: QModelIndex = QModelIndex()) -> int:
         if not parent.isValid():
             parent_node = self._root_node
         else:
-            parent_node = parent.internalPointer()
+            parent_node = cast(TreeNode, parent.internalPointer())
 
         return parent_node.child_count()
 
-    def columnCount(self, parent: QModelIndex) -> int:
+    def columnCount(self, parent: QModelIndex = QModelIndex()) -> int:
+        _ = parent
         return len(ArchiveColumn)
 
-    def index(self, row: int, column: int, parent: QModelIndex) -> QModelIndex:
+    def index(
+        self, row: int, column: int, parent: QModelIndex = QModelIndex()
+    ) -> QModelIndex:
         if not self.hasIndex(row, column, parent):
             return QModelIndex()
 
         if not parent.isValid():
             parent_node = self._root_node
         else:
-            parent_node = parent.internalPointer()
+            parent_node = cast(TreeNode, parent.internalPointer())
 
         child_node = parent_node.child(row)
         if child_node:
             return self.createIndex(row, column, child_node)
 
         return QModelIndex()
 
-    def parent(self, index: QModelIndex) -> QModelIndex:
-        if not index.isValid():
+    def parent(self, child: QModelIndex) -> QModelIndex:  # pyright: ignore[reportIncompatibleMethodOverride]
+        if not child.isValid():
             return QModelIndex()
 
-        child_node = index.internalPointer()
+        child_node = cast(TreeNode, child.internalPointer())
         parent_node = child_node.parent
 
         if parent_node == self._root_node or parent_node is None:
             return QModelIndex()
 
         return self.createIndex(parent_node.row(), 0, parent_node)
 
-    def data(self, index: QModelIndex, role: int = Qt.ItemDataRole.DisplayRole):
+    def data(
+        self, index: QModelIndex, role: int = Qt.ItemDataRole.DisplayRole
+    ) -> Any | None:
         if not index.isValid():
             return None
 
-        node = index.internalPointer()
+        node = cast(TreeNode, index.internalPointer())
         column = index.column()
 
         if role == Qt.ItemDataRole.DisplayRole:
@@ -270,7 +290,7 @@ def headerData(
     def get_node(self, index: QModelIndex) -> TreeNode | None:
         """Get the TreeNode for a given index."""
         if index.isValid():
-            return index.internalPointer()
+            return cast(TreeNode, index.internalPointer())
         return None
 
     @staticmethod

games/ff12/Archive/Reader.py

@@ -2,13 +2,14 @@
 import struct
 import zlib
 from pathlib import Path
-from typing import BinaryIO, Dict, List
+from types import TracebackType
+from typing import BinaryIO
 
 from PyQt6.QtCore import qWarning
 
 
 class ArchiveEntry:
-    def __init__(self, original_size: int, data_offset: int, block_sizes: List[int]):
+    def __init__(self, original_size: int, data_offset: int, block_sizes: list[int]):
         self.original_size = original_size
         self.data_offset = data_offset
         self.block_sizes = block_sizes
@@ -19,7 +20,7 @@ class ArchiveReader:
 
     def __init__(self, path: Path):
         self._filename = path
-        self._entries: Dict[str, ArchiveEntry] = {}
+        self._entries: dict[str, ArchiveEntry] = {}
         self._file_handle: BinaryIO | None = None
 
         self._load_metadata()
@@ -50,20 +51,27 @@ def __enter__(self):
         self.open()
         return self
 
-    def __exit__(self, exc_type, exc_val, exc_tb):
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc_val: BaseException | None,
+        exc_tb: TracebackType | None,
+    ) -> None:
         """Enable 'with' statement to automatically open and close the file handle."""
         self.close()
 
     def _load_metadata(self):
         """Load the archive metadata"""
-        with self as file:
-            file = file._file_handle
+        with self:
+            file = self._file_handle
+            if file is None:
+                return
             try:
                 header_data = file.read(16)
                 if len(header_data) < 16:
                     raise EOFError("File too short for header")
 
-                magic, header_size, file_count = struct.unpack("<IIQ", header_data)
+                magic, _header_size, file_count = struct.unpack("<IIQ", header_data)
                 if magic != 0x4B595253:
                     raise ValueError("Invalid archive format")
 
@@ -97,10 +105,12 @@ def _load_metadata(self):
             except Exception as e:
                 qWarning(f"Failed to load archive metadata: {e}")
 
-    def _read_file_metadata(self, file: BinaryIO, count: int) -> List[tuple]:
+    def _read_file_metadata(
+        self, file: BinaryIO, count: int
+    ) -> list[tuple[int, int, int, int]]:
         """Read metadata for file entries"""
         file_struct = struct.Struct("<IIQQQ")
-        file_metadata = []
+        file_metadata: list[tuple[int, int, int, int]] = []
 
         for _ in range(count):
             data = file.read(file_struct.size)
@@ -129,7 +139,7 @@ def _read_file_path_data(self, file: BinaryIO) -> bytes:
 
         return path_data
 
-    def _get_block_count(self, file_metadata: List[tuple]) -> int:
+    def _get_block_count(self, file_metadata: list[tuple[int, int, int, int]]) -> int:
         """Calculate total number of blocks across all files"""
         count = 0
         for _, original_size, _, _ in file_metadata:
@@ -139,15 +149,15 @@ def _get_block_count(self, file_metadata: List[tuple]) -> int:
             count += blocks
         return count
 
-    def _read_block_sizes(self, file: BinaryIO, count: int) -> List[int]:
+    def _read_block_sizes(self, file: BinaryIO, count: int) -> list[int]:
         """Read block sizes for all files"""
         data = file.read(count * 2)
         if len(data) < count * 2:
             raise ValueError("Unexpected EOF reading block sizes")
 
         return list(struct.unpack(f"<{count}H", data))
 
-    def unpack_file(self, file_path: str, out_path: str):
+    def unpack_file(self, file_path: str, out_path: str | Path):
         """Unpack a file from the archive"""
         if self._file_handle is None:
             raise ValueError("Archive file handle is not open")