Ytmapi Rs

https://docs.rs/ytmapi-rs/latest/
Admin
A Rust library for interacting with YouTube Music's internal API, providing functionalities for...
Tokens:699,608
Snippets:5,448
Trust Score:9.7
Update:1 week ago
Show doc for...
Tokens:
Raw
### Get library upload albums example

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html?search=

Shows how to get a list of all uploaded albums in your Library using get_library_upload_albums.

```rust
/// Gets a list of all uploaded albums in your Library.
/// # Additional functionality
/// See [`GetLibraryUploadAlbumsQuery`] and [`YtMusic.query()`]
/// for more ways to construct and run.
///
/// [`YtMusic.query()`]: crate::YtMusic::query
/// [GetLibraryUploadAlbumsQuery]: crate::query::GetLibraryUploadAlbumsQuery
///
/// ```no_run
/// # async {
/// let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
///     .await
///     .unwrap();
/// yt.get_library_upload_albums().await
/// # };
/// ```
```

--------------------------------

### Get library upload artists example

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html?search=

Shows how to get a list of all uploaded artists in your Library using get_library_upload_artists.

```rust
/// Gets a list of all uploaded artists in your Library.
/// # Additional functionality
/// See [`GetLibraryUploadArtistsQuery`] and [`YtMusic.query()`]
/// for more ways to construct and run.
///
/// [`YtMusic.query()`]: crate::YtMusic::query
/// [GetLibraryUploadArtistsQuery]: crate::query::GetLibraryUploadArtistsQuery
///
/// ```no_run
/// # async {
/// let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
///     .await
///     .unwrap();
/// yt.get_library_upload_artists().await
/// # };
/// ```
```

--------------------------------

### Get library upload albums example

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Shows how to retrieve a list of all uploaded albums in the user's Library. Requires a logged-in YtMusic instance. The example calls get_library_upload_albums() and awaits the result.

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
    .await
    .unwrap();
yt.get_library_upload_albums().await
```

--------------------------------

### Get library upload artists example

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Shows how to retrieve a list of all uploaded artists in the user's Library. Requires a logged-in YtMusic instance. The example calls get_library_upload_artists() and awaits the result.

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
    .await
    .unwrap();
yt.get_library_upload_artists().await
```

--------------------------------

### Get library upload songs example

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Shows how to retrieve a list of all uploaded songs in the user's Library. Requires a logged-in YtMusic instance. The example calls get_library_upload_songs() and awaits the result.

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
    .await
    .unwrap();
yt.get_library_upload_songs().await
```

--------------------------------

### query usage example

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/lib.rs.html?search=

Shows how to use the query method to run a query and get a typed output. Uses an empty cookie and asserts the first result's artist is 'The Beatles'.

```rust
# async {
let yt = ytmapi_rs::YtMusic::from_cookie("").await?;
let query = ytmapi_rs::query::SearchQuery::new("Beatles")
    .with_filter(ytmapi_rs::query::search::ArtistsFilter);
let result = yt.query(query).await?;
assert_eq!(result[0].artist, "The Beatles");
# Ok::<(), ytmapi_rs::Error>(())
# };

```

--------------------------------

### Get mood playlists with get_mood_playlists

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Returns a list of playlists for a given mood category. The example retrieves mood categories and then gets playlists for the first category's params.

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
    .await
    .unwrap();
let results = yt.get_mood_categories().await.unwrap();
yt.get_mood_playlists(&results[0].mood_categories[0].params)
    .await
```

--------------------------------

### and_then example function

Source: https://docs.rs/ytmapi-rs/latest/ytmapi_rs/error/type.Result.html

Example function for and_then, showing control flow based on Result values.

```rust
fn sq_then_to_string(x: u32) -> Result<String, &'static str> {
    x.checked_mul(x).map(|sq| sq.to_string()).ok_or("overflowed")
}
```

--------------------------------

### ytmapi_rs library documentation with usage examples

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/lib.rs.html?search=u32+-%3E+bool

Library-level documentation comments for ytmapi_rs, including three usage examples: unauthenticated, cookie-file authenticated with song upload, and OAuth authenticated with builder reuse. The unauthenticated example notes that not all queries are supported. The OAuth example requires environment variables YOUTUI_OAUTH_CLIENT_ID and YOUTUI_OAUTH_CLIENT_SECRET, and recommends saving the token for reuse until expiry.

```rust
//! # ytmapi_rs
//! Library into YouTube Music's internal API.
//! ## Examples
//! For additional examples using builder, see [`builder`] module.
//! ### Unauthenticated usage - note, not all queries supported.
//! ```no_run
//! #[tokio::main]
//! pub async fn main() -> Result<(), ytmapi_rs::Error> {
//!     let yt = ytmapi_rs::YtMusic::new_unauthenticated().await?;
//!     yt.get_search_suggestions("Beatles").await?;
//!     let result = yt.get_search_suggestions("Beatles").await?;
//!     println!("{:?}", result);
//!     Ok(())
//! }
//! ```
//! ### Basic authenticated usage with a pre-created cookie file, demonstrating uploading a song.
//! ```no_run
//! #[tokio::main]
//! pub async fn main() -> Result<(), ytmapi_rs::Error> {
//!     let cookie_path = std::path::Path::new("./cookie.txt");
//!     let yt = ytmapi_rs::YtMusic::from_cookie_file(cookie_path).await?;
//!     yt.get_search_suggestions("Beatles").await?;
//!     let result = yt.get_search_suggestions("Beatles").await?;
//!     println!("{:?}", result);
//!     assert_eq!(
//!         yt.upload_song("my_song_to_upload.mp3").await.unwrap(),
//!         ytmapi_rs::common::ApiOutcome::Success
//!     );
//!     Ok(())
//! }
//! ```
//! ### OAuth authenticated usage, using the workflow, and builder method to re-use the `Client`.
//! ```no_run
//! #[tokio::main]
//! pub async fn main() -> Result<(), ytmapi_rs::Error> {
//!     let client = ytmapi_rs::Client::new().unwrap();
//!     // A Client ID and Client Secret must be provided - see `youtui` README.md.
//!     // In this example, I assume they were put in environment variables beforehand.
//!     let client_id = std::env::var("YOUTUI_OAUTH_CLIENT_ID").unwrap();
//!     let client_secret = std::env::var("YOUTUI_OAUTH_CLIENT_SECRET").unwrap();
//!     let (code, url) = ytmapi_rs::generate_oauth_code_and_url(&client, &client_id).await?;
//!     println!("Go to {url}, finish the login flow, and press enter when done");
//!     let mut _buf = String::new();
//!     let _ = std::io::stdin().read_line(&mut _buf);
//!     let token =
//!         ytmapi_rs::generate_oauth_token(&client, code, client_id, client_secret).await?;
//!     // NOTE: The token can be re-used until it expires, and refreshed once it has,
//!     // so it's recommended to save it to a file here.
//!     let yt = ytmapi_rs::YtMusicBuilder::new_with_client(client)
//!         .with_auth_token(token)
//!         .build()
//!         .unwrap();
//!     let result = yt.get_search_suggestions("Beatles").await?;
//!     println!("{:?}", result);
//!     Ok(())
//! }
//! ```
```

--------------------------------

### Get podcast channel with get_channel

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Gets information about a Channel of Podcasts. The example searches for podcasts, gets the first podcast, and then retrieves its channel.

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
    .await
    .unwrap();
let podcasts = yt.search_podcasts("Rustacean").await.unwrap();
let podcast = yt.get_podcast(&podcasts[0].podcast_id).await.unwrap();
yt.get_channel(podcast.channels[0].id.as_ref().unwrap())
    .await
```

--------------------------------

### Usage example for generate_browser_token

Source: https://docs.rs/ytmapi-rs/latest/ytmapi_rs/fn.generate_browser_token.html?search=

Shows how to call generate_browser_token with a new Client and a fake cookie. The example asserts that the returned error is of kind ErrorKind::Header.

```rust
let client = ytmapi_rs::Client::new().unwrap();
let cookie = "FAKE COOKIE";
let token = ytmapi_rs::generate_browser_token(&client, cookie).await;
assert!(matches!(
    token.unwrap_err().into_kind(),
    ytmapi_rs::error::ErrorKind::Header
));
```

--------------------------------

### Usage example for generate_oauth_code_and_url

Source: https://docs.rs/ytmapi-rs/latest/ytmapi_rs/fn.generate_oauth_code_and_url.html

Shows how to create a Client, read the client ID from the YOUTUI_OAUTH_CLIENT_ID environment variable, and call the function to obtain the code and URL. The client ID must be provided; see the youtui README.md.

```rust
let client = ytmapi_rs::Client::new().unwrap();
// A Client ID must be provided - see `youtui` README.md.
// In this example, I assume it was put in an environment variable beforehand.
let client_id = std::env::var("YOUTUI_OAUTH_CLIENT_ID").unwrap();
let (code, url) = ytmapi_rs::generate_oauth_code_and_url(&client, client_id).await?;

```

--------------------------------

### Get song tracking URL with get_song_tracking_url

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Gets the 'SongTrackingUrl' for a song, used to add items to history via add_history_item(). The example searches for a song and retrieves its tracking URL.

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
    .await
    .unwrap();
let song = yt
    .search_songs("While My Guitar Gently Weeps")
    .await
    .unwrap()
    .into_iter()
    .next()
    .unwrap();
yt.get_song_tracking_url(song.video_id).await
```

--------------------------------

### ok example

Source: https://docs.rs/ytmapi-rs/latest/ytmapi_rs/error/type.Result.html

Demonstrates Result::ok, which converts a Result into an Option, returning Some(value) for Ok and None for Err.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.ok(), Some(2));

let x: Result<u32, &str> = Err("Nothing here");
assert_eq!(x.ok(), None);
```

--------------------------------

### Get mood categories with get_mood_categories

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Fetches 'Moods & Genres' categories. The example calls get_mood_categories.

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
    .await
    .unwrap();
yt.get_mood_categories().await
```

--------------------------------

### Edit playlist example

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html?search=

Shows how to make changes to a playlist by constructing an EditPlaylistQuery with a new title and description, then passing it to edit_playlist.

```rust
/// Makes changes to a playlist.
///  ```no_run
/// # async {
/// let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE").await.unwrap();
/// let playlists = yt.get_library_playlists()
///     .await
///     .unwrap();
/// let query = ytmapi_rs::query::EditPlaylistQuery::new_title(
///     &playlists[0].playlist_id,
///     "Better playlist title",
/// )
///     .with_new_description("Edited description");
/// yt.edit_playlist(query).await
/// # };
/// ```
```

--------------------------------

### CreatePlaylistQuery::new

Source: https://docs.rs/ytmapi-rs/latest/ytmapi_rs/query/playlist/create/struct.CreatePlaylistQuery.html?search=

Constructor for creating a new playlist query.

```APIDOC
## CreatePlaylistQuery::new

### Description
Creates a new playlist query with the given title, description, and privacy status.

### Method
Constructor

### Signature
```rust
pub fn new(
    title: &'a str,
    description: Option<&'a str>,
    privacy_status: PrivacyStatus,
) -> CreatePlaylistQuery<'a, BasicCreatePlaylist>
```

### Parameters
- **title** (`&'a str`) - Required - The title of the playlist.
- **description** (`Option<&'a str>`) - Optional - The description of the playlist.
- **privacy_status** (`PrivacyStatus`) - Required - The privacy status of the playlist.

### Returns
- `CreatePlaylistQuery<'a, BasicCreatePlaylist>` - A new playlist query instance.
```

--------------------------------

### Create a playlist

Source: https://docs.rs/ytmapi-rs/latest/ytmapi_rs/struct.YtMusic.html

Creates a new playlist. Requires the `simplified-queries` crate feature. The example builds a CreatePlaylistQuery with a title, no description, Public privacy, and a source playlist ID.

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE").await.unwrap();
let playlists = yt.search_featured_playlists("Heavy metal")
   .await
   .unwrap();
let query = ytmapi_rs::query::CreatePlaylistQuery::new(
   "My heavy metal playlist",
   None,
   ytmapi_rs::query::playlist::PrivacyStatus::Public,
)
   .with_source(&playlists[0].playlist_id);
yt.create_playlist(query).await
```

--------------------------------

### Implementation example - Incomplete (ParseFromContinuable for Date)

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/continuations.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows an incomplete example of implementing `ParseFromContinuable` for a `Date` struct, using `serde::Deserialize` and the `ytmapi_rs` types. The methods `parse_from_continuable` and `parse_continuation` are stubbed with `todo!()`. This is a starting point for implementing the trait for custom types.

```rust
//! This module contains the `ParseFromContinuable` trait, allowing streaming of
//! results that contain continuations.
//! # Implementation example - Incomplete
//! ```no_run
//! # struct GetDateQuery;
//! use serde::Deserialize;
//! use ytmapi_rs::common::ContinuationParams;
//! use ytmapi_rs::query::GetContinuationsQuery;
//!
//! #[derive(Debug, Deserialize)]
//! struct Date {
//!     date_string: String,
//!     date_timestamp: usize,
//! }
//! impl ytmapi_rs::continuations::ParseFromContinuable<GetDateQuery> for () {
//!     fn parse_from_continuable(
//!         p: ytmapi_rs::ProcessedResult<GetDateQuery>,
//!     ) -> ytmapi_rs::Result<(Self, Option<ContinuationParams<'static>>)> {
//!         todo!();
//!     }
//!     fn parse_continuation(
//!         p: ytmapi_rs::ProcessedResult<GetContinuationsQuery<'_, GetDateQuery>>,
//!     ) -> ytmapi_rs::Result<(Self, Option<ContinuationParams<'static>>)> {
//!         todo!();
//!     }
//! }
//! ```
```

--------------------------------

### Create a new playlist

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Creates a new playlist. The example searches for featured playlists to use as a source and creates a public playlist with a specified name.

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE").await.unwrap();
let playlists = yt.search_featured_playlists("Heavy metal")
    .await
    .unwrap();
let query = ytmapi_rs::query::CreatePlaylistQuery::new(
    "My heavy metal playlist",
    None,
    ytmapi_rs::query::playlist::PrivacyStatus::Public,
)
    .with_source(&playlists[0].playlist_id);
yt.create_playlist(query).await
```

--------------------------------

### Get search suggestions with get_search_suggestions

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Fetches search suggestions for a given query string. The example calls get_search_suggestions with "The Beat".

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
    .await
    .unwrap();
yt.get_search_suggestions("The Beat").await;
```

--------------------------------

### Basic usage with rustls and cookie file

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/builder.rs.html?search=u32+-%3E+bool

Example from the module documentation, conditionally built when the 'rustls' feature is enabled. It shows how to create a YtMusic instance using a pre-created cookie file and force rustls, then fetch search suggestions.

```rust
#[tokio::main]
pub async fn main() -> Result<(), ytmapi_rs::Error> {
    let cookie_path = std::path::Path::new("./cookie.txt");
    let yt = ytmapi_rs::builder::YtMusicBuilder::new_rustls_tls()
        .with_browser_token_cookie_file(cookie_path)
        .build()
        .await?;
    yt.get_search_suggestions("Beatles").await?;
    let result = yt.get_search_suggestions("Beatles").await?;
    println!("{:?}", result);
    Ok(())
}
```

--------------------------------

### Test get watch playlist query (incomplete)

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/parse/playlist.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Starts a test for GetWatchPlaylistQuery but the code is incomplete in the source, ending with an opening brace and no body.

```rust
#[tokio::test]
    async fn test_get_watch_playlist_query() {
```

--------------------------------

### podcasts.rs: Podcast query structs and implementations

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/query/podcasts.rs.html?search=std%3A%3Avec

Defines GetChannelQuery, GetChannelEpisodesQuery, GetPodcastQuery, GetEpisodeQuery, and GetNewEpisodesQuery with constructors and Query/PostQuery implementations. All use PostMethod and the 'browse' path. GetNewEpisodesQuery uses a fixed browseId 'VLRDPN' for the NewEpisodes auto-playlist.

```rust
1use super::{PostMethod, PostQuery, Query};
2use crate::auth::AuthToken;
3use crate::common::{EpisodeID, PodcastChannelID, PodcastChannelParams, PodcastID};
4use crate::parse::{Episode, GetEpisode, GetPodcast, GetPodcastChannel};
5use serde_json::json;
6
7pub struct GetChannelQuery<'a> {
8    channel_id: PodcastChannelID<'a>,
9}
10pub struct GetChannelEpisodesQuery<'a> {
11    channel_id: PodcastChannelID<'a>,
12    podcast_channel_params: PodcastChannelParams<'a>,
13}
14pub struct GetPodcastQuery<'a> {
15    podcast_id: PodcastID<'a>,
16}
17pub struct GetEpisodeQuery<'a> {
18    episode_id: EpisodeID<'a>,
19}
20pub struct GetNewEpisodesQuery;
21
22// NOTE: This is technically the same page as the GetArtist page. It's possible
23// this could be generalised.
24impl<'a> GetChannelQuery<'a> {
25    pub fn new(channel_id: impl Into<PodcastChannelID<'a>>) -> Self {
26        Self {
27            channel_id: channel_id.into(),
28        }
29    }
30}
31impl<'a> GetChannelEpisodesQuery<'a> {
32    pub fn new(
33        channel_id: impl Into<PodcastChannelID<'a>>,
34        podcast_channel_params: impl Into<PodcastChannelParams<'a>>,
35    ) -> GetChannelEpisodesQuery<'a> {
36        GetChannelEpisodesQuery {
37            channel_id: channel_id.into(),
38            podcast_channel_params: podcast_channel_params.into(),
39        }
40    }
41}
42impl<'a> GetPodcastQuery<'a> {
43    pub fn new(podcast_id: impl Into<PodcastID<'a>>) -> Self {
44        Self {
45            podcast_id: podcast_id.into(),
46        }
47    }
48}
49impl<'a> GetEpisodeQuery<'a> {
50    pub fn new(episode_id: impl Into<EpisodeID<'a>>) -> Self {
51        Self {
52            episode_id: episode_id.into(),
53        }
54    }
55}
56
57impl<A: AuthToken> Query<A> for GetChannelQuery<'_> {
58    type Output = GetPodcastChannel;
59    type Method = PostMethod;
60}
61impl<A: AuthToken> Query<A> for GetChannelEpisodesQuery<'_> {
62    type Output = Vec<Episode>;
63    type Method = PostMethod;
64}
65impl<A: AuthToken> Query<A> for GetPodcastQuery<'_> {
66    type Output = GetPodcast;
67    type Method = PostMethod;
68}
69impl<A: AuthToken> Query<A> for GetEpisodeQuery<'_> {
70    type Output = GetEpisode;
71    type Method = PostMethod;
72}
73impl<A: AuthToken> Query<A> for GetNewEpisodesQuery {
74    type Output = Vec<Episode>;
75    type Method = PostMethod;
76}
77
78impl PostQuery for GetChannelQuery<'_> {
79    fn header(&self) -> serde_json::Map<String, serde_json::Value> {
80        FromIterator::from_iter([("browseId".into(), json!(self.channel_id))])
81    }
82    fn params(&self) -> std::vec::Vec<(&str, std::borrow::Cow<'_, str>)> {
83        vec![]
84    }
85    fn path(&self) -> &str {
86        "browse"
87    }
88}
89impl PostQuery for GetChannelEpisodesQuery<'_> {
90    fn header(&self) -> serde_json::Map<String, serde_json::Value> {
91        FromIterator::from_iter([
92            ("browseId".into(), json!(self.channel_id)),
93            ("params".into(), json!(self.podcast_channel_params)),
94        ])
95    }
96    fn params(&self) -> std::vec::Vec<(&str, std::borrow::Cow<'_, str>)> {
97        vec![]
98    }
99    fn path(&self) -> &str {
100        "browse"
101    }
102}
103// TODO: Continuations
104impl PostQuery for GetPodcastQuery<'_> {
105    fn header(&self) -> serde_json::Map<String, serde_json::Value> {
106        // TODO: Confirm if any parsing required
107        FromIterator::from_iter([("browseId".into(), json!(self.podcast_id))])
108    }
109    fn params(&self) -> std::vec::Vec<(&str, std::borrow::Cow<'_, str>)> {
110        vec![]
111    }
112    fn path(&self) -> &str {
113        "browse"
114    }
115}
116impl PostQuery for GetEpisodeQuery<'_> {
117    fn header(&self) -> serde_json::Map<String, serde_json::Value> {
118        // TODO: Confirm if any parsing required
119        FromIterator::from_iter([("browseId".into(), json!(self.episode_id))])
120    }
121    fn params(&self) -> std::vec::Vec<(&str, std::borrow::Cow<'_, str>)> {
122        vec![]
123    }
124    fn path(&self) -> &str {
125        "browse"
126    }
127}
128// Gets the NewEpisodes auto-playlist. In future there could be other similar
129// playlists, we can instead re-implement this as GetEpisodesPlaylist.
130impl PostQuery for GetNewEpisodesQuery {
131    fn header(&self) -> serde_json::Map<String, serde_json::Value> {
132        FromIterator::from_iter([("browseId".into(), json!("VLRDPN"))])
133    }
134    fn params(&self) -> std::vec::Vec<(&str, std::borrow::Cow<'_, str>)> {
135        vec![]
136    }
137    fn path(&self) -> &str {
138        "browse"
139    }
140}

```

--------------------------------

### Get playlist details with get_playlist_details

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Fetches information about a playlist using its ID. The example searches for featured playlists and then retrieves details for the first result.

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
    .await
    .unwrap();
let results = yt.search_featured_playlists("Heavy metal").await.unwrap();
yt.get_playlist_details(&results[0].playlist_id).await
```

--------------------------------

### Usage example: generate_oauth_token

Source: https://docs.rs/ytmapi-rs/latest/ytmapi_rs/fn.generate_oauth_token.html

Shows how to use `generate_oauth_token` in a complete OAuth flow. Requires a `Client` and environment variables `YOUTUI_OAUTH_CLIENT_ID` and `YOUTUI_OAUTH_CLIENT_SECRET`. The example prints a URL for the user to complete login, waits for Enter, then calls the function and asserts the token is OK.

```rust
let client = ytmapi_rs::Client::new().unwrap();
// A Client ID and Client Secret must be provided - see `youtui` README.md.
// In this example, I assume they were put in environment variables beforehand.
let client_id = std::env::var("YOUTUI_OAUTH_CLIENT_ID").unwrap();
let client_secret = std::env::var("YOUTUI_OAUTH_CLIENT_SECRET").unwrap();
let (code, url) = ytmapi_rs::generate_oauth_code_and_url(&client, &client_id).await?;
println!("Go to {url}, finish the login flow, and press enter when done");
let mut buf = String::new();
let _ = std::io::stdin().read_line(&mut buf);
let token = ytmapi_rs::generate_oauth_token(&client, code, client_id, client_secret).await;
assert!(token.is_ok());
```

--------------------------------

### Get library upload artist

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Retrieves all tracks for an uploaded artist in the user's library. The example obtains the artist ID from the first result of get_library_upload_artists().

```rust
/// # async {
/// let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
///     .await
///     .unwrap();
/// let artists = yt.get_library_upload_artists().await.unwrap();
/// yt.get_library_upload_artist(&artists[0].artist_id).await
/// # };
/// ```
```

--------------------------------

### Unauthenticated usage example

Source: https://docs.rs/ytmapi-rs/latest/index.html

Shows how to use the library without authentication. Note that not all queries are supported in this mode. The example creates a YtMusic instance, calls get_search_suggestions, and prints the result.

```rust
#[tokio::main]
pub async fn main() -> Result<(), ytmapi_rs::Error> {
    let yt = ytmapi_rs::YtMusic::new_unauthenticated().await?;
    yt.get_search_suggestions("Beatles").await?;
    let result = yt.get_search_suggestions("Beatles").await?;
    println!("{:?}", result);
    Ok(())
}
```

--------------------------------

### Get library upload album

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Retrieves all tracks for an uploaded album in the user's library. The example obtains the album ID from the first result of get_library_upload_albums().

```rust
/// let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
///     .await
///     .unwrap();
/// let albums = yt.get_library_upload_albums().await.unwrap();
/// yt.get_library_upload_album(&albums[0].album_id).await
/// # };
/// ```
```

--------------------------------

### Client constructors: new, new_rustls_tls, new_native_tls, new_from_reqwest_client

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/client.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides four ways to create a Client: default with reqwest's TLS, forced rustls (feature 'rustls'), forced native-tls (feature 'native-tls'), and reusing an existing reqwest::Client (feature 'reqwest').

```rust
impl Client {
    /// Utilises reqwest's default tls choice for the enabled set of options.
    pub fn new() -> Result<Self> {
        let inner = reqwest::Client::builder().build()?;
        Ok(Self { inner })
    }
    #[cfg(feature = "rustls")]
    #[cfg_attr(docsrs, doc(cfg(feature = "rustls")))]
    /// Force the use of rustls
    pub fn new_rustls_tls() -> Result<Self> {
        let inner = reqwest::Client::builder().use_rustls_tls().build()?;
        Ok(Self { inner })
    }
    #[cfg(feature = "native-tls")]
    #[cfg_attr(docsrs, doc(cfg(feature = "native-tls")))]
    /// Force the use of native-tls
    pub fn new_native_tls() -> Result<Self> {
        let inner = reqwest::Client::builder().use_native_tls().build()?;
        Ok(Self { inner })
    }
    #[cfg(feature = "reqwest")]
    #[cfg_attr(docsrs, doc(cfg(feature = "reqwest")))]
    /// Re-use a pre-existing reqwest::Client.
    pub fn new_from_reqwest_client(client: reqwest::Client) -> Self {
        Self { inner: client }
    }
}

```

--------------------------------

### Get taste profile with get_taste_profile

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Fetches suggested artists from the user's taste profile, which is used to update recommendations. The example simply calls get_taste_profile.

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
    .await
    .unwrap();
yt.get_taste_profile().await
```

--------------------------------

### raw_json_query usage example

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/lib.rs.html?search=

Shows how to use raw_json_query to get the raw JSON string from a search query. Requires a BrowserToken and a SearchQuery with an ArtistsFilter. The result is asserted to be non-empty.

```rust
use ytmapi_rs::auth::BrowserToken;

# async {
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE").await?;
let query = ytmapi_rs::query::SearchQuery::new("Beatles")
    .with_filter(ytmapi_rs::query::search::ArtistsFilter);
let result = yt.raw_json_query(query).await?;
assert!(result.len() != 0);
# Ok::<(), ytmapi_rs::Error>(())
# };

```

--------------------------------

### Get history with YtMusic::get_history

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Constructs a YtMusic instance from a cookie and retrieves the user's recently played history. The example is marked no_run and wrapped in an async block.

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
    .await
    .unwrap();
let results = yt.get_history().await;
```

--------------------------------

### Get library channels with YtMusic::get_library_channels

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Constructs a YtMusic instance from a cookie and retrieves the user's library channels. The example is marked no_run and wrapped in an async block.

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
    .await
    .unwrap();
let results = yt.get_library_channels().await;
```

--------------------------------

### CreatePlaylistQuery implementation (create.rs)

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/query/playlist/create.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Full Rust source for the create playlist query module. Defines CreatePlaylistQuery, helper structs, and trait implementations for building a playlist creation request.

```rust
1use super::PrivacyStatus;
2use crate::auth::AuthToken;
3use crate::common::{PlaylistID, VideoID};
4use crate::query::{PostMethod, PostQuery, Query};
5use serde_json::json;
6use std::borrow::Cow;
7
8pub trait CreatePlaylistType {
9    fn additional_header(&self) -> Option<(String, serde_json::Value)>;
10}
11
12/// A playlist can be created using a list of video ids, or as a copy of an
13/// existing playlist (but not both at the same time).
14#[derive(Debug, Clone, PartialEq)]
15pub struct CreatePlaylistQuery<'a, C: CreatePlaylistType> {
16    title: Cow<'a, str>,
17    description: Option<Cow<'a, str>>,
18    privacy_status: PrivacyStatus,
19    query_type: C,
20}
21
22/// Helper struct for CreatePlaylistQuery
23#[derive(Default, Debug, Clone, PartialEq)]
24pub struct BasicCreatePlaylist {}
25/// Helper struct for CreatePlaylistQuery
26#[derive(Default, Debug, Clone, PartialEq)]
27pub struct CreatePlaylistFromVideos<'a> {
28    video_ids: Vec<VideoID<'a>>,
29}
30/// Helper struct for CreatePlaylistQuery
31#[derive(Debug, Clone, PartialEq)]
32pub struct CreatePlaylistFromPlaylist<'a> {
33    source_playlist: PlaylistID<'a>,
34}
35
36impl CreatePlaylistType for BasicCreatePlaylist {
37    fn additional_header(&self) -> Option<(String, serde_json::Value)> {
38        None
39    }
40}
41impl CreatePlaylistType for CreatePlaylistFromVideos<'_> {
42    fn additional_header(&self) -> Option<(String, serde_json::Value)> {
43        Some(("videoIds".into(), json!(self.video_ids)))
44    }
45}
46impl CreatePlaylistType for CreatePlaylistFromPlaylist<'_> {
47    fn additional_header(&self) -> Option<(String, serde_json::Value)> {
48        Some(("sourcePlaylistId".into(), json!(self.source_playlist)))
49    }
50}
51
52impl<'a> CreatePlaylistQuery<'a, BasicCreatePlaylist> {
53    pub fn new(
54        title: &'a str,
55        description: Option<&'a str>,
56        privacy_status: PrivacyStatus,
57    ) -> CreatePlaylistQuery<'a, BasicCreatePlaylist> {
58        CreatePlaylistQuery {
59            title: title.into(),
60            description: description.map(|d| d.into()),
61            privacy_status,
62            query_type: BasicCreatePlaylist {},
63        }
64    }
65}
66
67impl<'a> CreatePlaylistQuery<'a, BasicCreatePlaylist> {
68    pub fn with_source<T: Into<PlaylistID<'a>>>(
69        self,
70        source_playlist: T,
71    ) -> CreatePlaylistQuery<'a, CreatePlaylistFromPlaylist<'a>> {
72        let CreatePlaylistQuery {
73            title,
74            description,
75            privacy_status,
76            ..
77        } = self;
78        CreatePlaylistQuery {
79            title,
80            description,
81            privacy_status,
82            query_type: CreatePlaylistFromPlaylist {
83                source_playlist: source_playlist.into(),
84            },
85        }
86    }
87}
88
89impl<'a> CreatePlaylistQuery<'a, BasicCreatePlaylist> {
90    pub fn with_video_ids(
91        self,
92        video_ids: impl IntoIterator<Item = VideoID<'a>>,
93    ) -> CreatePlaylistQuery<'a, CreatePlaylistFromVideos<'a>> {
94        let CreatePlaylistQuery {
95            title,
96            description,
97            privacy_status,
98            ..
99        } = self;
100        CreatePlaylistQuery {
101            title,
102            description,
103            privacy_status,
104            query_type: CreatePlaylistFromVideos {
105                video_ids: video_ids.into_iter().collect(),
106            },
107        }
108    }
109}
110
111impl<A: AuthToken, C: CreatePlaylistType> Query<A> for CreatePlaylistQuery<'_, C> {
112    type Output = PlaylistID<'static>;
113    type Method = PostMethod;
114}
115impl<C: CreatePlaylistType> PostQuery for CreatePlaylistQuery<'_, C> {
116    fn header(&self) -> serde_json::Map<String, serde_json::Value> {
117        // TODO: Confirm if processing required to remove 'VL' portion of playlistId
118        let serde_json::Value::Object(mut map) = json!({
119            "title" : self.title,
120            "privacyStatus" : self.privacy_status.to_string(),
121        }) else {
122            unreachable!()
123        };
124        if let Some(description) = &self.description {
125            // TODO: Process description to ensure it doesn't contain html. Google doesn't
126            // allow html.
127            // https://github.com/sigma67/ytmusicapi/blob/main/ytmusicapi/mixins/playlists.py#L311
128            map.insert("description".to_string(), description.as_ref().into());
129        }
130        if let Some(additional_header) = self.query_type.additional_header() {
131            map.insert(additional_header.0, additional_header.1);
132        }
133        map
134    }
135    fn path(&self) -> &str {
136        "playlist/create"
137    }
138    fn params(&self) -> Vec<(&str, Cow<'_, str>)> {
139        vec![]
140    }
141}

```

--------------------------------

### Get library podcasts with YtMusic::get_library_podcasts

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Constructs a YtMusic instance from a cookie and retrieves the user's library podcasts. The example is marked no_run and wrapped in an async block.

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
    .await
    .unwrap();
let results = yt.get_library_podcasts().await;
```

--------------------------------

### Basic authenticated usage with cookie file and song upload

Source: https://docs.rs/ytmapi-rs/latest/index.html

Demonstrates authenticated usage by loading a cookie file from './cookie.txt'. It performs a search suggestion query and uploads a song, asserting the upload returns ApiOutcome::Success.

```rust
#[tokio::main]
pub async fn main() -> Result<(), ytmapi_rs::Error> {
    let cookie_path = std::path::Path::new("./cookie.txt");
    let yt = ytmapi_rs::YtMusic::from_cookie_file(cookie_path).await?;
    yt.get_search_suggestions("Beatles").await?;
    let result = yt.get_search_suggestions("Beatles").await?;
    println!("{:?}", result);
    assert_eq!(
        yt.upload_song("my_song_to_upload.mp3").await.unwrap(),
        ytmapi_rs::common::ApiOutcome::Success
    );
    Ok(())
}
```

--------------------------------

### and_then example: using with metadata and Path

Source: https://docs.rs/ytmapi-rs/latest/ytmapi_rs/error/type.Result.html

Demonstrates and_then with std::fs::metadata and modified. Shows that on Windows, "/" maps to "C:\". The example asserts that the root path metadata succeeds and that a bad path fails with ErrorKind::NotFound.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

--------------------------------

### Get library albums with YtMusic::get_library_albums

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Constructs a YtMusic instance from a cookie and retrieves the user's library albums. The example is marked no_run and wrapped in an async block.

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
    .await
    .unwrap();
let results = yt.get_library_albums().await;
```

--------------------------------

### Get library songs with YtMusic::get_library_songs

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/simplified_queries.rs.html

Constructs a YtMusic instance from a cookie and retrieves the user's library songs. The example is marked no_run and wrapped in an async block.

```rust
let yt = ytmapi_rs::YtMusic::from_cookie("FAKE COOKIE")
    .await
    .unwrap();
let results = yt.get_library_songs().await;
```

--------------------------------

### PostQuery implementations for upload queries

Source: https://docs.rs/ytmapi-rs/latest/src/ytmapi_rs/query/upload.rs.html?search=u32+-%3E+bool

Implements Query and PostQuery for each upload query type. Each implementation defines the output type, method, header with browseId and optional params, and the path 'browse'. Auth is required for all.

```rust
// Auth required
impl<A: LoggedIn> Query<A> for GetLibraryUploadAlbumQuery<'_> {
    type Output = GetLibraryUploadAlbum;
    type Method = PostMethod;
}
impl PostQuery for GetLibraryUploadAlbumQuery<'_> {
    fn header(&self) -> serde_json::Map<String, serde_json::Value> {
        serde_json::Map::from_iter([("browseId".to_string(), json!(self.upload_album_id))])
    }
    fn params(&self) -> Vec<(&str, Cow<'_, str>)> {
        vec![]
    }
    fn path(&self) -> &str {
        "browse"
    }
}
// Auth required
impl<A: LoggedIn> Query<A> for GetLibraryUploadArtistQuery<'_> {
    type Output = Vec<TableListUploadSong>;
    type Method = PostMethod;
}
impl PostQuery for GetLibraryUploadArtistQuery<'_> {
    fn header(&self) -> serde_json::Map<String, serde_json::Value> {
        serde_json::Map::from_iter([("browseId".to_string(), json!(self.upload_artist_id))])
    }
    fn params(&self) -> Vec<(&str, Cow<'_, str>)> {
        vec![]
    }
    fn path(&self) -> &str {
        "browse"
    }
}
// Auth required
impl<A: LoggedIn> Query<A> for GetLibraryUploadSongsQuery {
    type Output = Vec<TableListUploadSong>;
    type Method = PostMethod;
}
impl PostQuery for GetLibraryUploadSongsQuery {
    fn header(&self) -> serde_json::Map<String, serde_json::Value> {
        let params = get_sort_order_params(&self.sort_order);
        if let Some(params) = params {
            serde_json::Map::from_iter([
                (
                    "browseId".to_string(),
                    json!("FEmusic_library_privately_owned_tracks"),
                ),
                ("params".to_string(), json!(params)),
            ])
        } else {
            serde_json::Map::from_iter([(
                "browseId".to_string(),
                json!("FEmusic_library_privately_owned_tracks"),
            )])
        }
    }
    fn params(&self) -> Vec<(&str, Cow<'_, str>)> {
        vec![]
    }
    fn path(&self) -> &str {
        "browse"
    }
}
// Auth required
impl<A: LoggedIn> Query<A> for GetLibraryUploadAlbumsQuery {
    type Output = Vec<UploadAlbum>;
    type Method = PostMethod;
}
impl PostQuery for GetLibraryUploadAlbumsQuery {
    fn header(&self) -> serde_json::Map<String, serde_json::Value> {
        let params = get_sort_order_params(&self.sort_order);
        if let Some(params) = params {
            serde_json::Map::from_iter([
                (
                    "browseId".to_string(),
                    json!("FEmusic_library_privately_owned_releases"),
                ),
                ("params".to_string(), json!(params)),
            ])
        } else {
            serde_json::Map::from_iter([(
                "browseId".to_string(),
                json!("FEmusic_library_privately_owned_releases"),
            )])
        }
    }
    fn params(&self) -> Vec<(&str, Cow<'_, str>)> {
        vec![]
    }
    fn path(&self) -> &str {
        "browse"
    }
}
```
Tokens:
Raw