ytmusicapi_rs 0.1.0

Rust bindings for the ytmusicapi Python library
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156

//! Methods that require authentication.
use crate::{json_to_py, py_err, py_to_json, with_gil, Result, YTMusic};
use pyo3::prelude::*;
use pyo3::types::PyDict;
use serde_json::Value;

impl YTMusic {
    /// Fetch the user's saved songs (requires auth).
    pub fn get_library_songs(
        &self,
        limit: Option<u32>,
        validate_responses: Option<bool>,
        order: Option<&str>,
    ) -> Result<Value> {
        with_gil(|py| {
            let kw = PyDict::new(py);
            if let Some(v) = limit { kw.set_item("limit", v)?; }
            if let Some(v) = validate_responses { kw.set_item("validate_responses", v)?; }
            if let Some(v) = order { kw.set_item("order", v)?; }
            let result = self.inner.bind(py).call_method("get_library_songs", (), Some(&kw))?;
            py_to_json(py, &result)
        })
        .map_err(py_err)
    }

    /// Fetch the user's saved albums (requires auth).
    pub fn get_library_albums(&self, limit: Option<u32>, order: Option<&str>) -> Result<Value> {
        with_gil(|py| {
            let kw = PyDict::new(py);
            if let Some(v) = limit { kw.set_item("limit", v)?; }
            if let Some(v) = order { kw.set_item("order", v)?; }
            let result = self.inner.bind(py).call_method("get_library_albums", (), Some(&kw))?;
            py_to_json(py, &result)
        })
        .map_err(py_err)
    }

    /// Fetch the user's saved artists (requires auth).
    pub fn get_library_artists(&self, limit: Option<u32>, order: Option<&str>) -> Result<Value> {
        with_gil(|py| {
            let kw = PyDict::new(py);
            if let Some(v) = limit { kw.set_item("limit", v)?; }
            if let Some(v) = order { kw.set_item("order", v)?; }
            let result = self.inner.bind(py).call_method("get_library_artists", (), Some(&kw))?;
            py_to_json(py, &result)
        })
        .map_err(py_err)
    }

    /// Fetch the user's subscribed artists (requires auth).
    pub fn get_library_subscriptions(&self, limit: Option<u32>, order: Option<&str>) -> Result<Value> {
        with_gil(|py| {
            let kw = PyDict::new(py);
            if let Some(v) = limit { kw.set_item("limit", v)?; }
            if let Some(v) = order { kw.set_item("order", v)?; }
            let result = self.inner.bind(py).call_method("get_library_subscriptions", (), Some(&kw))?;
            py_to_json(py, &result)
        })
        .map_err(py_err)
    }

    /// Fetch the user's saved playlists (requires auth).
    pub fn get_library_playlists(&self, limit: Option<u32>) -> Result<Value> {
        with_gil(|py| {
            let kw = PyDict::new(py);
            if let Some(v) = limit { kw.set_item("limit", v)?; }
            let result = self.inner.bind(py).call_method("get_library_playlists", (), Some(&kw))?;
            py_to_json(py, &result)
        })
        .map_err(py_err)
    }

    /// Fetch the user's liked songs playlist (requires auth).
    pub fn get_liked_songs(&self, limit: Option<u32>) -> Result<Value> {
        with_gil(|py| {
            let kw = PyDict::new(py);
            if let Some(v) = limit { kw.set_item("limit", v)?; }
            let result = self.inner.bind(py).call_method("get_liked_songs", (), Some(&kw))?;
            py_to_json(py, &result)
        })
        .map_err(py_err)
    }

    /// Fetch the user's playback history (requires auth).
    pub fn get_history(&self) -> Result<Value> {
        with_gil(|py| {
            let result = self.inner.bind(py).call_method0("get_history")?;
            py_to_json(py, &result)
        })
        .map_err(py_err)
    }

    /// `song` should be a song object previously returned by `get_history` or similar.
    pub fn add_history_item(&self, song: &Value) -> Result<Value> {
        with_gil(|py| {
            let py_song = json_to_py(py, song)?;
            let result = self.inner.bind(py).call_method1("add_history_item", (py_song,))?;
            py_to_json(py, &result)
        })
        .map_err(py_err)
    }

    /// Remove history entries by feedback token (requires auth).
    pub fn remove_history_items(&self, feedback_tokens: &[&str]) -> Result<Value> {
        with_gil(|py| {
            let result = self.inner.bind(py).call_method1("remove_history_items", (feedback_tokens.to_vec(),))?;
            py_to_json(py, &result)
        })
        .map_err(py_err)
    }

    /// `rating` must be `"LIKE"`, `"DISLIKE"`, or `"INDIFFERENT"`.
    pub fn rate_song(&self, video_id: &str, rating: &str) -> Result<Value> {
        with_gil(|py| {
            let result = self.inner.bind(py).call_method1("rate_song", (video_id, rating))?;
            py_to_json(py, &result)
        })
        .map_err(py_err)
    }

    /// Rate a playlist (requires auth). `rating` must be `"LIKE"`, `"DISLIKE"`, or `"INDIFFERENT"`.
    pub fn rate_playlist(&self, playlist_id: &str, rating: &str) -> Result<Value> {
        with_gil(|py| {
            let result = self.inner.bind(py).call_method1("rate_playlist", (playlist_id, rating))?;
            py_to_json(py, &result)
        })
        .map_err(py_err)
    }

    /// Toggle a song's library status via feedback token (requires auth).
    pub fn edit_song_library_status(&self, feedback_tokens: &[&str]) -> Result<Value> {
        with_gil(|py| {
            let result = self.inner.bind(py).call_method1("edit_song_library_status", (feedback_tokens.to_vec(),))?;
            py_to_json(py, &result)
        })
        .map_err(py_err)
    }

    /// Subscribe to artists by channel ID (requires auth).
    pub fn subscribe_artists(&self, channel_ids: &[&str]) -> Result<Value> {
        with_gil(|py| {
            let result = self.inner.bind(py).call_method1("subscribe_artists", (channel_ids.to_vec(),))?;
            py_to_json(py, &result)
        })
        .map_err(py_err)
    }

    /// Unsubscribe from artists by channel ID (requires auth).
    pub fn unsubscribe_artists(&self, channel_ids: &[&str]) -> Result<Value> {
        with_gil(|py| {
            let result = self.inner.bind(py).call_method1("unsubscribe_artists", (channel_ids.to_vec(),))?;
            py_to_json(py, &result)
        })
        .map_err(py_err)
    }
}