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); + } +} +