//! 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::>(), 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::>()); 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::>()), 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::>()), 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::()), 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::>()), 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::>() ), 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.id).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) ), 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.id).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) ), 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::>()), 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::>()), 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::>() ), 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::>()), Err(e) => println!("liked clips: ERROR {e}"), } match client.suggest("зем").await { Ok(s) => println!("suggest: {:?}", s.iter().take(5).collect::>()), Err(e) => println!("suggest: ERROR {e}"), } }