ipodsync 0.1.7__tar.gz → 0.1.8__tar.gz

{ipodsync-0.1.7 → ipodsync-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipodsync
-Version: 0.1.7
+Version: 0.1.8
 Summary: Upload music to an iPod nano 6G/7G without iTunes: SQLite library, hashAB signing, cover art (pure-Python).
 Project-URL: Homepage, https://github.com/buldiei/ipodsync
 Project-URL: Repository, https://github.com/buldiei/ipodsync

{ipodsync-0.1.7 → ipodsync-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ipodsync"
-version = "0.1.7"
+version = "0.1.8"
 description = "Upload music to an iPod nano 6G/7G without iTunes: SQLite library, hashAB signing, cover art (pure-Python)."
 readme = "README.md"
 requires-python = ">=3.9"

{ipodsync-0.1.7 → ipodsync-0.1.8}/src/ipodsync/__init__.py

@@ -13,7 +13,7 @@ from .library import ItlpLibrary
 from .models import Track
 from .transport import IPod, IPodNotFound, find_ipod
 
-__version__ = "0.1.7"
+__version__ = "0.1.8"
 
 __all__ = [
     "find_ipod",

{ipodsync-0.1.7 → ipodsync-0.1.8}/src/ipodsync/artwork_writer.py

@@ -243,6 +243,79 @@ def attach_cover(artwork_dir: str | Path, song_id: int, cover_bytes: bytes) -> i
     return image_id
 
 
+# --- removing artwork / compacting the .ithmb files -----------------------------
+def _offset_field_positions() -> dict[int, int]:
+    """Byte position of each format's ithmb_offset field inside a 928-byte mhii,
+    derived from the atom templates (mirrors _build_mhii's layout)."""
+    pos = len(MHII_HEADER)
+    out: dict[int, int] = {}
+    for fid in FORMAT_IDS:
+        pos += len(MHOD_CONTAINER)
+        out[fid] = pos + 20          # ithmb_offset lives at byte 20 of the mhni
+        pos += len(MHNI[fid]) + len(STRMHOD[fid])
+    return out
+
+
+_OFFSET_POS = _offset_field_positions()
+_SLOT = {fid: slot for fid, _w, _h, slot in FORMATS}
+
+
+def compact(artwork_dir: str | Path, keep_song_ids) -> dict:
+    """Drop artwork for tracks not in `keep_song_ids` and repack the .ithmb files,
+    reclaiming the freed frames. `keep_song_ids` are (signed or unsigned) pids.
+
+    Surviving frames are copied verbatim to freshly-written .ithmb files and each
+    mhii's offsets are patched to the new positions; this preserves iTunes-made and
+    ipodsync-made covers alike. `Locations.itdb` is untouched, so no cbk re-sign.
+    Returns {'kept': n, 'removed': n} (no-op if there's no ArtworkDB).
+    """
+    artwork_dir = Path(artwork_dir)
+    db_path = artwork_dir / "ArtworkDB"
+    if not db_path.exists():
+        return {"kept": 0, "removed": 0}
+    keep = {int(s) % U64 for s in keep_song_ids}
+    db = ArtworkDB.load(db_path)
+
+    old = {}
+    for fid in FORMAT_IDS:
+        p = artwork_dir / f"F{fid}_1.ithmb"
+        old[fid] = p.read_bytes() if p.exists() else b""
+    new_frames = {fid: bytearray() for fid in FORMAT_IDS}
+
+    new_blocks: list[bytes] = []
+    removed = 0
+    for m in db.mhii_blocks:
+        sid = struct.unpack_from("<Q", m, 20)[0]
+        if sid not in keep:
+            removed += 1
+            continue
+        mb = bytearray(m)
+        for fid in FORMAT_IDS:
+            slot = _SLOT[fid]
+            off = struct.unpack_from("<i", mb, _OFFSET_POS[fid])[0]
+            frame = old[fid][off:off + slot]
+            if len(frame) < slot:                       # keep every frame slot-sized
+                frame = frame + b"\x00" * (slot - len(frame))
+            struct.pack_into("<i", mb, _OFFSET_POS[fid], len(new_frames[fid]))
+            new_frames[fid] += frame
+        new_blocks.append(bytes(mb))
+
+    if removed == 0:
+        return {"kept": len(new_blocks), "removed": 0}
+
+    db.mhii_blocks = new_blocks
+    db.song_ids = {struct.unpack_from("<Q", b, 20)[0] for b in new_blocks}
+    for fid in FORMAT_IDS:
+        p = artwork_dir / f"F{fid}_1.ithmb"
+        tmp = p.with_suffix(".tmp")
+        tmp.write_bytes(bytes(new_frames[fid]))
+        tmp.replace(p)
+    tmp = db_path.with_suffix(".tmp")
+    tmp.write_bytes(db.serialize())
+    tmp.replace(db_path)
+    return {"kept": len(new_blocks), "removed": removed}
+
+
 # --- extracting the embedded cover from audio -----------------------------------
 def extract_embedded_cover(audio_path: str | Path) -> bytes | None:
     """Extract the embedded cover bytes from MP3 (APIC) or M4A (covr)."""

{ipodsync-0.1.7 → ipodsync-0.1.8}/src/ipodsync/cli.py

@@ -71,18 +71,30 @@ def cmd_export(ipod, args):
 
 
 def cmd_rm(ipod, args):
+    from ipodsync.artwork_writer import compact
+
     itlp = ipod.itunes_dir / "iTunes Library.itlp"
     stamp = datetime.now().strftime("%Y%m%d-%H%M%S")
     backup = _backup_library(itlp, stamp) if args.backup else None
+    if args.backup:
+        _backup_artwork(ipod, stamp)
 
     guid = read_firewire_guid(ipod.sysinfo_extended, ipod.sysinfo, mount=ipod.root)
     lib = ItlpLibrary(itlp)
     music = ipod.music_dir if args.delete_file else None
-    loc = lib.remove_track(args.pid, music_dir=music)
+    lib.remove_track(args.pid, music_dir=music)
     lib.resign(guid)
+    live = {t["pid"] for t in lib.list_tracks()}   # remaining tracks, after removal
     lib.close()
+
+    # drop the removed track's thumbnails from ArtworkDB + repack the .ithmb files
+    stats = compact(ipod.control / "Artwork", live)
+
     print(f"✓ Removed track pid {args.pid}"
           f"{' (+ deleted the file)' if args.delete_file else ''}. Eject the iPod.")
+    if stats["removed"]:
+        print(f"  Reclaimed cover art for {stats['removed']} track"
+              f"{'s' if stats['removed'] != 1 else ''}.")
     if backup:
         print(f"  Undo: rm -rf '{itlp}' && cp -r '{backup}' '{itlp}'")
 

ipodsync-0.1.8/tests/test_artwork_compact.py

@@ -0,0 +1,60 @@
+"""compact() must drop the removed track's mhii + thumbnails and repack the
+.ithmb files, while keeping surviving covers byte-for-byte."""
+import io
+import struct
+
+from ipodsync.artwork_writer import (FORMAT_IDS, U64, ArtworkDB, _OFFSET_POS, _SLOT,
+                                     attach_cover, compact, encode_cover)
+
+
+def _solid_png(color):
+    from PIL import Image
+    b = io.BytesIO()
+    Image.new("RGB", (16, 16), color).save(b, "PNG")
+    return b.getvalue()
+
+
+def _frame_at(artwork_dir, fid, mhii_bytes):
+    off = struct.unpack_from("<i", mhii_bytes, _OFFSET_POS[fid])[0]
+    data = (artwork_dir / f"F{fid}_1.ithmb").read_bytes()
+    return data[off:off + _SLOT[fid]]
+
+
+def test_compact_drops_removed_keeps_survivors(tmp_path):
+    covers = {1001: _solid_png((200, 20, 20)),
+              1002: _solid_png((20, 200, 20)),
+              1003: _solid_png((20, 20, 200))}
+    for sid, png in covers.items():
+        assert attach_cover(tmp_path, sid, png) is not None
+
+    for fid in FORMAT_IDS:                       # 3 frames each before compaction
+        assert (tmp_path / f"F{fid}_1.ithmb").stat().st_size == 3 * _SLOT[fid]
+
+    stats = compact(tmp_path, {1001, 1003})      # drop 1002
+    assert stats == {"kept": 2, "removed": 1}
+
+    for fid in FORMAT_IDS:                        # 2 frames each after
+        assert (tmp_path / f"F{fid}_1.ithmb").stat().st_size == 2 * _SLOT[fid]
+
+    db = ArtworkDB.load(tmp_path / "ArtworkDB")
+    got = {struct.unpack_from("<Q", m, 20)[0]: m for m in db.mhii_blocks}
+    assert set(got) == {1001, 1003}              # 1002 gone from the DB
+
+    # survivors' frames still equal the freshly-encoded slots (verbatim copy)
+    for sid in (1001, 1003):
+        want = encode_cover(covers[sid])
+        for fid in FORMAT_IDS:
+            assert _frame_at(tmp_path, fid, got[sid]) == want[fid], (sid, fid)
+
+
+def test_compact_noop_when_nothing_removed(tmp_path):
+    attach_cover(tmp_path, 7, _solid_png((10, 10, 10)))
+    before = {fid: (tmp_path / f"F{fid}_1.ithmb").read_bytes() for fid in FORMAT_IDS}
+    stats = compact(tmp_path, {7, 999})          # 7 kept, 999 absent -> nothing to drop
+    assert stats["removed"] == 0
+    for fid in FORMAT_IDS:                        # files untouched
+        assert (tmp_path / f"F{fid}_1.ithmb").read_bytes() == before[fid]
+
+
+def test_compact_no_artworkdb_is_safe(tmp_path):
+    assert compact(tmp_path, {1, 2}) == {"kept": 0, "removed": 0}