Crate lastfm

lastfm is an async Rust client to fetch your Last.fm listening history or the track you are currently playing

Installation

Add the following to your Cargo.toml:

[dependencies]
lastfm = "*"

Replace the * with the actual version you want to use.

Alternatively you can run:

cargo add lastfm

Usage

To use this library you will need a Last.fm account and an API key. You can get one by registering an application. If you have already registered an application, you can find your API key in the API settings.

Create a new client

If you have your API key exposed through the LASTFM_API_KEY environment variable, you can use the from_env method:

let client = Client::<String, &str>::from_env("YOUR_USERNAME");

Note: this method will panic if LASTFM_API_KEY is not set.

Alternatively, you can use try_from_env which will return a Result.

let maybe_client = Client::<String, &str>::try_from_env("YOUR_USERNAME");
match maybe_client {
  Ok(client) => {
    // do something with the client
  }
  Err(e) => {
    // handle error
  }
}

Finally, for more advanced configurations you can use a Client::builder():

let client = Client::builder().api_key("YOUR_API_KEY").username("YOUR_USERNAME").build();

Fetch the track you are currently playing

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
  let client = Client::builder().api_key("YOUR_API_KEY").username("YOUR_USERNAME").build();
  let now_playing = client.now_playing().await?;
  if let Some(track) = now_playing {
    println!("Now playing: {} - {}", track.artist.name, track.name);
  }

  Ok(())
}

Fetch your listening history

Note: You will need the futures-util crate to use the Stream returned by all_tracks.

use futures_util::pin_mut;
use futures_util::stream::StreamExt;
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
  let client = Client::builder().api_key("YOUR_API_KEY").username("YOUR_USERNAME").build();
  let tracks = client.all_tracks().await?;
  println!("Total tracks: {}", tracks.total_tracks);

   let recent_tracks = tracks.into_stream();
   pin_mut!(recent_tracks); // needed for iteration
   while let Some(track) = recent_tracks.next().await {
       match track {
           Ok(track) => {
               println!(
                   "{}: {} - {}",
                   track.date.to_rfc2822(),
                   track.artist.name,
                   track.name
               );
           }
           Err(e) => {
               println!("Error fetching data: {:?}", e);
           }
       }
   }
   Ok(())
}

Re-exports

pub use client::Client;

pub use reqwest;

Modules

artist

Artist

client

Client

error_response

Error response

errors

Errors

imageset

Image set

lfm_date

Last.fm Date

recent_tracks_page

Recent tracks page

retry_strategy

Retry strategy

track

Tracks