Files
musyx/crates/musyx/examples/api_probe.rs
T
yuriy.pandClaude Opus 5.5 899ab223b9 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 <noreply@anthropic.com>
2026-10-22 14:39:21 +06:00

125 lines
5.9 KiB
Rust

//! Read-only check of the discovery endpoints with the signed-in account:
//! `cargo run -p musyx --example api_probe`. Prints counts and a few titles.
use ym_api::auth::Credentials;
use ym_api::{SearchKind, YmClient};
#[tokio::main(flavor = "current_thread")]
async fn main() {
let raw = keyring::Entry::new("musyx", "yandex-music")
.and_then(|e| e.get_password())
.expect("sign in with Musyx first");
let credentials: Credentials = serde_json::from_str(&raw).expect("stored credentials");
let (client, account) = YmClient::connect(&credentials, ym_api::ContentLanguage::English).await.expect("connect");
println!("account: {} (plus: {})", account.login, account.has_plus);
match client.home().await {
Ok(h) => println!(
"home: {} personal {:?}, {} chart, {} new releases, {} new playlists",
h.personal.len(),
h.personal.iter().map(|p| p.playlist.title.as_str()).collect::<Vec<_>>(),
h.chart.len(),
h.new_releases.len(),
h.new_playlists.len()
),
Err(e) => println!("home: ERROR {e}"),
}
match client.genres().await {
Ok(g) => {
println!("genres: {} {:?}", g.len(), g.iter().take(8).map(|g| (&g.id, &g.title)).collect::<Vec<_>>());
for genre in g.iter().skip(1).take(4) {
match client.tag_playlists(&genre.id).await {
Ok(p) => println!("tag {}: {} playlists {:?}", genre.id, p.len(), p.iter().take(2).map(|p| &p.title).collect::<Vec<_>>()),
Err(e) => println!("tag {}: ERROR {e}", genre.id),
}
}
}
Err(e) => println!("genres: ERROR {e}"),
}
match client.featured_podcasts().await {
Ok(p) => println!("podcasts: {} {:?}", p.len(), p.iter().take(3).map(|a| &a.title).collect::<Vec<_>>()),
Err(e) => println!("podcasts: ERROR {e}"),
}
match client.search("земфира", SearchKind::All, 0).await {
Ok(r) => println!(
"search: best {:?}, {} tracks ({}), {} albums, {} artists, {} playlists, {} podcasts",
r.best.as_ref().map(|b| format!("{b:?}").chars().take(60).collect::<String>()),
r.tracks.len(), r.totals.tracks, r.albums.len(), r.artists.len(), r.playlists.len(), r.podcasts.len()
),
Err(e) => println!("search: ERROR {e}"),
}
match client.stations().await {
Ok(st) => println!("stations: {} {:?}", st.len(), st.iter().take(6).map(|s| (&s.id, &s.name)).collect::<Vec<_>>()),
Err(e) => println!("stations: ERROR {e}"),
}
match client.wave_settings(ym_api::MY_WAVE).await {
Ok(s) => println!("wave settings: {s:?}"),
Err(e) => println!("wave settings: ERROR {e}"),
}
match client.wave_start(ym_api::MY_WAVE, None).await {
Ok(b) => println!(
"wave session {:?} batch {:?}: {:?}",
b.session_id,
b.batch_id,
b.tracks.iter().map(|t| format!("{} — {}", t.artist_line(), t.title)).collect::<Vec<_>>()
),
Err(e) => println!("wave: ERROR {e}"),
}
match client.liked_ids().await {
Ok(l) => println!(
"liked ids: {} albums, {} artists, {} playlists, {} disliked tracks",
l.albums.len(), l.artists.len(), l.playlists.len(), l.disliked_tracks.len()
),
Err(e) => println!("liked ids: ERROR {e}"),
}
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).await {
Ok(Some(l)) => println!(
"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),
}
}
}
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).await {
Ok(Some(l)) => println!(
"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),
}
}
}
match client.recently_played(10).await {
Ok(r) => println!("recently played: {} {:?}", r.len(), r.iter().take(3).map(|t| t.full_title()).collect::<Vec<_>>()),
Err(e) => println!("recently played: ERROR {e}"),
}
match client.similar_tracks("85507364").await {
Ok(s) => println!("similar: {} {:?}", s.len(), s.iter().take(3).map(|t| format!("{} — {}", t.artist_line(), t.title)).collect::<Vec<_>>()),
Err(e) => println!("similar: ERROR {e}"),
}
match client.artist_clips(675068).await {
Ok(c) => println!(
"artist clips: {} {:?}",
c.len(),
c.iter().take(3).map(|c| format!("{} {} — {} ({}s)", c.id, c.artist_line(), c.title, c.duration.as_secs())).collect::<Vec<_>>()
),
Err(e) => println!("artist clips: ERROR {e}"),
}
match client.liked_clips().await {
Ok(c) => println!("liked clips: {} {:?}", c.len(), c.iter().take(3).map(|c| &c.title).collect::<Vec<_>>()),
Err(e) => println!("liked clips: ERROR {e}"),
}
match client.suggest("зем").await {
Ok(s) => println!("suggest: {:?}", s.iter().take(5).collect::<Vec<_>>()),
Err(e) => println!("suggest: ERROR {e}"),
}
}