lastfm-edit 6.0.1

Rust crate for programmatic access to Last.fm's scrobble editing functionality via web scraping
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

#[path = "shared/common.rs"]
mod common;

use lastfm_edit::Result;

#[tokio::main]
async fn main() -> Result<()> {
    let client = common::setup_client().await?;

    let artist = "Radiohead";
    let album = "In Rainbows";

    println!("=== Debug Album URL Test ===\n");
    println!("🔍 Testing URL construction for album tracks...");
    println!("Artist: {artist}");
    println!("Album: {album}\n");

    // First, let's see if the artist has albums at all
    println!("1. Testing artist albums page...");
    match client.get_artist_albums_page(artist, 1).await {
        Ok(albums_page) => {
            println!("✅ Found {} albums for {artist}", albums_page.albums.len());
            for (i, album_item) in albums_page.albums.iter().enumerate().take(5) {
                println!(
                    "   [{i}] '{}' ({} plays)",
                    album_item.name, album_item.playcount
                );
            }
        }
        Err(e) => {
            println!("❌ Error getting albums: {e}");
            return Ok(());
        }
    }

    println!("\n2. Testing album tracks page...");
    match client.get_album_tracks_page(album, artist, 1).await {
        Ok(tracks_page) => {
            println!(
                "✅ Album tracks page returned {} tracks",
                tracks_page.tracks.len()
            );
            println!("   Has next page: {}", tracks_page.has_next_page);
            println!("   Total pages: {:?}", tracks_page.total_pages);
            for (i, track) in tracks_page.tracks.iter().enumerate().take(10) {
                println!(
                    "   [{i}] '{}' - Album: '{}'",
                    track.name,
                    track.album.as_deref().unwrap_or("(none)")
                );
            }
        }
        Err(e) => {
            println!("❌ Error getting album tracks: {e}");
        }
    }

    // Let's also test with an album we know exists from the albums list
    println!("\n3. Testing with first album from albums list...");
    match client.get_artist_albums_page(artist, 1).await {
        Ok(albums_page) => {
            if let Some(first_album) = albums_page.albums.first() {
                println!("Testing with album: '{}'", first_album.name);
                match client
                    .get_album_tracks_page(&first_album.name, artist, 1)
                    .await
                {
                    Ok(tracks_page) => {
                        println!(
                            "✅ Found {} tracks for '{}'",
                            tracks_page.tracks.len(),
                            first_album.name
                        );
                        for (i, track) in tracks_page.tracks.iter().enumerate().take(5) {
                            println!("   [{i}] '{}'", track.name);
                        }
                    }
                    Err(e) => {
                        println!("❌ Error: {e}");
                    }
                }
            } else {
                println!("No albums found in list");
            }
        }
        Err(e) => {
            println!("❌ Error getting albums: {e}");
        }
    }

    Ok(())
}