Struct LastFmEditClientImpl

pub struct LastFmEditClientImpl { /* private fields */ }

Main implementation for interacting with Last.fm’s web interface.

This implementation provides methods for browsing user libraries and editing scrobble data through web scraping. It requires a valid authenticated session to function.

Implementations

impl LastFmEditClientImpl

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

Create a new LastFmEditClient from an authenticated session.

This is the primary constructor for creating a client. You must obtain a valid session first using the login function.

Arguments

• client - Any HTTP client implementation that implements HttpClient
• session - A valid authenticated session

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

Create a new LastFmEditClient from an authenticated session with custom rate limit patterns.

This is useful for testing or customizing rate limit detection.

Arguments

• client - Any HTTP client implementation
• session - A valid authenticated session
• rate_limit_patterns - Text patterns that indicate rate limiting in responses

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

Create a new authenticated LastFmEditClient by logging in with username and password.

This is a convenience method that combines login and client creation into one step.

Arguments

• client - Any HTTP client implementation
• username - Last.fm username or email
• password - Last.fm password

Returns

Returns an authenticated client on success, or LastFmError::Auth on failure.

pub fn get_session(&self) -> LastFmEditSession

Extract the current session state for persistence.

pub fn restore_session(&self, session: LastFmEditSession)

Restore session state from a previously saved session.

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

Create a new client that shares the same session and event broadcaster.

This is useful when you want multiple HTTP client instances but want them to share the same authentication state and event broadcasting system.

Arguments

• client - A new HTTP client implementation

Returns

Returns a new client that shares the session and broadcaster with this client.

pub fn username(&self) -> String

Get the currently authenticated username.

Returns an empty string if not logged in.

pub async fn validate_session(&self) -> bool

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

Delete a scrobble by its identifying information.

pub fn subscribe(&self) -> ClientEventReceiver

Subscribe to internal client events.

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

Get the latest client event without subscribing to future events.

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

Fetch recent scrobbles from the user’s listening history This gives us real scrobble data with timestamps for editing

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

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

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

Find the most recent scrobble for a specific track This searches through recent listening history to find real scrobble data

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>

Edit a single scrobble with retry logic, returning a single-result EditResponse.

This method takes a fully-specified ExactScrobbleEdit and performs a single edit operation. Unlike edit_scrobble, this method does not perform enrichment or multiple edits - it edits exactly one scrobble instance.

Arguments

• exact_edit - A fully-specified edit with all required fields populated
• max_retries - Maximum number of retry attempts for rate limiting

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

Load prepopulated form values for editing a specific track This extracts scrobble data directly from the track page forms

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>>

Extract tracks from HTML document (delegates to parser)

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

Parse tracks page (delegates to parser)

pub fn parse_recent_scrobbles(&self, document: &Html) -> Result<Vec<Track>>

Parse recent scrobbles from HTML document (for testing)

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

Make an HTTP GET request with authentication and retry logic

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

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 LastFmEditClient for LastFmEditClientImpl

fn username(&self) -> String

Get the currently authenticated username.

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

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

Fetch recent scrobbles from the user’s listening history.

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 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 get_session(&self) -> LastFmEditSession

Extract the current session state for persistence.

fn restore_session(&self, session: LastFmEditSession)

Restore session state from a previously saved session.

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 discover_scrobbles( &self, edit: ScrobbleEdit, ) -> Box<dyn AsyncDiscoveryIterator<ExactScrobbleEdit>>

Create an incremental discovery iterator for scrobble editing.

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 artist_tracks(&self, artist: &str) -> ArtistTracksIterator

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

fn artist_albums(&self, artist: &str) -> ArtistAlbumsIterator

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

fn album_tracks( &self, album_name: &str, artist_name: &str, ) -> AlbumTracksIterator

Create an iterator for browsing tracks from a specific album.

fn recent_tracks(&self) -> RecentTracksIterator

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

fn recent_tracks_from_page(&self, starting_page: u32) -> RecentTracksIterator

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

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 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_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 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 get_album_tracks<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, album_name: &'life1 str, artist_name: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Vec<Track>>> + 'async_trait>>

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

Get tracks from a specific album page.

fn find_scrobble_by_timestamp<'life0, 'async_trait>( &'life0 self, timestamp: u64, ) -> Pin<Box<dyn Future<Output = Result<Track>> + 'async_trait>>

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

Find a scrobble by its timestamp in recent scrobbles.

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.