Add configurable library reference roots

serato_doctor/cli.py

@@ -1,6 +1,7 @@
 from pathlib import Path
 import argparse
 
+from serato_doctor.config import ScanConfig
 from serato_doctor.crate_parser import parse_crates
 from serato_doctor.models.library import Library
 from serato_doctor.scanner import scan_audio
@@ -13,28 +14,39 @@ def main():
     parser.add_argument("--music", default=str(Path.home() / "Library/CloudStorage/OneDrive-Personal/Jukebox"))
     parser.add_argument("--out", default=str(Path.home() / "Desktop/serato_doctor_scan.csv"))
     parser.add_argument("--report", default=str(Path.home() / "Desktop/serato_doctor_missing_report.txt"))
+    parser.add_argument(
+        "--reference-root",
+        action="append",
+        default=[],
+        help="Old library root stored in crates; may be supplied more than once",
+    )
     args = parser.parse_args()
 
-    serato = Path(args.serato)
-    music = Path(args.music)
-    out = Path(args.out)
-    report = Path(args.report)
+    config = ScanConfig.build(
+        serato=Path(args.serato),
+        music=Path(args.music),
+        out=Path(args.out),
+        report=Path(args.report),
+        reference_roots=(Path(root) for root in args.reference_root),
+    )
 
     library = Library.build(
-        references=parse_crates(serato / "Subcrates"),
-        tracks=scan_audio(music),
+        references=parse_crates(
+            config.serato / "Subcrates", config.reference_roots
+        ),
+        tracks=scan_audio(config.music),
     )
     results = library.reconcile_by_filename()
     missing_count = sum(1 for result in results if not result.exists_by_filename)
 
-    write_csv(results, out)
-    write_missing_report(results, report)
+    write_csv(results, config.out)
+    write_missing_report(results, config.report)
 
     print(f"Crate references: {len(library.references)}")
     print(f"Disk tracks: {len(library.tracks)}")
     print(f"Missing by filename: {missing_count}")
-    print(f"CSV: {out}")
-    print(f"Report: {report}")
+    print(f"CSV: {config.out}")
+    print(f"Report: {config.report}")
 
 
 if __name__ == "__main__":

serato_doctor/config.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Iterable, Tuple
+
+
+@dataclass(frozen=True)
+class ScanConfig:
+    """Read-only paths used for one library scan."""
+
+    serato: Path
+    music: Path
+    out: Path
+    report: Path
+    reference_roots: Tuple[Path, ...] = ()
+
+    @classmethod
+    def build(
+        cls,
+        serato: Path,
+        music: Path,
+        out: Path,
+        report: Path,
+        reference_roots: Iterable[Path] = (),
+    ) -> "ScanConfig":
+        return cls(serato, music, out, report, tuple(reference_roots))

serato_doctor/crate_parser.py

@@ -1,4 +1,5 @@
 from pathlib import Path
+from typing import Iterable, Tuple
 
 from serato_doctor.models.crate import Crate
 from serato_doctor.models.reference import TrackReference
@@ -21,45 +22,63 @@ def clean_path(raw: str) -> str:
     return raw.strip()
 
 
-def load_crate(crate_path: Path) -> Crate:
+DEFAULT_PATH_MARKERS = ("Users/", "Volumes/")
+
+
+def path_markers(reference_roots: Iterable[Path]) -> Tuple[str, ...]:
+    configured = tuple(
+        root.expanduser().as_posix().strip("/") + "/" for root in reference_roots
+    )
+    return configured or DEFAULT_PATH_MARKERS
+
+
+def load_crate(crate_path: Path, reference_roots: Iterable[Path] = ()) -> Crate:
     text = read_crate_text(crate_path)
     refs = []
 
-    marker = "Users/djsplice/OneDrive/Jukebox/"
-
     # Serato record markers seen after paths in UTF-16-LE decoded crate data.
     stop_markers = ["牴k", "otrk", "ptrk", "tvcn", "ovct"]
 
-    for part in text.split(marker)[1:]:
-        candidate = marker + part
+    for marker in path_markers(reference_roots):
+        for part in text.split(marker)[1:]:
+            candidate = marker + part
 
-        stops = [candidate.find(m) for m in stop_markers if candidate.find(m) != -1]
-        if not stops:
-            continue
+            stops = [
+                candidate.find(stop)
+                for stop in stop_markers
+                if candidate.find(stop) != -1
+            ]
+            if not stops:
+                continue
 
-        raw_path = "/" + candidate[: min(stops)]
-        raw_path = clean_path(raw_path)
+            raw_path = "/" + candidate[: min(stops)]
+            raw_path = clean_path(raw_path)
 
-        path = Path(raw_path)
-        refs.append(
-            TrackReference(
-                source=crate_path,
-                path=path,
-                filename=path.name,
+            path = Path(raw_path)
+            refs.append(
+                TrackReference(
+                    source=crate_path,
+                    path=path,
+                    filename=path.name,
+                )
             )
-        )
 
     return Crate(path=crate_path, references=tuple(refs))
 
 
-def parse_crate(crate_path: Path) -> list[TrackReference]:
+def parse_crate(
+    crate_path: Path, reference_roots: Iterable[Path] = ()
+) -> list[TrackReference]:
     """Parse references from one crate, preserving the prototype API."""
 
-    return list(load_crate(crate_path).references)
+    return list(load_crate(crate_path, reference_roots).references)
 
 
-def parse_crates(root: Path) -> list[TrackReference]:
+def parse_crates(
+    root: Path, reference_roots: Iterable[Path] = ()
+) -> list[TrackReference]:
     refs = []
+    reference_roots = tuple(reference_roots)
     for crate in root.rglob("*.crate"):
-        refs.extend(parse_crate(crate))
+        refs.extend(parse_crate(crate, reference_roots))
     return refs