Struct LastFmEditClientImpl 

pub struct LastFmEditClientImpl { /* private fields */ }

Implementations

impl LastFmEditClientImpl

pub fn from_session( client: Box<dyn HttpClient + Send + Sync>, session: LastFmEditSession, ) -> Self

pub fn from_session_with_rate_limit_patterns( client: Box<dyn HttpClient + Send + Sync>, session: LastFmEditSession, rate_limit_patterns: Vec<String>, ) -> Self

pub async fn login_with_credentials( client: Box<dyn HttpClient + Send + Sync>, username: &str, password: &str, ) -> Result<Self>

pub fn from_session_with_client_config( client: Box<dyn HttpClient + Send + Sync>, session: LastFmEditSession, config: ClientConfig, ) -> Self

pub async fn login_with_credentials_and_client_config( client: Box<dyn HttpClient + Send + Sync>, username: &str, password: &str, config: ClientConfig, ) -> Result<Self>

pub fn from_session_with_config( client: Box<dyn HttpClient + Send + Sync>, session: LastFmEditSession, retry_config: RetryConfig, rate_limit_config: RateLimitConfig, ) -> Self

pub async fn login_with_credentials_and_config( client: Box<dyn HttpClient + Send + Sync>, username: &str, password: &str, retry_config: RetryConfig, rate_limit_config: RateLimitConfig, ) -> Result<Self>

pub fn get_session(&self) -> LastFmEditSession

pub fn cancel(&self)

pub fn reset_cancel(&self)

pub fn is_cancelled(&self) -> bool

pub fn with_shared_broadcaster( &self, client: Box<dyn HttpClient + Send + Sync>, ) -> Self

pub fn non_blocking(&self) -> Self

Get a non-blocking clone of this client that returns errors instead of sleeping when rate limited.

The returned client shares this client’s HTTP client, session, event broadcaster, and cancellation state (all Arc/channel-shared on plain clone()); only its ClientConfig::rate_limit_behavior differs, set to RateLimitBehavior::ReturnError. Any events it emits (including RateLimited) are visible to subscribers of the original client, and both clients report the same rate_limit_state.

Intended usage: caller-managed queues

Instead of the client parking internally with backoff sleeps, operations on the non-blocking clone fail fast with LastFmError::RateLimit. A caller building its own work queue can:

1. Attempt an operation; on Err(LastFmError::RateLimit { .. }), requeue it.
2. Watch watch_rate_limit_state for the RateLimitState::RateLimited “paused until T” estimate.
3. Schedule its own retry once the state returns to RateLimitState::Ready (or until_estimate passes).

pub fn username(&self) -> String

pub async fn validate_session(&self) -> bool

pub async fn delete_scrobble( &self, artist_name: &str, track_name: &str, timestamp: u64, ) -> Result<bool>

pub fn subscribe(&self) -> ClientEventReceiver

pub fn latest_event(&self) -> Option<ClientEvent>

pub fn rate_limit_state(&self) -> RateLimitState

Get the current rate-limit state snapshot.

Shared across all clones of this client (they share the same broadcaster), so a monitoring task can hold a clone and observe rate limiting caused by any of them.

pub fn watch_rate_limit_state(&self) -> RateLimitStateWatcher

Get a watch receiver tracking the rate-limit state. Await .changed() to react to pause/resume transitions without polling.

pub async fn get_recent_scrobbles(&self, page: u32) -> Result<Vec<Track>>

pub async fn get_recent_tracks_page(&self, page: u32) -> Result<TrackPage>

pub async fn find_recent_scrobble_for_track( &self, track_name: &str, artist_name: &str, max_pages: u32, ) -> Result<Option<Track>>

pub async fn edit_scrobble(&self, edit: &ScrobbleEdit) -> Result<EditResponse>

pub async fn edit_scrobble_single( &self, exact_edit: &ExactScrobbleEdit, max_retries: u32, ) -> Result<EditResponse>

pub async fn load_edit_form_values_internal( &self, track_name: &str, artist_name: &str, ) -> Result<Vec<ExactScrobbleEdit>>

👎Deprecated:

use get_scrobble_edit_variations

Deprecated alias for get_scrobble_edit_variations.

pub async fn get_scrobble_edit_variations( &self, track_name: &str, artist_name: &str, ) -> Result<Vec<ExactScrobbleEdit>>

Discover every album variation of a track in the user’s library, fully populated from the scrobble edit forms on the track’s library page.

This scrapes /user/{user}/library/music/{artist}/_/{track} (following pagination up to a few pages) and returns one ExactScrobbleEdit per unique (album, album artist) combination, with all original fields — including the authoritative album_artist_name_original — taken from the hidden form inputs.

pub async fn get_artist_tracks_page( &self, artist: &str, page: u32, ) -> Result<TrackPage>

pub fn extract_tracks_from_document( &self, document: &Html, artist: &str, album: Option<&str>, ) -> Result<Vec<Track>>

pub fn parse_tracks_page( &self, document: &Html, page_number: u32, artist: &str, album: Option<&str>, ) -> Result<TrackPage>

pub async fn get(&self, url: &str) -> Result<Response>

pub async fn get_artists_page(&self, page: u32) -> Result<ArtistPage>

pub async fn get_artist_albums_page( &self, artist: &str, page: u32, ) -> Result<AlbumPage>

pub async fn get_album_tracks_page( &self, album_name: &str, artist_name: &str, page: u32, ) -> Result<TrackPage>

pub async fn search_tracks_page( &self, query: &str, page: u32, ) -> Result<TrackPage>

pub async fn search_albums_page( &self, query: &str, page: u32, ) -> Result<AlbumPage>

pub async fn search_artists_page( &self, query: &str, page: u32, ) -> Result<ArtistPage>

pub fn api_client(&self) -> Option<LastFmApiClientImpl>

Construct a standalone LastFmApiClientImpl from this edit client’s fields.

Returns None if no API key is configured.

pub fn inner_client(&self) -> Arc<dyn HttpClient + Send + Sync>

Expose the inner HTTP client for advanced use cases like VCR cassette management

Trait Implementations

impl Clone for LastFmEditClientImpl

fn clone(&self) -> LastFmEditClientImpl

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl LastFmApiClient for LastFmEditClientImpl

fn api_get_recent_tracks_page_in_range<'life0, 'async_trait>( &'life0 self, page: u32, from: Option<u64>, to: Option<u64>, ) -> Pin<Box<dyn Future<Output = Result<TrackPage>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Fetch a single page of the user’s recent tracks restricted to a unix-timestamp window.

fn api_get_recent_tracks_page<'life0, 'async_trait>( &'life0 self, page: u32, ) -> Pin<Box<dyn Future<Output = Result<TrackPage>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Fetch a single page of the user’s recent tracks via the JSON API.

impl LastFmBaseClient for LastFmEditClientImpl

fn get_artists_page<'life0, 'async_trait>( &'life0 self, page: u32, ) -> Pin<Box<dyn Future<Output = Result<ArtistPage>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get a page of artists from the user’s library.

fn get_artist_tracks_page<'life0, 'life1, 'async_trait>( &'life0 self, artist: &'life1 str, page: u32, ) -> Pin<Box<dyn Future<Output = Result<TrackPage>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get a page of tracks from the user’s library for the specified artist.

fn get_artist_albums_page<'life0, 'life1, 'async_trait>( &'life0 self, artist: &'life1 str, page: u32, ) -> Pin<Box<dyn Future<Output = Result<AlbumPage>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get a page of albums from the user’s library for the specified artist.

fn get_album_tracks_page<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, album_name: &'life1 str, artist_name: &'life2 str, page: u32, ) -> Pin<Box<dyn Future<Output = Result<TrackPage>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get a page of tracks from a specific album in the user’s library.

fn get_recent_tracks_page<'life0, 'async_trait>( &'life0 self, page: u32, ) -> Pin<Box<dyn Future<Output = Result<TrackPage>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Get a page of tracks from the user’s recent listening history.

fn search_tracks_page<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 str, page: u32, ) -> Pin<Box<dyn Future<Output = Result<TrackPage>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get a single page of track search results from the user’s library.

fn search_albums_page<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 str, page: u32, ) -> Pin<Box<dyn Future<Output = Result<AlbumPage>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get a single page of album search results from the user’s library.

fn search_artists_page<'life0, 'life1, 'async_trait>( &'life0 self, query: &'life1 str, page: u32, ) -> Pin<Box<dyn Future<Output = Result<ArtistPage>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Get a single page of artist search results from the user’s library.

fn username(&self) -> String

Get the currently authenticated username.

fn get_session(&self) -> LastFmEditSession

Extract the current session state for persistence.

fn subscribe(&self) -> ClientEventReceiver

Subscribe to internal client events.

fn latest_event(&self) -> Option<ClientEvent>

Get the latest client event without subscribing to future events.

fn rate_limit_state(&self) -> RateLimitState

Get the current rate-limit state snapshot.

fn watch_rate_limit_state(&self) -> RateLimitStateWatcher

Get a watch receiver tracking rate-limit state transitions.

fn validate_session<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = bool> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Validate if the current session is still working.

fn find_recent_scrobble_for_track<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, track_name: &'life1 str, artist_name: &'life2 str, max_pages: u32, ) -> Pin<Box<dyn Future<Output = Result<Option<Track>>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Find the most recent scrobble for a specific track.

fn cancel(&self)

Request cooperative cancellation of ongoing operations (best-effort).

fn reset_cancel(&self)

Clear the cancellation request so future operations can run again.

fn is_cancelled(&self) -> bool

Whether cancellation has been requested.

impl LastFmEditClient for LastFmEditClientImpl

fn edit_scrobble<'life0, 'life1, 'async_trait>( &'life0 self, edit: &'life1 ScrobbleEdit, ) -> Pin<Box<dyn Future<Output = Result<EditResponse>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Edit scrobbles by discovering and updating all matching instances.

fn edit_scrobble_single<'life0, 'life1, 'async_trait>( &'life0 self, exact_edit: &'life1 ExactScrobbleEdit, max_retries: u32, ) -> Pin<Box<dyn Future<Output = Result<EditResponse>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Edit a single scrobble with complete information and retry logic.

fn delete_scrobble<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, artist_name: &'life1 str, track_name: &'life2 str, timestamp: u64, ) -> Pin<Box<dyn Future<Output = Result<bool>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Delete a scrobble by its identifying information.

fn get_scrobble_edit_variations<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, track_name: &'life1 str, artist_name: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<ExactScrobbleEdit>>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Get every album variation of a track from the user’s library, fully populated from the scrobble edit forms on the track’s library page.

fn discover_scrobbles( &self, edit: ScrobbleEdit, ) -> Box<dyn AsyncDiscoveryIterator<ExactScrobbleEdit>>

Create an incremental discovery iterator for scrobble editing.

fn artists(&self) -> Box<dyn AsyncPaginatedIterator<Artist>>

Create an iterator for browsing all artists in the user’s library.

fn artist_tracks(&self, artist: &str) -> Box<dyn AsyncPaginatedIterator<Track>>

Create an iterator for browsing an artist’s tracks from the user’s library.

fn artist_tracks_direct( &self, artist: &str, ) -> Box<dyn AsyncPaginatedIterator<Track>>

Create an iterator for browsing an artist’s tracks directly using the paginated endpoint.

fn artist_albums(&self, artist: &str) -> Box<dyn AsyncPaginatedIterator<Album>>

Create an iterator for browsing an artist’s albums from the user’s library.

fn album_tracks( &self, album_name: &str, artist_name: &str, ) -> Box<dyn AsyncPaginatedIterator<Track>>

Create an iterator for browsing tracks from a specific album.

fn recent_tracks(&self) -> Box<dyn AsyncPaginatedIterator<Track>>

Create an iterator for browsing the user’s recent tracks/scrobbles.

fn recent_tracks_from_page( &self, starting_page: u32, ) -> Box<dyn AsyncPaginatedIterator<Track>>

Create an iterator for browsing the user’s recent tracks starting from a specific page.

fn search_tracks(&self, query: &str) -> Box<dyn AsyncPaginatedIterator<Track>>

Create an iterator for searching tracks in the user’s library.

fn search_albums(&self, query: &str) -> Box<dyn AsyncPaginatedIterator<Album>>

Create an iterator for searching albums in the user’s library.

fn search_artists(&self, query: &str) -> Box<dyn AsyncPaginatedIterator<Artist>>

Create an iterator for searching artists in the user’s library.

fn discover_scrobble_edit_variations<'life0, 'life1, 'async_trait>( &'life0 self, edit: &'life1 ScrobbleEdit, ) -> Pin<Box<dyn Future<Output = Result<Vec<ExactScrobbleEdit>>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Discover all scrobble edit variations based on the provided ScrobbleEdit template.

fn resolve_album_artist<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, artist: &'life1 str, track: &'life2 str, album: Option<&'life3 str>, ) -> Pin<Box<dyn Future<Output = Result<Option<String>>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Resolve the authoritative album artist for a scrobbled track.

fn edit_album<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, old_album_name: &'life1 str, new_album_name: &'life2 str, artist_name: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<EditResponse>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Edit album metadata by updating scrobbles with new album name.

fn edit_artist<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, old_artist_name: &'life1 str, new_artist_name: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<EditResponse>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Edit artist metadata by updating scrobbles with new artist name.

fn edit_artist_for_track<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, track_name: &'life1 str, old_artist_name: &'life2 str, new_artist_name: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<EditResponse>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Edit artist metadata for a specific track only.

fn edit_artist_for_album<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, album_name: &'life1 str, old_artist_name: &'life2 str, new_artist_name: &'life3 str, ) -> Pin<Box<dyn Future<Output = Result<EditResponse>> + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Edit artist metadata for all tracks in a specific album.