Reformat Python files

kuba2k2 · kuba2k2 · commit f25d661322cf · 2025-03-25T16:36:05.000+01:00
diff --git a/ltchiptool/soc/amb/system.py b/ltchiptool/soc/amb/system.py
@@ -6,7 +6,7 @@
 from datastruct import DataStruct
 from datastruct.fields import adapter, alignto, bitfield, field
 
-FF_16 = b"\xFF" * 16
+FF_16 = b"\xff" * 16
 
 
 class FlashSpeed(IntEnum):
diff --git a/ltchiptool/soc/ambz/binary.py b/ltchiptool/soc/ambz/binary.py
@@ -24,14 +24,14 @@ def check_xip_binary(
 ) -> Optional[Tuple[int, int, bytes]]:
     if data[0:8] != header:
         return None
-    if data[16:32] != b"\xFF" * 16:
+    if data[16:32] != b"\xff" * 16:
         return None
     length, start = unpack("<II", data[8:16])
     return start, length, data[32:]
 
 
 def check_bootloader_binary(data: bytes) -> Optional[Tuple[int, int, bytes]]:
-    return check_xip_binary(data, header=b"\x99\x99\x96\x96\x3F\xCC\x66\xFC")
+    return check_xip_binary(data, header=b"\x99\x99\x96\x96\x3f\xcc\x66\xfc")
 
 
 class AmebaZBinary(SocInterface, ABC):
diff --git a/ltchiptool/soc/ambz/flash.py b/ltchiptool/soc/ambz/flash.py
@@ -105,7 +105,7 @@ def flash_sw_reset(self) -> None:
         port.baudrate = 115200
         sleep(0.1)
         # try software reset by writing the family ID, preceded by 55AA
-        magic_word = b"\x55\xAA" + self.family.id.to_bytes(length=4, byteorder="big")
+        magic_word = b"\x55\xaa" + self.family.id.to_bytes(length=4, byteorder="big")
         port.write(magic_word)
         sleep(0.5)
         port.baudrate = prev_baudrate
@@ -178,7 +178,7 @@ def flash_get_chip_info(self) -> List[Tuple[str, str]]:
         syscfg2 = letoint(data[256 + 512 + 16 + 8 : 256 + 512 + 16 + 8 + 4])
 
         system_data = data[256 + 512 + 16 + 16 : 256 + 512 + 16 + 16 + 128].ljust(
-            4096, b"\xFF"
+            4096, b"\xff"
         )
         system = SystemData.unpack(system_data)
 
diff --git a/ltchiptool/soc/ambz/util/ambzcode.py b/ltchiptool/soc/ambz/util/ambzcode.py
@@ -204,7 +204,7 @@ def read_efuse_otp(offset: int = 0) -> bytes:
         return (
             b"\x02\x48\x01\x4b"
             b"\x98\x47\x03\xe0"
-            b"\x21\x3C\x00\x00"  # EFUSE_OTP_Read32B()
+            b"\x21\x3c\x00\x00"  # EFUSE_OTP_Read32B()
         ) + inttole32(AMBZ_DATA_ADDRESS + offset)
 
     @staticmethod
diff --git a/ltchiptool/soc/ambz/util/ambztool.py b/ltchiptool/soc/ambz/util/ambztool.py
@@ -108,7 +108,7 @@ def read(self, io: IO[bytes], n: int) -> bytes:
         # increment saved address
         self.address += n
         # add padding to force sending N+4 packet size
-        data = data.ljust(n + 4, b"\xFF")
+        data = data.ljust(n + 4, b"\xff")
         return data
 
 
diff --git a/ltchiptool/soc/ambz/util/rtltool.py b/ltchiptool/soc/ambz/util/rtltool.py
@@ -29,7 +29,7 @@
 CMD_XMD = b"\x07"  # Go xmodem mode (write RAM/Flash mode)
 CMD_EFS = b"\x17"  # Erase Flash Sectors
 CMD_RBF = b"\x19"  # Read Block Flash
-CMD_ABRT = b"\x1B"  # End xmodem mode (write RAM/Flash mode)
+CMD_ABRT = b"\x1b"  # End xmodem mode (write RAM/Flash mode)
 CMD_GFS = b"\x21"  # FLASH Get Status
 CMD_SFS = b"\x26"  # FLASH Set Status
 
@@ -283,7 +283,7 @@ def send_xmodem(self, stream, offset, size, retry=3):
                 if not data:  # end of stream
                     print("send: at EOF")
                     return False
-                data = data.ljust(packet_size, b"\xFF")
+                data = data.ljust(packet_size, b"\xff")
                 pkt = (
                     struct.pack("<BBBI", ord(cmd), sequence, 0xFF - sequence, offset)
                     + data
diff --git a/ltchiptool/soc/ambz2/binary.py b/ltchiptool/soc/ambz2/binary.py
@@ -134,7 +134,7 @@ def elf2bin(self, input: str, ota_idx: int) -> List[FirmwareBinary]:
         nmap_ota1 = self.board.toolchain.nm(input)
 
         # build the partition table
-        ptable = PartitionTable(user_data=b"\xFF" * 256)
+        ptable = PartitionTable(user_data=b"\xff" * 256)
         for region, type in config.ptable.items():
             offset, length, _ = self.board.region(region)
             hash_key = config.keys.hash_keys[region]
@@ -205,11 +205,11 @@ def elf2bin(self, input: str, ota_idx: int) -> List[FirmwareBinary]:
         with output.write() as f:
             f.write(data)
         with out_ptab.write() as f:
-            ptab = data[ptab_offset:ptab_end].rstrip(b"\xFF")
+            ptab = data[ptab_offset:ptab_end].rstrip(b"\xff")
             ptab = pad_data(ptab, 0x20, 0xFF)
             f.write(ptab)
         with out_boot.write() as f:
-            boot = data[boot_offset:boot_end].rstrip(b"\xFF")
+            boot = data[boot_offset:boot_end].rstrip(b"\xff")
             boot = pad_data(boot, 0x20, 0xFF)
             f.write(boot)
         with out_ota1.write() as f:
@@ -230,15 +230,15 @@ def detect_file_type(
             return Detection.make("Realtek AmebaZ2 Flash Image", offset=0)
 
         if (
-            data[0x40:0x44] != b"\xFF\xFF\xFF\xFF"
+            data[0x40:0x44] != b"\xff\xff\xff\xff"
             and data[0x48] == ImageType.BOOT.value
         ):
             return Detection.make("Realtek AmebaZ2 Bootloader", offset=0x4000)
 
         if (
-            data[0xE0:0xE8].strip(b"\xFF")
+            data[0xE0:0xE8].strip(b"\xff")
             and data[0xE8] == ImageType.FWHS_S.value
-            and data[0x1A0:0x1A8].strip(b"\xFF")
+            and data[0x1A0:0x1A8].strip(b"\xff")
             and data[0x1A8] == SectionType.SRAM.value
         ):
             return Detection.make("Realtek AmebaZ2 Firmware", offset=None)
diff --git a/ltchiptool/soc/ambz2/util/models/images.py b/ltchiptool/soc/ambz2/util/models/images.py
@@ -27,7 +27,7 @@
 from .partitions import Bootloader, Firmware, PartitionTable
 from .utils import FF_32
 
-FLASH_CALIBRATION = b"\x99\x99\x96\x96\x3F\xCC\x66\xFC\xC0\x33\xCC\x03\xE5\xDC\x31\x62"
+FLASH_CALIBRATION = b"\x99\x99\x96\x96\x3f\xcc\x66\xfc\xc0\x33\xcc\x03\xe5\xdc\x31\x62"
 
 
 @dataclass
diff --git a/ltchiptool/soc/ambz2/util/models/utils.py b/ltchiptool/soc/ambz2/util/models/utils.py
@@ -4,9 +4,9 @@
 
 from datastruct import Adapter, Context
 
-FF_48 = b"\xFF" * 48
-FF_32 = b"\xFF" * 32
-FF_16 = b"\xFF" * 16
+FF_48 = b"\xff" * 48
+FF_32 = b"\xff" * 32
+FF_16 = b"\xff" * 16
 
 T = TypeVar("T")
 
diff --git a/ltchiptool/soc/bk72xx/binary.py b/ltchiptool/soc/bk72xx/binary.py
@@ -29,7 +29,7 @@ def to_address(offs: int) -> int:
 def check_app_code_crc(data: bytes) -> Union[bool, None]:
     # b #0x40
     # ldr pc, [pc, #0x14]
-    if data[0:8] == b"\x2F\x07\xB5\x94\x35\xFF\x2A\x9B":
+    if data[0:8] == b"\x2f\x07\xb5\x94\x35\xff\x2a\x9b":
         crc = CRC16.CMS.calc(data[0:32])
         crc_found = betoint(data[32:34])
         if crc == crc_found:
@@ -183,13 +183,13 @@ def elf2bin(self, input: str, ota_idx: int) -> List[FirmwareBinary]:
         with out_ug.write() as ug:
             hdr = BytesIO()
             ota_bin = ota_data.getvalue()
-            hdr.write(b"\x55\xAA\x55\xAA")
+            hdr.write(b"\x55\xaa\x55\xaa")
             hdr.write(pad_data(version.encode(), 12, 0x00))
             hdr.write(inttobe32(len(ota_bin)))
             hdr.write(inttobe32(sum(ota_bin)))
             ug.write(hdr.getvalue())
             ug.write(inttobe32(sum(hdr.getvalue())))
-            ug.write(b"\xAA\x55\xAA\x55")
+            ug.write(b"\xaa\x55\xaa\x55")
             ug.write(ota_bin)
 
         # close all files
@@ -218,7 +218,7 @@ def detect_file_type(
             return Detection.make_unsupported("Beken Encrypted App")
 
         # raw firmware binary
-        if data[0:8] == b"\x0E\x00\x00\xEA\x14\xF0\x9F\xE5":
+        if data[0:8] == b"\x0e\x00\x00\xea\x14\xf0\x9f\xe5":
             return Detection.make_unsupported("Raw ARM Binary")
 
         # RBL file for OTA - 'download' partition
diff --git a/ltchiptool/soc/bk72xx/util/binary.py b/ltchiptool/soc/bk72xx/util/binary.py
@@ -44,7 +44,7 @@ def __init__(self, coeffs: Union[bytes, str] = None) -> None:
     def crc(self, data: ByteSource, type: DataType = None) -> DataGenerator:
         for block in geniter(data, 32):
             if len(block) < 32:
-                block += b"\xFF" * (32 - len(block))
+                block += b"\xff" * (32 - len(block))
             crc = CRC16.CMS.calc(block)
             block += inttobe16(crc)
             if type:
@@ -54,7 +54,7 @@ def crc(self, data: ByteSource, type: DataType = None) -> DataGenerator:
 
     def uncrc(self, data: ByteSource, check: bool = True) -> ByteGenerator:
         for block in geniter(data, 34):
-            if check and block != b"\xFF" * 34:
+            if check and block != b"\xff" * 34:
                 crc = CRC16.CMS.calc(block[0:32])
                 crc_found = betoint(block[32:34])
                 if crc != crc_found:
diff --git a/ltchiptool/soc/ln882h/flash.py b/ltchiptool/soc/ln882h/flash.py
@@ -1,14 +1,10 @@
 # Copyright (c) Etienne Le Cousin 2025-01-02.
 
 from abc import ABC
-from binascii import crc32
 from typing import IO, Generator, List, Optional, Tuple, Union
 
 from ltchiptool import SocInterface
 from ltchiptool.util.flash import FlashConnection, FlashFeatures, FlashMemoryType
-from ltchiptool.util.intbin import gen2bytes, inttole32
-from ltchiptool.util.logging import VERBOSE, verbose
-from ltchiptool.util.misc import sizeof
 from ltchiptool.util.streams import ProgressCallback
 from uf2tool import OTAScheme, UploadContext
 
diff --git a/ltchiptool/soc/ln882h/util/ln882htool.py b/ltchiptool/soc/ln882h/util/ln882htool.py
@@ -7,14 +7,9 @@
 from typing import IO, Callable, Generator, Optional
 
 import click
-from hexdump import hexdump, restore
-from serial import Serial
 from ymodem.Socket import ModemSocket
 
 from ltchiptool.util.cli import DevicePortParamType
-from ltchiptool.util.intbin import align_down, biniter, gen2bytes, letoint, pad_data
-from ltchiptool.util.logging import LoggingHandler, verbose
-from ltchiptool.util.misc import retry_catching, retry_generator
 from ltchiptool.util.serialtool import SerialToolBase
 
 _T_YmodemCB = Optional[Callable[[int, str, int, int], None]]
diff --git a/ltchiptool/soc/ln882h/util/models/boot_header.py b/ltchiptool/soc/ln882h/util/models/boot_header.py
@@ -19,7 +19,6 @@
 
 import zlib
 import struct
-from .ln_tools import *
 
 
 class BootHeader:
diff --git a/ltchiptool/util/detection.py b/ltchiptool/util/detection.py
@@ -13,16 +13,16 @@
 
 FILE_TYPES = {
     "UF2": [
-        (0x000, b"UF2\x0A"),
-        (0x004, b"\x57\x51\x5D\x9E"),
-        (0x1FC, b"\x30\x6F\xB1\x0A"),
+        (0x000, b"UF2\x0a"),
+        (0x004, b"\x57\x51\x5d\x9e"),
+        (0x1FC, b"\x30\x6f\xb1\x0a"),
     ],
     "ELF": [
-        (0x00, b"\x7FELF"),
+        (0x00, b"\x7fELF"),
     ],
     "Tuya UG": [
-        (0x00, b"\x55\xAA\x55\xAA"),
-        (0x1C, b"\xAA\x55\xAA\x55"),
+        (0x00, b"\x55\xaa\x55\xaa"),
+        (0x1C, b"\xaa\x55\xaa\x55"),
     ],
 }
 
diff --git a/uf2tool/models/block.py b/uf2tool/models/block.py
@@ -37,7 +37,7 @@ def encode(self) -> bytes:
         self.flags.has_tags = not not self.tags
         self.length = self.data and len(self.data) or 0
         # UF2 magic 1 and 2
-        data = b"\x55\x46\x32\x0A\x57\x51\x5D\x9E"
+        data = b"\x55\x46\x32\x0a\x57\x51\x5d\x9e"
         # encode integer variables
         data += inttole32(self.flags.encode())
         data += inttole32(self.address)
@@ -71,7 +71,7 @@ def encode(self) -> bytes:
                 raise ValueError("Padding too long")
             data += self.padding
         data += b"\x00" * (512 - 4 - len(data))
-        data += b"\x30\x6F\xB1\x0A"  # magic 3
+        data += b"\x30\x6f\xb1\x0a"  # magic 3
         return data
 
     def decode(self, data: bytes):
