Needs Work tab: find and stage tracks that need MIK or Platinum Notes

Sortero can derive genre, artist and title, but key, BPM and energy need
outside tools. The Needs Work tab makes that actionable rather than just a
number on the dashboard: filter by what is missing, select tracks, and stage
them in 'To Be Processed' ready for Platinum Notes and Mixed In Key.

Set recordings are excluded - the Recorded Mixes folder and anything over 20
minutes are your own sets, not tracks to analyse, and staging them would be
wrong. This drops the "missing key or BPM" list from 335 to 310 on a real
library.

Also caches the mutagen handle instead of reopening each file three times per
scan (2,754 files: ~20s -> ~3.5s), and names the macOS release artifact
universal2 when it really is both architectures.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: sparkly-quasar

README.md

@@ -45,8 +45,21 @@ DJ Collection/
 | **Tags** | Strips download-site spam from Genre/Comment, infers missing Artist/Title from filenames, normalises Genre, and promotes Mixed In Key energy into the sortable Grouping field. |
 | **Duplicates** | Exact (identical audio) and Likely (same artist/title/version, same length). Different remixes are never grouped. Extras move to `_Quarantine`. |
 | **Import** | Add files or folders. Analysed tracks go straight to `Tracks/<Genre>`; anything missing key/BPM lands in `To Be Processed`. Tracks already in the library are flagged, not copied. **"Sort the 'Processed' folder"** files everything you've already run through PN and MIK. |
+| **Needs Work** | Everything Sortero can't fix by itself, filtered by what's missing (key/BPM, energy, genre, artist, low bitrate). Select tracks and stage them in `To Be Processed` for Platinum Notes and Mixed In Key. Your own set recordings are excluded. |
+| **Playlists** | Rebuild a Spotify or TIDAL playlist against your local files, or rebuild the folder playlists. |
 | **History** | Every operation, with one-click undo. |
 
+## The analysis loop
+
+Sortero can compute genre, artist and titles, but not key, BPM or energy —
+those need Mixed In Key and Platinum Notes. The **Needs Work** tab closes that
+loop:
+
+1. Filter by *Missing key or BPM* and select what you want.
+2. **Stage selected in 'To Be Processed'.**
+3. Run that folder through Platinum Notes and Mixed In Key, saving into `Processed`.
+4. **Import → "Sort the 'Processed' folder"** files them by genre automatically.
+
 ## Streaming playlists
 
 Paste a Spotify or TIDAL playlist link on the **Playlists** tab and Sortero

build/build_app.py

@@ -89,7 +89,11 @@ def main():
         # Ad-hoc signature so Gatekeeper will run it locally.
         subprocess.run(["codesign", "--force", "--deep", "--sign", "-", app],
                        capture_output=True)
-        arch = "-".join(mac_arches(os.path.join(app, "Contents", "MacOS", "Sortero"))) or "unknown"
+        arches = mac_arches(os.path.join(app, "Contents", "MacOS", "Sortero"))
+        if "x86_64" in arches and "arm64" in arches:
+            arch = "universal2"
+        else:
+            arch = "-".join(arches) or "unknown"
         zip_path = os.path.join(DIST, f"Sortero-macOS-{arch}.zip")
         print("==> zipping (ditto preserves the bundle)")
         subprocess.run(["ditto", "-c", "-k", "--sequesterRsrc", "--keepParent",

sortero/app.py

@@ -122,12 +122,13 @@ def _build_tabs(self):
         self.tab_tags = TagsTab(self.nb, self)
         self.tab_dupes = DupesTab(self.nb, self)
         self.tab_import = ImportTab(self.nb, self)
+        self.tab_needs = NeedsWorkTab(self.nb, self)
         self.tab_playlists = PlaylistTab(self.nb, self)
         self.tab_history = HistoryTab(self.nb, self)
         for t, n in [(self.tab_overview, "Overview"), (self.tab_organize, "Organise"),
                      (self.tab_tags, "Tags"), (self.tab_dupes, "Duplicates"),
-                     (self.tab_import, "Import"), (self.tab_playlists, "Playlists"),
-                     (self.tab_history, "History")]:
+                     (self.tab_import, "Import"), (self.tab_needs, "Needs Work"),
+                     (self.tab_playlists, "Playlists"), (self.tab_history, "History")]:
             self.nb.add(t, text=n)
 
     def _build_footer(self):
@@ -173,7 +174,7 @@ def done(res):
             self.recs, self.health = res
             self.tab_overview.render(self.health)
             for t in (self.tab_organize, self.tab_tags, self.tab_dupes,
-                      self.tab_import, self.tab_playlists):
+                      self.tab_import, self.tab_needs, self.tab_playlists):
                 t.invalidate()
             self.log(f"Scanned {len(self.recs)} files in {d}")
 
@@ -675,6 +676,150 @@ def done(res):
         self.app.task.run(work, done, "Importing")
 
 
+class NeedsWorkTab(BaseTab):
+    """Find and act on tracks whose metadata still needs outside help."""
+
+    FILTERS = [
+        ("Missing key or BPM — needs Platinum Notes + Mixed In Key",
+         lambda r: not r.analyzed),
+        ("Missing key only", lambda r: not r.key),
+        ("Missing BPM only", lambda r: not r.bpm),
+        ("No energy rating", lambda r: r.energy is None),
+        ("Missing genre", lambda r: not r.genre),
+        ("Missing artist", lambda r: not r.artist),
+        ("Low bitrate (under 192 kbps)", lambda r: 0 < getattr(r, "bitrate", 0) < 192000),
+    ]
+
+    def build(self):
+        ttk.Label(self, foreground="#666", wraplength=980, justify="left",
+                  text="Everything here needs something Sortero can't compute itself. "
+                       "Pick a filter, select the tracks you want, then stage them in "
+                       "'To Be Processed' — drop that folder into Platinum Notes and "
+                       "Mixed In Key, and when they land in 'Processed' the Import tab "
+                       "files them automatically."
+                  ).pack(anchor="w", pady=(0, 8))
+
+        row = ttk.Frame(self)
+        row.pack(fill="x", pady=(0, 8))
+        ttk.Label(row, text="Show").pack(side="left")
+        self.filter_var = tk.StringVar(value=self.FILTERS[0][0])
+        box = ttk.Combobox(row, textvariable=self.filter_var, width=52, state="readonly",
+                           values=[f[0] for f in self.FILTERS])
+        box.pack(side="left", padx=6)
+        box.bind("<<ComboboxSelected>>", lambda e: self.refresh())
+        ttk.Button(row, text="Select all", command=self.select_all).pack(side="left", padx=6)
+        ttk.Button(row, text="Reveal selected",
+                   command=self.reveal).pack(side="left")
+        self.count = ttk.Label(row, text="", foreground="#444")
+        self.count.pack(side="left", padx=12)
+
+        row0 = ttk.Frame(self)
+        row0.pack(fill="x", pady=(0, 6))
+        self.skip_mixes = tk.BooleanVar(value=True)
+        ttk.Checkbutton(row0, text="Hide your set recordings "
+                                   "(the Recorded Mixes folder, and anything over 20 minutes)",
+                        variable=self.skip_mixes,
+                        command=self.refresh).pack(side="left")
+
+        row2 = ttk.Frame(self)
+        row2.pack(fill="x", pady=(0, 8))
+        self.stage_btn = ttk.Button(row2, text="Stage selected in 'To Be Processed'",
+                                    command=self.stage, state="disabled")
+        self.stage_btn.pack(side="left")
+        ttk.Button(row2, text="Copy list", command=self.copy).pack(side="left", padx=8)
+
+        f, self.tv = tree(self, ("Track", "Key", "BPM", "Energy", "Genre", "Where"),
+                          (330, 60, 60, 60, 150, 300), height=15)
+        f.pack(fill="both", expand=True)
+        self.tv.bind("<<TreeviewSelect>>", lambda e: self._sync())
+        self.rows = []
+
+    def invalidate(self):
+        self.refresh()
+
+    def _predicate(self):
+        for label, fn in self.FILTERS:
+            if label == self.filter_var.get():
+                return fn
+        return self.FILTERS[0][1]
+
+    def refresh(self):
+        self.tv.delete(*self.tv.get_children())
+        self.rows = []
+        if not self.app.recs:
+            self.count.configure(text="")
+            return
+        pred = self._predicate()
+        skip_mixes = self.skip_mixes.get()
+        for r in self.app.recs:
+            if r.protected or not pred(r):
+                continue
+            # Your own set recordings are never candidates for analysis.
+            if skip_mixes and (r.is_recording or
+                               (r.duration and r.duration >= organize.MIX_MIN_SECONDS)):
+                continue
+            self.rows.append(r)
+            self.tv.insert("", "end", values=(
+                r.display[:80], r.camelot or r.key or "—", r.bpm or "—",
+                r.energy if r.energy is not None else "—",
+                (r.genre or "—")[:28], os.path.dirname(r.rel) or "(root)"))
+        self.count.configure(text=f"{len(self.rows)} tracks")
+        self._sync()
+
+    def _sync(self):
+        n = len(self.tv.selection())
+        self.stage_btn.configure(state="normal" if n else "disabled")
+        if n:
+            self.count.configure(text=f"{len(self.rows)} tracks · {n} selected")
+        else:
+            self.count.configure(text=f"{len(self.rows)} tracks")
+
+    def select_all(self):
+        self.tv.selection_set(self.tv.get_children())
+        self._sync()
+
+    def _selected_recs(self):
+        return [self.rows[self.tv.index(i)] for i in self.tv.selection()]
+
+    def reveal(self):
+        recs = self._selected_recs()
+        if not recs:
+            messagebox.showinfo(APP, "Select a track first.")
+            return
+        paths.reveal(recs[0].path)
+
+    def copy(self):
+        recs = self._selected_recs() or self.rows
+        if not recs:
+            return
+        self.clipboard_clear()
+        self.clipboard_append("\n".join(r.display for r in recs))
+        messagebox.showinfo(APP, f"Copied {len(recs)} track names.")
+
+    def stage(self):
+        recs = self._selected_recs()
+        if not recs:
+            return
+        if not messagebox.askyesno(
+                APP, f"Move {len(recs)} tracks into 'To Be Processed'?\n\n"
+                     "Run them through Platinum Notes and Mixed In Key, save the "
+                     "results into 'Processed', then use Import → \"Sort the "
+                     "'Processed' folder\".\n\nReversible from History."):
+            return
+        root = self.app.root_dir.get()
+
+        def work(progress, log):
+            return organize.stage_for_analysis(root, recs, log=log, progress=progress)
+
+        def done(res):
+            path, n = res
+            messagebox.showinfo(APP, f"Staged {n} tracks in 'To Be Processed'.")
+            self.app.tab_history.refresh()
+            self.app.scan()
+
+        self.app.task.run(work, done, "Staging tracks")
+
+
 class PlaylistTab(BaseTab):
     """Rebuild a curated streaming playlist against the local collection."""
 

sortero/library.py

@@ -8,8 +8,9 @@
 # areas, plus Sortero's own quarantine.
 PROTECTED = {"To Be Processed", "Processed", "_Quarantine", "_Playlists"}
 
-# Folders that hold full releases / recordings rather than individual DJ tracks.
-NON_TRACK_HINTS = re.compile(r"(?i)^(recorded mixes|renaissance|compilations)")
+# Folders holding your own recordings rather than tracks to play. Nothing in
+# here ever needs Mixed In Key / Platinum Notes analysis.
+RECORDING_DIRS = {"Recorded Mixes", "Mixes", "Recordings"}
 
 
 @dataclass
@@ -27,6 +28,7 @@ class Rec:
     comment: str = None
     album: str = None
     duration: float = 0.0
+    bitrate: int = 0
     protected: bool = False
 
     @property
@@ -46,6 +48,11 @@ def energy(self):
                     return int(m.group(1))
         return None
 
+    @property
+    def is_recording(self):
+        """A recording of a set, not a track to mix with."""
+        return any(p in RECORDING_DIRS for p in self.rel.split(os.sep))
+
     @property
     def analyzed(self):
         return bool(self.key and self.bpm)
@@ -101,6 +108,7 @@ def scan(root, progress=None):
             r.comment = _clean(t.get("comment"))
             r.album = _clean(t.get("album"))
             r.duration = t.length or 0.0
+            r.bitrate = t.bitrate or 0
         if not r.artist or not r.title:
             a, ti = split_artist_title(clean_stem(p))
             r.artist = r.artist or a
@@ -136,7 +144,7 @@ def health(recs):
         "spam_genre": spam_genre,
         "spam_comment": spam_comment,
         "no_energy": [r for r in live if r.energy is None],
-        "low_bitrate": [],
+        "low_bitrate": [r for r in live if 0 < r.bitrate < 192000],
         "genres": collections.Counter(r.genre for r in live if r.genre and not is_spam(r.genre)),
         "keys": collections.Counter(r.camelot for r in live if r.camelot),
         "tops": collections.Counter(r.top for r in recs),

sortero/organize.py

@@ -296,6 +296,36 @@ def write_playlists(root, playlists, journal=None, dry=False):
     return written
 
 
+def stage_for_analysis(root, recs, log=print, progress=None):
+    """Move chosen tracks into 'To Be Processed' for Platinum Notes / Mixed In Key."""
+    j = Journal("stage-for-analysis", root)
+    dest_dir = os.path.join(root, "To Be Processed")
+    total = len(recs) or 1
+    n = 0
+    for i, r in enumerate(recs):
+        if progress and i % 10 == 0:
+            progress(i, total)
+        try:
+            os.makedirs(dest_dir, exist_ok=True)
+            dest = os.path.join(dest_dir, target_filename(r))
+            stem, ext = os.path.splitext(dest)
+            c = 1
+            while os.path.exists(dest):
+                c += 1
+                dest = f"{stem} ({c}){ext}"
+            shutil.move(r.path, dest)
+            j.moved(r.path, dest)
+            n += 1
+        except Exception as e:
+            log(f"  ! {os.path.basename(r.path)}: {e}")
+    prune_empty(root, keep=PROTECTED)
+    if progress:
+        progress(total, total)
+    path = j.save()
+    log(f"staged {n} tracks in 'To Be Processed' | journal: {path}")
+    return path, n
+
+
 def apply(root, moves, playlists, log=print, progress=None):
     """Execute the plan. Returns the saved journal path."""
     j = Journal("organize", root)

sortero/tagio.py

@@ -27,6 +27,7 @@ def __init__(self, path):
             a = mutagen.File(path)
         except Exception:
             a = None
+        self._mf = a            # kept so length/bitrate don't reopen the file
         if isinstance(a, (FLAC, OggVorbis)):
             self.kind, self.audio = "vorbis", a
         elif isinstance(a, MP4):
@@ -45,15 +46,19 @@ def __init__(self, path):
     def ok(self):
         return self.audio is not None
 
+    @property
+    def bitrate(self):
+        """Nominal bitrate in bits/sec, or 0 when unavailable."""
+        try:
+            return int(getattr(self._mf.info, "bitrate", 0) or 0)
+        except Exception:
+            return 0
+
     @property
     def length(self):
         """Duration in seconds, or 0.0 when unavailable."""
         try:
-            if self.kind in ("vorbis", "mp4") and self.audio is not None:
-                return float(self.audio.info.length)
-            import mutagen
-            a = mutagen.File(self.path)
-            return float(a.info.length) if a is not None else 0.0
+            return float(self._mf.info.length)
         except Exception:
             return 0.0