From 899ab223b95d85525a493c7366eb13ff92f12755 Mon Sep 17 00:00:00 2001 From: Yuriy Panov Date: Thu, 22 Oct 2026 14:09:44 +0600 Subject: [PATCH] feat: fall back to LRCLIB when Yandex has no lyrics Look the track up on lrclib.net by exact signature, then by search filtered on length, preferring synced lyrics. The drawer credits LRCLIB, and the empty-state message no longer names Yandex. Co-Authored-By: Claude Opus 5.5 --- Cargo.lock | 1 + crates/musyx/examples/api_probe.rs | 12 +- crates/musyx/src/app/edit.rs | 8 +- crates/musyx/src/i18n/ru.rs | 3 +- crates/musyx/src/widgets/drawer.rs | 14 ++- crates/ym-api/Cargo.toml | 2 + crates/ym-api/src/client.rs | 12 +- crates/ym-api/src/edit.rs | 11 +- crates/ym-api/src/lib.rs | 3 +- crates/ym-api/src/lrclib.rs | 170 +++++++++++++++++++++++++++++ 10 files changed, 216 insertions(+), 20 deletions(-) create mode 100644 crates/ym-api/src/lrclib.rs diff --git a/Cargo.lock b/Cargo.lock index a8021ff..ae04978 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -6672,6 +6672,7 @@ checksum = "e01738255b5a16e78bbb83e7fbba0a1e7dd506905cfc53f4622d89015a03fbb5" name = "ym-api" version = "0.2.1" dependencies = [ + "reqwest", "serde", "serde_json", "thiserror 2.0.21", diff --git a/crates/musyx/examples/api_probe.rs b/crates/musyx/examples/api_probe.rs index 6833caa..f4c7525 100644 --- a/crates/musyx/examples/api_probe.rs +++ b/crates/musyx/examples/api_probe.rs @@ -74,10 +74,10 @@ async fn main() { if let Ok(found) = client.search("eminem without me", SearchKind::Tracks, 0).await { for track in found.tracks.iter().take(2) { println!("track {} {} lyrics_available={}", track.id, track.title, track.lyrics_available); - match client.lyrics(&track.id).await { + match client.lyrics(track).await { Ok(Some(l)) => println!( - "lyrics {}: synced={} lines={} first_stamp={:?}", - track.id, l.synced, l.lines.len(), l.lines.first().and_then(|x| x.at) + "lyrics {}: {:?} synced={} lines={} first_stamp={:?}", + track.id, l.source, l.synced, l.lines.len(), l.lines.first().and_then(|x| x.at) ), Ok(None) => println!("lyrics {}: none", track.id), Err(e) => println!("lyrics {}: ERROR {e}", track.id), @@ -87,10 +87,10 @@ async fn main() { if let Ok(chart) = client.chart().await { for entry in chart.iter().take(3) { println!("chart {} lyrics_available={}", entry.track.id, entry.track.lyrics_available); - match client.lyrics(&entry.track.id).await { + match client.lyrics(&entry.track).await { Ok(Some(l)) => println!( - "lyrics {}: synced={} lines={} first_stamp={:?}", - entry.track.id, l.synced, l.lines.len(), l.lines.first().and_then(|x| x.at) + "lyrics {}: {:?} synced={} lines={} first_stamp={:?}", + entry.track.id, l.source, l.synced, l.lines.len(), l.lines.first().and_then(|x| x.at) ), Ok(None) => println!("lyrics {}: none", entry.track.id), Err(e) => println!("lyrics {}: ERROR {e}", entry.track.id), diff --git a/crates/musyx/src/app/edit.rs b/crates/musyx/src/app/edit.rs index 75f8e40..7ad285f 100644 --- a/crates/musyx/src/app/edit.rs +++ b/crates/musyx/src/app/edit.rs @@ -275,11 +275,11 @@ impl App { if self.drawer != Some(crate::widgets::drawer::Panel::Lyrics) || self.lyrics.contains_key(&track.id) { return Task::none(); } - let id = track.id.clone(); - self.lyrics.insert(id.clone(), Loadable::Loading); + let track = track.clone(); + self.lyrics.insert(track.id.clone(), Loadable::Loading); Task::future(async move { - let result = client.lyrics(&id).await.map(|l| l.map(Arc::new)); - Message::LyricsLoaded(id, result) + let result = client.lyrics(&track).await.map(|l| l.map(Arc::new)); + Message::LyricsLoaded(track.id, result) }) } diff --git a/crates/musyx/src/i18n/ru.rs b/crates/musyx/src/i18n/ru.rs index 52e832c..857d5d8 100644 --- a/crates/musyx/src/i18n/ru.rs +++ b/crates/musyx/src/i18n/ru.rs @@ -274,12 +274,13 @@ pub fn get(english: &str) -> Option<&'static str> { "Очередь пока пуста. Здесь появятся треки, которые вы включите, и те, что за ними." } "Play a track to see its lyrics." => "Включите трек, чтобы увидеть его текст.", - "Yandex Music has no lyrics for this track." => "У Яндекс Музыки нет текста этого трека.", + "No lyrics for this track." => "У этого трека нет текста.", "Couldn't load the lyrics. Check your connection and try again." => { "Не удалось загрузить текст. Проверьте подключение и попробуйте ещё раз." } "Loading lyrics…" => "Загружаем текст…", "Written by {}" => "Авторы: {}", + "Lyrics from LRCLIB" => "Текст из LRCLIB", "No sound output found. Connect speakers or headphones and playback picks up." => { "Не найдено устройство вывода звука. Подключите колонки или наушники, и воспроизведение продолжится." } diff --git a/crates/musyx/src/widgets/drawer.rs b/crates/musyx/src/widgets/drawer.rs index 1e1f5d7..3a2ffac 100644 --- a/crates/musyx/src/widgets/drawer.rs +++ b/crates/musyx/src/widgets/drawer.rs @@ -4,7 +4,7 @@ use std::sync::Arc; use std::time::Duration; use iced::widget::{Column, button, column, container, row, scrollable, space}; -use ym_api::{Lyrics, Track}; +use ym_api::{Lyrics, LyricsSource, Track}; use iced::{Alignment, Element, Fill, Padding}; use crate::app::Message; @@ -69,7 +69,7 @@ pub fn view<'a>( (Panel::Lyrics, None) => note(t, tr("Play a track to see its lyrics.")), (Panel::Lyrics, Some(_)) => match lyrics { Some(Loadable::Loaded(Some(l))) => lyrics_view(t, l, player.position()), - Some(Loadable::Loaded(None)) => note(t, tr("Yandex Music has no lyrics for this track.")), + Some(Loadable::Loaded(None)) => note(t, tr("No lyrics for this track.")), Some(Loadable::Failed(_)) => column![ note(t, tr("Couldn't load the lyrics. Check your connection and try again.")), container( @@ -123,10 +123,14 @@ fn lyrics_view<'a>(t: &'static Tokens, l: &'a Lyrics, position: Duration) -> Ele } }); let mut list = Column::with_children(lines).spacing(2); - if !l.writers.is_empty() { + let credit = match l.source { + LyricsSource::Lrclib => Some(tr("Lyrics from LRCLIB").to_owned()), + LyricsSource::Yandex if !l.writers.is_empty() => Some(trf("Written by {}", &[&l.writers.join(", ")])), + LyricsSource::Yandex => None, + }; + if let Some(credit) = credit { list = list.push( - container(para(trf("Written by {}", &[&l.writers.join(", ")]), size::SMALL, t.muted)) - .padding(iced::Padding::default().top(18).left(8).right(8)), + container(para(credit, size::SMALL, t.muted)).padding(iced::Padding::default().top(18).left(8).right(8)), ); } scrollable(list.padding(Padding::default().left(10).right(10).bottom(18))) diff --git a/crates/ym-api/Cargo.toml b/crates/ym-api/Cargo.toml index fe7609d..db9c3e2 100644 --- a/crates/ym-api/Cargo.toml +++ b/crates/ym-api/Cargo.toml @@ -8,6 +8,8 @@ publish.workspace = true [dependencies] yamuse = "0.3.2" +# Same major as yamuse, so LRCLIB calls share its client and TLS setup. +reqwest = { version = "0.12", default-features = false } serde = { version = "1", features = ["derive"] } thiserror = "2" serde_json = "1" diff --git a/crates/ym-api/src/client.rs b/crates/ym-api/src/client.rs index ae1e771..1f65527 100644 --- a/crates/ym-api/src/client.rs +++ b/crates/ym-api/src/client.rs @@ -695,8 +695,16 @@ impl YmClient { // ---- Lyrics ---- - /// Synced lyrics when Yandex has them, else plain text; `None` when there are none. - pub async fn lyrics(&self, track_id: &str) -> Result> { + /// Synced lyrics when Yandex has them, else plain text, else whatever LRCLIB + /// has; `None` when neither has any. + pub async fn lyrics(&self, track: &Track) -> Result> { + if let Some(lyrics) = self.yandex_lyrics(&track.id).await? { + return Ok(Some(lyrics)); + } + crate::lrclib::lyrics(self.inner.transport().http(), track).await + } + + async fn yandex_lyrics(&self, track_id: &str) -> Result> { for format in [yamuse::LyricsFormat::Lrc, yamuse::LyricsFormat::Text] { let meta = match self.inner.track_lyrics(track_id, format).await { Ok(meta) => meta, diff --git a/crates/ym-api/src/edit.rs b/crates/ym-api/src/edit.rs index 8e9573b..ddd42a1 100644 --- a/crates/ym-api/src/edit.rs +++ b/crates/ym-api/src/edit.rs @@ -23,11 +23,19 @@ pub struct LyricLine { pub text: String, } +/// Where lyrics came from, so the UI can credit a source other than Yandex. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum LyricsSource { + Yandex, + Lrclib, +} + #[derive(Debug, Clone, PartialEq, Eq)] pub struct Lyrics { pub lines: Vec, pub synced: bool, pub writers: Vec, + pub source: LyricsSource, } impl Lyrics { @@ -45,6 +53,7 @@ impl Lyrics { lines: text.lines().map(|l| LyricLine { at: None, text: l.trim_end().to_owned() }).collect(), synced: false, writers, + source: LyricsSource::Yandex, } } @@ -72,7 +81,7 @@ impl Lyrics { } } lines.sort_by_key(|l| l.at); - Self { lines, synced: true, writers } + Self { lines, synced: true, writers, source: LyricsSource::Yandex } } } diff --git a/crates/ym-api/src/lib.rs b/crates/ym-api/src/lib.rs index 5edcac2..01961ff 100644 --- a/crates/ym-api/src/lib.rs +++ b/crates/ym-api/src/lib.rs @@ -10,6 +10,7 @@ mod discover; mod edit; mod error; mod library; +mod lrclib; mod models; mod wave; @@ -24,5 +25,5 @@ pub use wave::{ Character, Language, MY_WAVE, Mood, PlayReport, Station, WaveBatch, WaveEvent, WaveSettings, }; pub use discover::{BestMatch, ChartEntry, Genre, Home, Personal, SearchKind, SearchResults, Totals}; -pub use edit::{LikedIds, LyricLine, Lyrics}; +pub use edit::{LikedIds, LyricLine, Lyrics, LyricsSource}; pub use error::{Error, Result}; diff --git a/crates/ym-api/src/lrclib.rs b/crates/ym-api/src/lrclib.rs new file mode 100644 index 0000000..1684897 --- /dev/null +++ b/crates/ym-api/src/lrclib.rs @@ -0,0 +1,170 @@ +//! LRCLIB (lrclib.net), the open lyrics database, for tracks Yandex has no lyrics for. + +use std::time::Duration; + +use serde::Deserialize; + +use crate::edit::{Lyrics, LyricsSource}; +use crate::models::Track; +use crate::{Error, Result}; + +const BASE: &str = "https://lrclib.net/api"; +/// LRCLIB asks clients to name themselves. +const USER_AGENT: &str = concat!("musyx/", env!("CARGO_PKG_VERSION")); +const TIMEOUT: Duration = Duration::from_secs(10); +/// How far a match's length may stray from the track's; LRCLIB's own `get` uses ±2 s. +const SLACK: f64 = 2.0; + +#[derive(Debug, Deserialize)] +#[serde(rename_all = "camelCase")] +struct Record { + #[serde(default)] + duration: Option, + #[serde(default)] + instrumental: bool, + plain_lyrics: Option, + synced_lyrics: Option, +} + +impl Record { + fn has_lyrics(&self) -> bool { + !self.instrumental && (filled(&self.synced_lyrics).is_some() || filled(&self.plain_lyrics).is_some()) + } + + /// Synced when there are timings, else plain text. + fn into_lyrics(self) -> Option { + if self.instrumental { + return None; + } + let lyrics = match (filled(&self.synced_lyrics), filled(&self.plain_lyrics)) { + (Some(lrc), _) => Lyrics::from_lrc(lrc, vec![]), + (None, Some(text)) => Lyrics::from_text(text, vec![]), + (None, None) => return None, + }; + Some(Lyrics { source: LyricsSource::Lrclib, ..lyrics }) + } +} + +fn filled(s: &Option) -> Option<&str> { + s.as_deref().filter(|s| !s.trim().is_empty()) +} + +/// Looks the track up by its exact signature first, then by a looser search +/// filtered on length so a live cut or a remix doesn't borrow the studio timings. +pub(crate) async fn lyrics(http: &reqwest::Client, track: &Track) -> Result> { + let Some(artist) = track.artists.first().map(|a| a.name.as_str()) else { return Ok(None) }; + let secs = track.duration.as_secs_f64(); + + if let Some(album) = &track.album + && secs > 0.0 + { + let duration = secs.round().to_string(); + let query = [ + ("track_name", track.title.as_str()), + ("artist_name", artist), + ("album_name", album.title.as_str()), + ("duration", duration.as_str()), + ]; + if let Some(record) = get::(http, "get", &query).await? + && let Some(lyrics) = record.into_lyrics() + { + return Ok(Some(lyrics)); + } + } + + let query = [("track_name", track.title.as_str()), ("artist_name", artist)]; + let found = get::>(http, "search", &query).await?.unwrap_or_default(); + Ok(pick(found, secs).and_then(Record::into_lyrics)) +} + +/// The closest-length match that has words, preferring synced ones. +fn pick(found: Vec, secs: f64) -> Option { + let off = |r: &Record| match r.duration { + Some(d) if secs > 0.0 => (d - secs).abs(), + _ => 0.0, + }; + found + .into_iter() + .filter(|r| r.has_lyrics() && (secs <= 0.0 || r.duration.is_none_or(|d| (d - secs).abs() <= SLACK))) + .min_by(|a, b| { + filled(&b.synced_lyrics) + .is_some() + .cmp(&filled(&a.synced_lyrics).is_some()) + .then(off(a).total_cmp(&off(b))) + }) +} + +/// `None` on 404, which LRCLIB answers when it has no such track. +async fn get( + http: &reqwest::Client, + endpoint: &str, + query: &[(&str, &str)], +) -> Result> { + let network = |e: reqwest::Error| Error::Network(format!("lrclib: {e}")); + let response = http + .get(format!("{BASE}/{endpoint}")) + .query(query) + .header(reqwest::header::USER_AGENT, USER_AGENT) + .timeout(TIMEOUT) + .send() + .await + .map_err(network)?; + let status = response.status(); + if status == reqwest::StatusCode::NOT_FOUND { + return Ok(None); + } + if !status.is_success() { + return Err(if status.is_server_error() || status == reqwest::StatusCode::TOO_MANY_REQUESTS { + Error::Network(format!("lrclib: {status}")) + } else { + Error::Api(format!("lrclib: {status}")) + }); + } + let body = response.bytes().await.map_err(network)?; + serde_json::from_slice(&body).map(Some).map_err(|e| Error::Api(format!("lrclib: {e}"))) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn records(json: &str) -> Vec { + serde_json::from_str(json).unwrap() + } + + #[test] + fn prefers_synced_then_closest_length() { + let found = records( + r#"[ + {"duration":200,"instrumental":false,"plainLyrics":"far","syncedLyrics":"[00:01.00]far"}, + {"duration":181,"instrumental":false,"plainLyrics":"plain","syncedLyrics":null}, + {"duration":182,"instrumental":false,"plainLyrics":"x","syncedLyrics":"[00:01.00]near"}, + {"duration":180,"instrumental":false,"plainLyrics":"y","syncedLyrics":"[00:01.00]exact"} + ]"#, + ); + let l = pick(found, 180.0).unwrap().into_lyrics().unwrap(); + assert!(l.synced); + assert_eq!(l.lines[0].text, "exact"); + assert_eq!(l.source, LyricsSource::Lrclib); + } + + #[test] + fn skips_instrumentals_and_wrong_lengths() { + let found = records( + r#"[ + {"duration":180,"instrumental":true,"plainLyrics":null,"syncedLyrics":null}, + {"duration":240,"instrumental":false,"plainLyrics":"live","syncedLyrics":null} + ]"#, + ); + assert!(pick(found, 180.0).is_none()); + } + + #[test] + fn falls_back_to_plain_text() { + let r = records(r#"[{"duration":180,"instrumental":false,"plainLyrics":"a\nb","syncedLyrics":" "}]"#); + let l = pick(r, 180.0).unwrap().into_lyrics().unwrap(); + assert!(!l.synced); + assert_eq!(l.lines.len(), 2); + } +} +