ipodsync 0.1.6__tar.gz → 0.1.7__tar.gz

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

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "ipodsync"
-version = "0.1.6"
+version = "0.1.7"
 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.7}/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.7"
 
 __all__ = [
     "find_ipod",

{ipodsync-0.1.6 → ipodsync-0.1.7}/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.7/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()