Many clarity updates

 - Fix required version in readme (>=3.6 for fstrings)
 - Simplify isobuster hexdump function
 - Fix SHA256 in sample
 - Remove stupid hack suggestion in readme
 - Add some comments
 - Misc minor code changes

Author: Altomare

README.md

@@ -9,12 +9,12 @@ Given an ISO file, it will generate a pre-filled Redump submission, containing:
 - ISO PVD Hexdump
 - SFO information
 
-`sfo_info.py` can be used by itself as a standalone sfo_info.exe replacement that works on Linux too.
+`sfo_info.py` can be used by itself as a standalone sfo_info.exe replacement.
 
 
 # Requirements
 
-- Python 3 (>= 3.4)
+- Python 3 (>= 3.6)
 - pycdlib
 
 Windows exe builds are available in the release tab.
@@ -57,7 +57,7 @@ HashCalc Info:
 MD5:    dd60041bfb6d677fdaacd2cf9cb6d84a
 SHA1:   88a19042041ff368b9cb887432cb5255c654c33c
 CRC32:  83adb164
-SHA256: 7a9a04d89c1867b7f0ce4e9358b78ff52ec0a6612dc3a15511a3aaa5b1ef9cb4 
+SHA256: c824f63de2f8bf779e73cad524cd3619fc852d8d669fc00f97f110acecb3015d
 [/code]
 
 Primary Volume Descriptor (PVD)
@@ -106,16 +106,7 @@ UPDATER_VER: 1.50
 [/code]
 ```
 
-# Using it in other scripts
-
-Since this is just scripts and was not made like a module, some modifications are needed if you want to import the Python code in some bigger project.
-The easiest (and quite ugly) solution is to add a `__init__.py` file, containing:
-```Python
-import sys
-import os
-sys.path.append(os.path.join(os.path.dirname(__file__), ".", "."))
-```
-This adds the whole directory to the path, so beware.
+# Automating it
 
 Below is a simple script I've made that auto-generates submissions for every ISO in the given directory.
 Make sure it only contains PSP ISOs.
@@ -138,7 +129,8 @@ for root, dirs, files in os.walk(args.dir):
         if iso_name + '.nfo' in files:
             continue
 
+        print(f"Generating submission for {name}...")
         gen_psp_redump(os.path.join(root, iso_name + '.iso'),
                        os.path.join(root, iso_name + '.nfo'))
-        print(f"Generated submission for {name}")
+        print("Done.")
 ```

redump_psp.py

@@ -9,24 +9,23 @@
 
 
 def hexdump(data, offset, size):
+    """Return hexdump string of given data in isobuster format."""
+    def ascii_print(c):
+        return chr(c) if 32 <= c <= 127 else "."
+
     dump = ""
-    line_nb = size // 0x10
-    for i in range(line_nb):
-        line = f"{offset + i * 16:04x} : "
-        for j in range(0x10):
-            line += f"{data[offset + i * 16 + j]:02X}"
-            line += "  " if j == 0x7 else " "
-        line += "  "
-        r_line = data[offset + i * 0x10: offset + i * 0x10 + 0x10]
-        line += "".join([chr(b) if 0x20 <= b <= 0x7F else "." for b in r_line])
-        dump += line
-        if i < line_nb - 1:
-            dump += "\n"
+    for i in range(size // 0x10):
+        line_offset = offset + i * 0x10
+        line_data = data[line_offset: line_offset + 0x10]
+
+        line_format = "{:04X} :" + " {:02X}" * 8 + " " + " {:02X}" * 8
+        dump += line_format.format(line_offset, *line_data)
+        dump += "   " + "".join([ascii_print(b) for b in line_data]) + "\n"
     return dump
 
 
 def gen_hashes(filestream):
-    def read_in_chunks(file_object, chunk_size=1024):
+    def read_in_chunks(file_object, chunk_size):
         while True:
             data = file_object.read(chunk_size)
             if not data:
@@ -47,14 +46,16 @@ def read_in_chunks(file_object, chunk_size=1024):
     return (format(prev_crc32 & 0xFFFFFFFF, 'x').zfill(8),
             sha1.hexdigest().zfill(40),
             md5.hexdigest().zfill(32),
-            sha256.hexdigest())
+            sha256.hexdigest().zfill(64))
 
 
 def get_pvd_dump(filestream):
+    # Locate PVD sector, starting from sector 0x10
+    # See: https://wiki.osdev.org/ISO_9660#Volume_Descriptors
     filestream.seek(0x8000)
     raw_sector = filestream.read(0x800)
     while raw_sector[0] != 0xFF:
-        if raw_sector[6] == 0x1:
+        if raw_sector[0] == 0x01:
             return hexdump(raw_sector, 0x320, 0x60)
         raw_sector = filestream.read(0x800)
     raise Exception("Could not find PVD")
@@ -75,7 +76,7 @@ def gen_psp_redump(iso, out):
     dump = TEMPLATE.format(
         size_mb=size_mb, size_b=size_b,
         md5=hashes[2], sha1=hashes[1], crc32=hashes[0], sha256=hashes[3],
-        pvd_hexdump=pvd_dump, sfo_info=sfo_info)
+        pvd_hexdump=pvd_dump.strip('\n'), sfo_info=sfo_info)
     if out:
         with open(out, 'w', encoding='utf8') as f:
             f.write(dump)

sfo_info.py

@@ -12,16 +12,6 @@ class SFODataFormat(IntEnum):
     INT32 = 0x0404
 
 
-class SFOHeader:
-    def __init__(self, raw):
-        # Check magic
-        assert(raw[:0x4] == b"\x00PSF")
-        version_minor = struct.unpack("<I", raw[0x5:0x8] + b"\x00")[0]
-        self.version = f"{raw[0x04]}.{version_minor}"
-        self.key_table_start, self.data_table_start, self.table_entries = \
-            struct.unpack('<III', raw[0x08:0x14])
-
-
 class SFOIndexTableEntry:
     def __init__(self, raw, offset):
         fields = struct.unpack('<HHIII', raw[offset: offset + 0x10])
@@ -34,20 +24,28 @@ def __init__(self, raw, offset):
 
 class SFO:
     def __init__(self, raw_sfo):
-        self.header = SFOHeader(raw_sfo)
+        # Read header
+        assert(raw_sfo[:0x4] == b"\x00PSF")
+        version_minor = struct.unpack("<I", raw_sfo[0x5:0x8] + b"\x00")[0]
+        self.version = f"{raw_sfo[0x04]}.{version_minor}"
+        self.key_table_start, self.data_table_start, self.table_entries = \
+            struct.unpack('<III', raw_sfo[0x08:0x14])
 
+        # Read index table entries
         self.idx_table = []
-        for idx in range(self.header.table_entries):
+        for idx in range(self.table_entries):
             self.idx_table.append(
                 SFOIndexTableEntry(raw_sfo, 0x14 + idx * 0x10))
 
+        # Read data entries
         self.data = {}
         for i in range(len(self.idx_table)):
             self._read_entry(raw_sfo, i)
 
     def _read_entry(self, raw_sfo, idx):
-        key_table_start = self.header.key_table_start
-        data_table_start = self.header.data_table_start
+        # Offsets
+        key_table_start = self.key_table_start
+        data_table_start = self.data_table_start
         entry = self.idx_table[idx]
 
         # Read key from key table
@@ -69,8 +67,7 @@ def _read_entry(self, raw_sfo, idx):
         self.data[key] = data
 
     def dump(self):
-        dump = ""
-        dump += f"SFO Version: {self.header.version}\n"
+        dump = f"SFO Version: {self.version}\n"
         for key in self.data.keys():
             dump += f"{key}: {self.data[key]}\n"
         return dump
@@ -96,7 +93,7 @@ def get_sfo_info(path):
     iso.close()
 
     if out:
-        out = out[:-2]
+        out = out[:-2]  # Strip trailing backlines
     return out