Fix all mypy errors

Author: NinjaCheetah

pyproject.toml

@@ -23,7 +23,8 @@ classifiers = [
 ]
 dependencies = [
     "pycryptodome",
-    "requests"
+    "requests",
+    "types-requests"
 ]
 keywords = ["Wii", "wii"]
 

requirements.txt

@@ -1,6 +1,7 @@
 build
 pycryptodome
 requests
+types-requests
 sphinx
 sphinx-book-theme
 myst-parser

src/libWiiPy/archive/ash.py

@@ -8,10 +8,11 @@
 # See <link pending> for details about the ASH compression format.
 
 import io
-from dataclasses import dataclass as _dataclass
+from dataclasses import dataclass
+from typing import List
 
 
-@_dataclass
+@dataclass
 class _ASHBitReader:
     """
     An _ASHBitReader class used to parse individual words in an ASH file. Private class used by the ASH module.
@@ -93,7 +94,7 @@ def _ash_bit_reader_read_bits(bit_reader: _ASHBitReader, num_bits: int):
     return bits
 
 
-def _ash_read_tree(bit_reader: _ASHBitReader, width: int, left_tree: [int], right_tree: [int]):
+def _ash_read_tree(bit_reader: _ASHBitReader, width: int, left_tree: List[int], right_tree: List[int]):
     # Read either the symbol or distance tree from the ASH file, and return the root of that tree.
     work = [0] * (2 * (1 << width))
     work_pos = 0

src/libWiiPy/archive/lz77.py

@@ -5,7 +5,7 @@
 
 import io
 from dataclasses import dataclass as _dataclass
-from typing import List as _List
+from typing import List, Tuple
 
 
 _LZ_MIN_DISTANCE = 0x01   # Minimum distance for each reference.
@@ -21,7 +21,7 @@ class _LZNode:
     weight: int = 0
 
 
-def _compress_compare_bytes(buffer: _List[int], offset1: int, offset2: int, abs_len_max: int) -> int:
+def _compress_compare_bytes(buffer: List[int], offset1: int, offset2: int, abs_len_max: int) -> int:
     # Compare bytes up to the maximum length we can match. Start by comparing the first 3 bytes, since that's the
     # minimum match length and this allows for a more optimized early exit.
     num_matched = 0
@@ -32,7 +32,7 @@ def _compress_compare_bytes(buffer: _List[int], offset1: int, offset2: int, abs_
     return num_matched
 
 
-def _compress_search_matches_optimized(buffer: _List[int], pos: int) -> (int, int):
+def _compress_search_matches_optimized(buffer: List[int], pos: int) -> Tuple[int, int]:
     bytes_left = len(buffer) - pos
     global _LZ_MAX_DISTANCE, _LZ_MIN_LENGTH, _LZ_MAX_LENGTH, _LZ_MIN_DISTANCE
     # Default to only looking back 4096 bytes, unless we've moved fewer than 4096 bytes, in which case we should
@@ -54,7 +54,7 @@ def _compress_search_matches_optimized(buffer: _List[int], pos: int) -> (int, in
     return biggest_match, biggest_match_pos
 
 
-def _compress_search_matches_greedy(buffer: _List[int], pos: int) -> (int, int):
+def _compress_search_matches_greedy(buffer: List[int], pos: int) -> Tuple[int, int]:
     # Finds and returns the first valid match, rather that finding the best one.
     bytes_left = len(buffer) - pos
     global _LZ_MAX_DISTANCE, _LZ_MAX_LENGTH, _LZ_MIN_DISTANCE

src/libWiiPy/archive/u8.py

@@ -68,16 +68,16 @@ def __init__(self):
         self.root_node: _U8Node = _U8Node(0, 0, 0, 0)
         self.imet_header: IMETHeader = IMETHeader()
 
-    def load(self, u8_data: bytes) -> None:
+    def load(self, u8: bytes) -> None:
         """
         Loads raw U8 data into a new U8 object. This allows for extracting the file and updating its contents.
 
         Parameters
         ----------
-        u8_data : bytes
+        u8 : bytes
             The data for the U8 file to load.
         """
-        with io.BytesIO(u8_data) as u8_data:
+        with io.BytesIO(u8) as u8_data:
             # Read the first 4 bytes of the file to ensure that it's a U8 archive.
             u8_data.seek(0x0)
             self.u8_magic = u8_data.read(4)
@@ -126,7 +126,7 @@ def load(self, u8_data: bytes) -> None:
             # Seek back before the root node so that it gets read with all the rest.
             u8_data.seek(u8_data.tell() - 12)
             # Iterate over the number of nodes that the root node lists.
-            for node in range(root_node_size):
+            for _ in range(root_node_size):
                 node_type = int.from_bytes(u8_data.read(1))
                 node_name_offset = int.from_bytes(u8_data.read(3))
                 node_data_offset = int.from_bytes(u8_data.read(4))
@@ -160,7 +160,7 @@ def dump(self) -> bytes:
         # This is 0 because the header size DOES NOT include the initial 32 bytes describing the file.
         header_size = 0
         # Add 12 bytes for each node, since that's how many bytes each one is made up of.
-        for node in range(len(self.u8_node_list)):
+        for _ in range(len(self.u8_node_list)):
             header_size += 12
         # Add the number of bytes used for each file/folder name in the string table.
         for file_name in self.file_name_list:
@@ -170,13 +170,13 @@ def dump(self) -> bytes:
         # Adjust all nodes to place file data in the same order as the nodes. Why isn't it already like this?
         current_data_offset = data_offset
         current_name_offset = 0
-        for node in range(len(self.u8_node_list)):
-            if self.u8_node_list[node].type == 0:
-                self.u8_node_list[node].data_offset = _align_value(current_data_offset, 32)
-                current_data_offset += _align_value(self.u8_node_list[node].size, 32)
+        for idx in range(len(self.u8_node_list)):
+            if self.u8_node_list[idx].type == 0:
+                self.u8_node_list[idx].data_offset = _align_value(current_data_offset, 32)
+                current_data_offset += _align_value(self.u8_node_list[idx].size, 32)
             # Calculate the name offsets, including the extra 1 for the NULL byte at the end of each name.
-            self.u8_node_list[node].name_offset = current_name_offset
-            current_name_offset += len(self.file_name_list[node]) + 1
+            self.u8_node_list[idx].name_offset = current_name_offset
+            current_name_offset += len(self.file_name_list[idx]) + 1
         # Begin joining all the U8 archive data into bytes.
         u8_data = b''
         # Magic number.
@@ -300,7 +300,7 @@ def _pack_u8_dir(u8_archive: U8Archive, current_path, node_count, parent_node):
     return u8_archive, node_count
 
 
-def pack_u8(input_path, generate_imet=False, imet_titles:List[str]=None) -> bytes:
+def pack_u8(input_path, generate_imet=False, imet_titles:List[str] | None = None) -> bytes:
     """
     Packs the provided file or folder into a new U8 archive, and returns the raw file data for it.
 
@@ -513,13 +513,15 @@ def get_channel_names(self, target_languages: int | List[int]) -> str | List[str
                 raise ValueError(f"The specified language is not valid!")
             return self.channel_names[target_languages]
         # If multiple channel names were requested.
-        else:
+        elif type(target_languages) == List:
             channel_names = []
             for lang in target_languages:
                 if lang not in self.LocalizedTitles:
                     raise ValueError(f"The specified language at index {target_languages.index(lang)} is not valid!")
                 channel_names.append(self.channel_names[lang])
             return channel_names
+        else:
+            raise TypeError("Target languages must be type int or List[int]!")
 
     def set_channel_names(self, channel_names: Tuple[int, str] | List[Tuple[int, str]]) -> None:
         """
@@ -544,7 +546,7 @@ def set_channel_names(self, channel_names: Tuple[int, str] | List[Tuple[int, str
                                  f"42 characters!")
             self.channel_names[channel_names[0]] = channel_names[1]
         # If a list of channel names was provided.
-        else:
+        elif type(channel_names) == list:
             for name in channel_names:
                 if name[0] not in self.LocalizedTitles:
                     raise ValueError(f"The target language \"{name[0]}\" for the name at index {channel_names.index(name)} "
@@ -553,3 +555,5 @@ def set_channel_names(self, channel_names: Tuple[int, str] | List[Tuple[int, str
                     raise ValueError(f"The channel name \"{name[1]}\" at index {channel_names.index(name)} is too long! "
                                      f"Channel names cannot exceed 42 characters!")
                 self.channel_names[name[0]] = name[1]
+        else:
+            raise TypeError("Channel names must be type Tuple[int, str] or List[Tuple[int, str]]!")

src/libWiiPy/nand/emunand.py

@@ -7,7 +7,7 @@
 import pathlib
 import shutil
 from dataclasses import dataclass as _dataclass
-from typing import List
+from typing import Callable, List
 from ..title.ticket import Ticket
 from ..title.title import Title
 from ..title.tmd import TMD
@@ -32,7 +32,7 @@ class EmuNAND:
     emunand_root : pathlib.Path
         The path to the EmuNAND root directory.
     """
-    def __init__(self, emunand_root: str | pathlib.Path, callback: callable = None):
+    def __init__(self, emunand_root: str | pathlib.Path, callback: Callable | None = None):
         self.emunand_root = pathlib.Path(emunand_root)
         self.log = callback if callback is not None else None
 

src/libWiiPy/nand/setting.py

@@ -4,6 +4,7 @@
 # See https://wiibrew.org/wiki//title/00000001/00000002/data/setting.txt for information about setting.txt.
 
 import io
+from typing import List
 from ..shared import _pad_bytes
 
 
@@ -53,16 +54,16 @@ def load(self, setting_txt: bytes) -> None:
         """
         with io.BytesIO(setting_txt) as setting_data:
             global _key  # I still don't actually know what *kind* of encryption this is.
-            setting_txt_dec: [int] = []
+            setting_txt_dec: List[int] = []
             for i in range(0, 256):
                 setting_txt_dec.append(int.from_bytes(setting_data.read(1)) ^ (_key & 0xff))
                 _key = (_key << 1) | (_key >> 31)
-        setting_txt_dec = bytes(setting_txt_dec)
+        setting_txt_bytes = bytes(setting_txt_dec)
         try:
-            setting_str = setting_txt_dec.decode('utf-8')
+            setting_str = setting_txt_bytes.decode('utf-8')
         except UnicodeDecodeError:
-            last_newline_pos = setting_txt_dec.rfind(b'\n')  # This makes sure we don't try to decode any garbage data.
-            setting_str = setting_txt_dec[:last_newline_pos + 1].decode('utf-8')
+            last_newline_pos = setting_txt_bytes.rfind(b'\n')  # This makes sure we don't try to decode any garbage data.
+            setting_str = setting_txt_bytes[:last_newline_pos + 1].decode('utf-8')
         self.load_decrypted(setting_str)
 
     def load_decrypted(self, setting_txt: str) -> None:
@@ -104,13 +105,13 @@ def dump(self) -> bytes:
         setting_txt_dec = setting_str.encode()
         global _key
         # This could probably be made more efficient somehow.
-        setting_txt_enc: [int] = []
+        setting_txt_enc: List[int] = []
         with io.BytesIO(setting_txt_dec) as setting_data:
             for i in range(0, len(setting_txt_dec)):
                 setting_txt_enc.append(int.from_bytes(setting_data.read(1)) ^ (_key & 0xff))
                 _key = (_key << 1) | (_key >> 31)
-        setting_txt_enc = _pad_bytes(bytes(setting_txt_enc), 256)
-        return setting_txt_enc
+        setting_txt_bytes = _pad_bytes(bytes(setting_txt_enc), 256)
+        return setting_txt_bytes
 
     def dump_decrypted(self) -> str:
         """

src/libWiiPy/nand/sys.py

@@ -91,11 +91,8 @@ def add(self, title_id: str | bytes) -> int:
             The UID assigned to the new Title ID.
         """
         if type(title_id) is bytes:
-            # This catches the format b'0000000100000002'
-            if len(title_id) == 16:
-                title_id_converted = title_id.encode()
             # This catches the format b'\x00\x00\x00\x01\x00\x00\x00\x02'
-            elif len(title_id) == 8:
+            if len(title_id) == 8:
                 title_id_converted = binascii.hexlify(title_id).decode()
             # If it isn't one of those lengths, it cannot possibly be valid, so reject it.
             else:

src/libWiiPy/py.typed

@@ -61,10 +61,10 @@ class Certificate:
         The exponent of this certificate's public key. Combined with the modulus to get the full key.
     """
     def __init__(self):
-        self.type: CertificateType | None = None
+        self.type: CertificateType = CertificateType.RSA_4096
         self.signature: bytes = b''
         self.issuer: str = ""
-        self.pub_key_type: CertificateKeyType | None = None
+        self.pub_key_type: CertificateKeyType  = CertificateKeyType.RSA_4096
         self.child_name: str = ""
         self.pub_key_id: int = 0
         self.pub_key_modulus: int = 0