ipodsync 0.1.6__tar.gz → 0.1.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ipodsync
-Version: 0.1.6
+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.6 → ipodsync-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ipodsync"
-version = "0.1.6"
+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.6 → 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.6"
+__version__ = "0.1.8"
 
 __all__ = [
     "find_ipod",

{ipodsync-0.1.6 → 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.6 → 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.6 → ipodsync-0.1.8}/src/ipodsync/library.py

@@ -229,11 +229,40 @@ class ItlpLibrary:
         self.cx["Library.itdb"].commit()
 
     # --- DELETE ---------------------------------------------------------------
+    # Lookup tables that are reference-counted by `item`: (table, key col, item col).
+    _LOOKUP_TABLES = (
+        ("album", "pid", "album_pid"),
+        ("artist", "pid", "artist_pid"),
+        ("composer", "pid", "composer_pid"),
+        ("track_artist", "pid", "track_artist_pid"),
+        ("genre_map", "id", "genre_id"),
+    )
+
+    def gc_orphan_lookups(self) -> int:
+        """Delete album/artist/composer/track_artist/genre rows no longer referenced
+        by any item. Otherwise removed tracks leave behind empty albums in the UI.
+
+        A full sweep, so it also cleans up orphans left by earlier versions. Returns
+        the number of rows removed.
+        """
+        lib = self.cx["Library.itdb"]
+        removed = 0
+        for table, key, ref in self._LOOKUP_TABLES:
+            try:
+                cur = lib.execute(
+                    f'DELETE FROM "{table}" WHERE "{key}" NOT IN '
+                    f'(SELECT "{ref}" FROM item WHERE "{ref}" IS NOT NULL)')
+                removed += cur.rowcount if cur.rowcount and cur.rowcount > 0 else 0
+            except sqlite3.OperationalError:
+                continue  # table/column absent on this device — skip it
+        lib.commit()
+        return removed
+
     def remove_track(self, pid: int, *, music_dir: Path | None = None) -> str | None:
         """Remove a track from all tables. If music_dir is given — also delete the file.
 
         Returns the location of the deleted file (or None). After removal, don't
-        forget resign(). We leave orphaned album/artist/genre (iTunes is fine with it).
+        forget resign(). Orphaned album/artist/genre rows are swept by gc_orphan_lookups().
         """
         lib = self.cx["Library.itdb"]
         r = self.cx["Locations.itdb"].execute(
@@ -249,6 +278,7 @@ class ItlpLibrary:
         self.cx["Locations.itdb"].execute("DELETE FROM location WHERE item_pid=?", (pid,))
         self.cx["Dynamic.itdb"].execute("DELETE FROM item_stats WHERE item_pid=?", (pid,))
         self.cx["Extras.itdb"].execute("DELETE FROM chapter WHERE item_pid=?", (pid,))
+        self.gc_orphan_lookups()
         for c in self.cx.values():
             c.commit()
 

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}

ipodsync-0.1.8/tests/test_gc_orphans.py

@@ -0,0 +1,76 @@
+"""gc_orphan_lookups() must delete lookup rows (album/artist/track_artist/genre)
+no longer referenced by any item, so removing tracks doesn't leave empty albums."""
+import sqlite3
+
+from ipodsync.library import ItlpLibrary
+
+
+def _make_itlp(tmp_path):
+    """A minimal .itlp dir: a Library.itdb with item + lookup tables, plus the
+    other three (empty) dbs the constructor opens."""
+    d = tmp_path / "iTunes Library.itlp"
+    d.mkdir()
+    for name in ("Locations.itdb", "Dynamic.itdb", "Extras.itdb"):
+        sqlite3.connect(d / name).close()          # just needs to exist & be valid
+    lib = sqlite3.connect(d / "Library.itdb")
+    lib.executescript(
+        """
+        CREATE TABLE item (pid INTEGER PRIMARY KEY, album_pid INTEGER,
+            artist_pid INTEGER, track_artist_pid INTEGER, genre_id INTEGER);
+        CREATE TABLE album (pid INTEGER PRIMARY KEY, name TEXT);
+        CREATE TABLE artist (pid INTEGER PRIMARY KEY, name TEXT);
+        CREATE TABLE track_artist (pid INTEGER PRIMARY KEY, name TEXT);
+        CREATE TABLE genre_map (id INTEGER PRIMARY KEY, genre TEXT);
+
+        INSERT INTO album VALUES (10, 'Kept'), (11, 'Empty');
+        INSERT INTO artist VALUES (20, 'Kept'), (21, 'Empty');
+        INSERT INTO track_artist VALUES (30, 'Kept'), (31, 'Empty');
+        INSERT INTO genre_map VALUES (40, 'Rock'), (41, 'Ambient');
+
+        -- one item referencing only the *Kept* lookups; the *Empty* ones are orphans
+        INSERT INTO item VALUES (100, 10, 20, 30, 40);
+        """
+    )
+    lib.commit()
+    lib.close()
+    return d
+
+
+def test_gc_removes_orphans_keeps_referenced(tmp_path):
+    d = _make_itlp(tmp_path)
+    lib = ItlpLibrary(d)
+    try:
+        removed = lib.gc_orphan_lookups()
+        assert removed == 4  # one orphan in each of the 4 tables
+
+        cx = lib.cx["Library.itdb"]
+        assert [r[0] for r in cx.execute("SELECT pid FROM album ORDER BY pid")] == [10]
+        assert [r[0] for r in cx.execute("SELECT pid FROM artist ORDER BY pid")] == [20]
+        assert [r[0] for r in cx.execute("SELECT pid FROM track_artist ORDER BY pid")] == [30]
+        assert [r[0] for r in cx.execute("SELECT id FROM genre_map ORDER BY id")] == [40]
+    finally:
+        lib.close()
+
+
+def test_gc_wipes_all_lookups_when_no_items(tmp_path):
+    d = _make_itlp(tmp_path)
+    lib = ItlpLibrary(d)
+    try:
+        lib.cx["Library.itdb"].execute("DELETE FROM item")
+        lib.cx["Library.itdb"].commit()
+        lib.gc_orphan_lookups()
+        for table in ("album", "artist", "track_artist", "genre_map"):
+            n = lib.cx["Library.itdb"].execute(f"SELECT COUNT(*) FROM {table}").fetchone()[0]
+            assert n == 0, f"{table} should be empty once no item references it"
+    finally:
+        lib.close()
+
+
+def test_gc_tolerates_missing_table(tmp_path):
+    """composer table isn't present here — gc must skip it, not raise."""
+    d = _make_itlp(tmp_path)
+    lib = ItlpLibrary(d)
+    try:
+        lib.gc_orphan_lookups()  # must not raise despite no `composer` table
+    finally:
+        lib.close()