fmscrape 0.1.0__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Potentially problematic release.
This version of fmscrape might be problematic. Click here for more details.
- fmscrape/__init__.py +80 -0
- fmscrape/api/__init__.py +2 -0
- fmscrape/api/album.py +80 -0
- fmscrape/api/artist.py +265 -0
- fmscrape/api/auth.py +21 -0
- fmscrape/api/base.py +185 -0
- fmscrape/api/chart.py +71 -0
- fmscrape/api/geo.py +22 -0
- fmscrape/api/library.py +272 -0
- fmscrape/api/tag.py +174 -0
- fmscrape/api/track.py +144 -0
- fmscrape/api/user.py +638 -0
- fmscrape/client.py +474 -0
- fmscrape/errors.py +37 -0
- fmscrape/models.py +594 -0
- fmscrape/normalize.py +80 -0
- fmscrape/parsers/__init__.py +2 -0
- fmscrape/parsers/album.py +152 -0
- fmscrape/parsers/artist.py +305 -0
- fmscrape/parsers/chart.py +118 -0
- fmscrape/parsers/common.py +120 -0
- fmscrape/parsers/tag.py +207 -0
- fmscrape/parsers/track.py +184 -0
- fmscrape/parsers/user_lists.py +462 -0
- fmscrape/parsers/user_recent.py +190 -0
- fmscrape-0.1.0.dist-info/METADATA +126 -0
- fmscrape-0.1.0.dist-info/RECORD +29 -0
- fmscrape-0.1.0.dist-info/WHEEL +5 -0
- fmscrape-0.1.0.dist-info/top_level.txt +1 -0
fmscrape/api/user.py
ADDED
|
@@ -0,0 +1,638 @@
|
|
|
1
|
+
"""User API endpoints (`user.*`)."""
|
|
2
|
+
|
|
3
|
+
from __future__ import annotations
|
|
4
|
+
|
|
5
|
+
from collections.abc import AsyncIterator, Iterator
|
|
6
|
+
from datetime import date, datetime, tzinfo
|
|
7
|
+
from typing import TYPE_CHECKING, Any
|
|
8
|
+
from urllib.parse import quote
|
|
9
|
+
|
|
10
|
+
from fmscrape.api.base import (
|
|
11
|
+
aiter_paginated,
|
|
12
|
+
iter_paginated,
|
|
13
|
+
library_filter_params,
|
|
14
|
+
validate_period,
|
|
15
|
+
)
|
|
16
|
+
from fmscrape.errors import NotSupportedError
|
|
17
|
+
from fmscrape.models import (
|
|
18
|
+
AlbumListPage,
|
|
19
|
+
ArtistListPage,
|
|
20
|
+
FriendsPage,
|
|
21
|
+
RecentTracksPage,
|
|
22
|
+
TrackListPage,
|
|
23
|
+
)
|
|
24
|
+
from fmscrape.parsers.user_lists import (
|
|
25
|
+
parse_user_friends,
|
|
26
|
+
parse_user_info,
|
|
27
|
+
parse_user_personal_tags,
|
|
28
|
+
parse_user_top_albums,
|
|
29
|
+
parse_user_top_artists,
|
|
30
|
+
parse_user_top_tags,
|
|
31
|
+
parse_user_top_tracks,
|
|
32
|
+
)
|
|
33
|
+
from fmscrape.parsers.user_recent import parse_user_recent_tracks
|
|
34
|
+
|
|
35
|
+
if TYPE_CHECKING:
|
|
36
|
+
from fmscrape.client import AsyncLastFmClient, LastFmClient
|
|
37
|
+
|
|
38
|
+
|
|
39
|
+
def _require_cookies(has_cookies: bool, method: str) -> None:
|
|
40
|
+
if not has_cookies:
|
|
41
|
+
raise NotSupportedError(
|
|
42
|
+
f"{method} requires user cookies on last.fm (to pass Client Challenge or login gate). "
|
|
43
|
+
"Initialize LastFmClient(cookies=...) with your browser session cookies."
|
|
44
|
+
)
|
|
45
|
+
|
|
46
|
+
|
|
47
|
+
def _date_range_params(
|
|
48
|
+
from_ts: int | str | None,
|
|
49
|
+
to_ts: int | str | None,
|
|
50
|
+
*,
|
|
51
|
+
has_cookies: bool,
|
|
52
|
+
method: str,
|
|
53
|
+
) -> dict[str, Any]:
|
|
54
|
+
params: dict[str, Any] = {}
|
|
55
|
+
if from_ts is not None or to_ts is not None:
|
|
56
|
+
_require_cookies(has_cookies, method)
|
|
57
|
+
if from_ts is not None:
|
|
58
|
+
params["from"] = str(from_ts)
|
|
59
|
+
if to_ts is not None:
|
|
60
|
+
params["to"] = str(to_ts)
|
|
61
|
+
return params
|
|
62
|
+
|
|
63
|
+
|
|
64
|
+
class UserAPI:
|
|
65
|
+
"""Synchronous `user.*` methods."""
|
|
66
|
+
|
|
67
|
+
def __init__(self, client: LastFmClient) -> None:
|
|
68
|
+
self._client = client
|
|
69
|
+
|
|
70
|
+
def get_info(self, user: str) -> Any:
|
|
71
|
+
_require_cookies(self._client.has_cookies, "user.get_info")
|
|
72
|
+
path = f"/user/{quote(user, safe='')}"
|
|
73
|
+
resp = self._client.get(path)
|
|
74
|
+
return self._client.format_result(parse_user_info(resp.text, url=str(resp.url)))
|
|
75
|
+
|
|
76
|
+
def _get_recent_tracks_page(
|
|
77
|
+
self,
|
|
78
|
+
user: str,
|
|
79
|
+
*,
|
|
80
|
+
limit: int = 50,
|
|
81
|
+
page: int = 1,
|
|
82
|
+
from_ts: int | None = None,
|
|
83
|
+
to_ts: int | None = None,
|
|
84
|
+
) -> RecentTracksPage:
|
|
85
|
+
params = _date_range_params(
|
|
86
|
+
from_ts, to_ts, has_cookies=self._client.has_cookies, method="user.get_recent_tracks"
|
|
87
|
+
)
|
|
88
|
+
if page > 1:
|
|
89
|
+
params["page"] = page
|
|
90
|
+
path = f"/user/{quote(user, safe='')}/library"
|
|
91
|
+
resp = self._client.get(path, params=params or None)
|
|
92
|
+
return parse_user_recent_tracks(resp.text, url=str(resp.url), user=user, page=page, limit=limit)
|
|
93
|
+
|
|
94
|
+
def get_recent_tracks(
|
|
95
|
+
self,
|
|
96
|
+
user: str,
|
|
97
|
+
*,
|
|
98
|
+
limit: int = 50,
|
|
99
|
+
page: int = 1,
|
|
100
|
+
from_ts: int | None = None,
|
|
101
|
+
to_ts: int | None = None,
|
|
102
|
+
) -> Any:
|
|
103
|
+
return self._client.format_result(
|
|
104
|
+
self._get_recent_tracks_page(user, limit=limit, page=page, from_ts=from_ts, to_ts=to_ts)
|
|
105
|
+
)
|
|
106
|
+
|
|
107
|
+
def iter_recent_tracks(
|
|
108
|
+
self,
|
|
109
|
+
user: str,
|
|
110
|
+
*,
|
|
111
|
+
limit: int = 50,
|
|
112
|
+
start_page: int = 1,
|
|
113
|
+
max_pages: int | None = None,
|
|
114
|
+
) -> Iterator[Any]:
|
|
115
|
+
return iter_paginated(
|
|
116
|
+
lambda p: self._get_recent_tracks_page(user, limit=limit, page=p),
|
|
117
|
+
lambda r: r.tracks,
|
|
118
|
+
start_page=start_page,
|
|
119
|
+
max_pages=max_pages,
|
|
120
|
+
raw_json=self._client.raw_json,
|
|
121
|
+
)
|
|
122
|
+
|
|
123
|
+
def _get_top_artists_page(
|
|
124
|
+
self,
|
|
125
|
+
user: str,
|
|
126
|
+
*,
|
|
127
|
+
period: str = "overall",
|
|
128
|
+
from_ts: int | str | date | datetime | None = None,
|
|
129
|
+
to_ts: int | str | date | datetime | None = None,
|
|
130
|
+
tz: str | tzinfo | None = None,
|
|
131
|
+
limit: int = 50,
|
|
132
|
+
page: int = 1,
|
|
133
|
+
) -> ArtistListPage:
|
|
134
|
+
params = library_filter_params(
|
|
135
|
+
period=period,
|
|
136
|
+
from_ts=from_ts,
|
|
137
|
+
to_ts=to_ts,
|
|
138
|
+
tz=tz,
|
|
139
|
+
page=page,
|
|
140
|
+
has_cookies=self._client.has_cookies,
|
|
141
|
+
method="user.get_top_artists",
|
|
142
|
+
)
|
|
143
|
+
path = f"/user/{quote(user, safe='')}/library/artists"
|
|
144
|
+
resp = self._client.get(path, params=params or None)
|
|
145
|
+
return parse_user_top_artists(resp.text, url=str(resp.url), user=user, page=page, limit=limit)
|
|
146
|
+
|
|
147
|
+
def get_top_artists(
|
|
148
|
+
self,
|
|
149
|
+
user: str,
|
|
150
|
+
*,
|
|
151
|
+
period: str = "overall",
|
|
152
|
+
from_ts: int | str | date | datetime | None = None,
|
|
153
|
+
to_ts: int | str | date | datetime | None = None,
|
|
154
|
+
tz: str | tzinfo | None = None,
|
|
155
|
+
limit: int = 50,
|
|
156
|
+
page: int = 1,
|
|
157
|
+
) -> Any:
|
|
158
|
+
return self._client.format_result(
|
|
159
|
+
self._get_top_artists_page(
|
|
160
|
+
user, period=period, from_ts=from_ts, to_ts=to_ts, tz=tz, limit=limit, page=page
|
|
161
|
+
)
|
|
162
|
+
)
|
|
163
|
+
|
|
164
|
+
def iter_top_artists(
|
|
165
|
+
self,
|
|
166
|
+
user: str,
|
|
167
|
+
*,
|
|
168
|
+
period: str = "overall",
|
|
169
|
+
from_ts: int | str | date | datetime | None = None,
|
|
170
|
+
to_ts: int | str | date | datetime | None = None,
|
|
171
|
+
tz: str | tzinfo | None = None,
|
|
172
|
+
limit: int = 50,
|
|
173
|
+
start_page: int = 1,
|
|
174
|
+
max_pages: int | None = None,
|
|
175
|
+
) -> Iterator[Any]:
|
|
176
|
+
return iter_paginated(
|
|
177
|
+
lambda p: self._get_top_artists_page(
|
|
178
|
+
user, period=period, from_ts=from_ts, to_ts=to_ts, tz=tz, limit=limit, page=p
|
|
179
|
+
),
|
|
180
|
+
lambda r: r.artists,
|
|
181
|
+
start_page=start_page,
|
|
182
|
+
max_pages=max_pages,
|
|
183
|
+
raw_json=self._client.raw_json,
|
|
184
|
+
)
|
|
185
|
+
|
|
186
|
+
def _get_top_albums_page(
|
|
187
|
+
self,
|
|
188
|
+
user: str,
|
|
189
|
+
*,
|
|
190
|
+
period: str = "overall",
|
|
191
|
+
from_ts: int | str | date | datetime | None = None,
|
|
192
|
+
to_ts: int | str | date | datetime | None = None,
|
|
193
|
+
tz: str | tzinfo | None = None,
|
|
194
|
+
limit: int = 50,
|
|
195
|
+
page: int = 1,
|
|
196
|
+
) -> AlbumListPage:
|
|
197
|
+
params = library_filter_params(
|
|
198
|
+
period=period,
|
|
199
|
+
from_ts=from_ts,
|
|
200
|
+
to_ts=to_ts,
|
|
201
|
+
tz=tz,
|
|
202
|
+
page=page,
|
|
203
|
+
has_cookies=self._client.has_cookies,
|
|
204
|
+
method="user.get_top_albums",
|
|
205
|
+
)
|
|
206
|
+
path = f"/user/{quote(user, safe='')}/library/albums"
|
|
207
|
+
resp = self._client.get(path, params=params or None)
|
|
208
|
+
return parse_user_top_albums(resp.text, url=str(resp.url), user=user, page=page, limit=limit)
|
|
209
|
+
|
|
210
|
+
def get_top_albums(
|
|
211
|
+
self,
|
|
212
|
+
user: str,
|
|
213
|
+
*,
|
|
214
|
+
period: str = "overall",
|
|
215
|
+
from_ts: int | str | date | datetime | None = None,
|
|
216
|
+
to_ts: int | str | date | datetime | None = None,
|
|
217
|
+
tz: str | tzinfo | None = None,
|
|
218
|
+
limit: int = 50,
|
|
219
|
+
page: int = 1,
|
|
220
|
+
) -> Any:
|
|
221
|
+
return self._client.format_result(
|
|
222
|
+
self._get_top_albums_page(
|
|
223
|
+
user, period=period, from_ts=from_ts, to_ts=to_ts, tz=tz, limit=limit, page=page
|
|
224
|
+
)
|
|
225
|
+
)
|
|
226
|
+
|
|
227
|
+
def iter_top_albums(
|
|
228
|
+
self,
|
|
229
|
+
user: str,
|
|
230
|
+
*,
|
|
231
|
+
period: str = "overall",
|
|
232
|
+
from_ts: int | str | date | datetime | None = None,
|
|
233
|
+
to_ts: int | str | date | datetime | None = None,
|
|
234
|
+
tz: str | tzinfo | None = None,
|
|
235
|
+
limit: int = 50,
|
|
236
|
+
start_page: int = 1,
|
|
237
|
+
max_pages: int | None = None,
|
|
238
|
+
) -> Iterator[Any]:
|
|
239
|
+
return iter_paginated(
|
|
240
|
+
lambda p: self._get_top_albums_page(
|
|
241
|
+
user, period=period, from_ts=from_ts, to_ts=to_ts, tz=tz, limit=limit, page=p
|
|
242
|
+
),
|
|
243
|
+
lambda r: r.albums,
|
|
244
|
+
start_page=start_page,
|
|
245
|
+
max_pages=max_pages,
|
|
246
|
+
raw_json=self._client.raw_json,
|
|
247
|
+
)
|
|
248
|
+
|
|
249
|
+
def _get_top_tracks_page(
|
|
250
|
+
self,
|
|
251
|
+
user: str,
|
|
252
|
+
*,
|
|
253
|
+
period: str = "overall",
|
|
254
|
+
from_ts: int | str | date | datetime | None = None,
|
|
255
|
+
to_ts: int | str | date | datetime | None = None,
|
|
256
|
+
tz: str | tzinfo | None = None,
|
|
257
|
+
limit: int = 50,
|
|
258
|
+
page: int = 1,
|
|
259
|
+
) -> TrackListPage:
|
|
260
|
+
_require_cookies(self._client.has_cookies, "user.get_top_tracks")
|
|
261
|
+
params = library_filter_params(
|
|
262
|
+
period=period,
|
|
263
|
+
from_ts=from_ts,
|
|
264
|
+
to_ts=to_ts,
|
|
265
|
+
tz=tz,
|
|
266
|
+
page=page,
|
|
267
|
+
has_cookies=self._client.has_cookies,
|
|
268
|
+
method="user.get_top_tracks",
|
|
269
|
+
)
|
|
270
|
+
path = f"/user/{quote(user, safe='')}/library/tracks"
|
|
271
|
+
resp = self._client.get(path, params=params or None)
|
|
272
|
+
return parse_user_top_tracks(resp.text, url=str(resp.url), user=user, page=page, limit=limit)
|
|
273
|
+
|
|
274
|
+
def get_top_tracks(
|
|
275
|
+
self,
|
|
276
|
+
user: str,
|
|
277
|
+
*,
|
|
278
|
+
period: str = "overall",
|
|
279
|
+
from_ts: int | str | date | datetime | None = None,
|
|
280
|
+
to_ts: int | str | date | datetime | None = None,
|
|
281
|
+
tz: str | tzinfo | None = None,
|
|
282
|
+
limit: int = 50,
|
|
283
|
+
page: int = 1,
|
|
284
|
+
) -> Any:
|
|
285
|
+
return self._client.format_result(
|
|
286
|
+
self._get_top_tracks_page(
|
|
287
|
+
user, period=period, from_ts=from_ts, to_ts=to_ts, tz=tz, limit=limit, page=page
|
|
288
|
+
)
|
|
289
|
+
)
|
|
290
|
+
|
|
291
|
+
def iter_top_tracks(
|
|
292
|
+
self,
|
|
293
|
+
user: str,
|
|
294
|
+
*,
|
|
295
|
+
period: str = "overall",
|
|
296
|
+
from_ts: int | str | date | datetime | None = None,
|
|
297
|
+
to_ts: int | str | date | datetime | None = None,
|
|
298
|
+
tz: str | tzinfo | None = None,
|
|
299
|
+
limit: int = 50,
|
|
300
|
+
start_page: int = 1,
|
|
301
|
+
max_pages: int | None = None,
|
|
302
|
+
) -> Iterator[Any]:
|
|
303
|
+
return iter_paginated(
|
|
304
|
+
lambda p: self._get_top_tracks_page(
|
|
305
|
+
user, period=period, from_ts=from_ts, to_ts=to_ts, tz=tz, limit=limit, page=p
|
|
306
|
+
),
|
|
307
|
+
lambda r: r.tracks,
|
|
308
|
+
start_page=start_page,
|
|
309
|
+
max_pages=max_pages,
|
|
310
|
+
raw_json=self._client.raw_json,
|
|
311
|
+
)
|
|
312
|
+
|
|
313
|
+
def _get_loved_tracks_page(self, user: str, *, limit: int = 50, page: int = 1) -> TrackListPage:
|
|
314
|
+
_require_cookies(self._client.has_cookies, "user.get_loved_tracks")
|
|
315
|
+
path = f"/user/{quote(user, safe='')}/loved"
|
|
316
|
+
params = {"page": page} if page > 1 else None
|
|
317
|
+
resp = self._client.get(path, params=params)
|
|
318
|
+
return parse_user_top_tracks(
|
|
319
|
+
resp.text, url=str(resp.url), user=user, page=page, limit=limit, root_key="lovedtracks"
|
|
320
|
+
)
|
|
321
|
+
|
|
322
|
+
def get_loved_tracks(self, user: str, *, limit: int = 50, page: int = 1) -> Any:
|
|
323
|
+
return self._client.format_result(self._get_loved_tracks_page(user, limit=limit, page=page))
|
|
324
|
+
|
|
325
|
+
def iter_loved_tracks(
|
|
326
|
+
self,
|
|
327
|
+
user: str,
|
|
328
|
+
*,
|
|
329
|
+
limit: int = 50,
|
|
330
|
+
start_page: int = 1,
|
|
331
|
+
max_pages: int | None = None,
|
|
332
|
+
) -> Iterator[Any]:
|
|
333
|
+
return iter_paginated(
|
|
334
|
+
lambda p: self._get_loved_tracks_page(user, limit=limit, page=p),
|
|
335
|
+
lambda r: r.tracks,
|
|
336
|
+
start_page=start_page,
|
|
337
|
+
max_pages=max_pages,
|
|
338
|
+
raw_json=self._client.raw_json,
|
|
339
|
+
)
|
|
340
|
+
|
|
341
|
+
def get_top_tags(self, user: str, *, limit: int | None = None) -> Any:
|
|
342
|
+
_require_cookies(self._client.has_cookies, "user.get_top_tags")
|
|
343
|
+
path = f"/user/{quote(user, safe='')}/tags"
|
|
344
|
+
resp = self._client.get(path)
|
|
345
|
+
return self._client.format_result(parse_user_top_tags(resp.text, url=str(resp.url), limit=limit))
|
|
346
|
+
|
|
347
|
+
def _get_friends_page(self, user: str, *, limit: int = 50, page: int = 1) -> FriendsPage:
|
|
348
|
+
path = f"/user/{quote(user, safe='')}/following"
|
|
349
|
+
params = {"page": page} if page > 1 else None
|
|
350
|
+
resp = self._client.get(path, params=params)
|
|
351
|
+
return parse_user_friends(resp.text, url=str(resp.url), user=user, page=page, limit=limit)
|
|
352
|
+
|
|
353
|
+
def get_friends(self, user: str, *, limit: int = 50, page: int = 1) -> Any:
|
|
354
|
+
return self._client.format_result(self._get_friends_page(user, limit=limit, page=page))
|
|
355
|
+
|
|
356
|
+
def iter_friends(
|
|
357
|
+
self,
|
|
358
|
+
user: str,
|
|
359
|
+
*,
|
|
360
|
+
limit: int = 50,
|
|
361
|
+
start_page: int = 1,
|
|
362
|
+
max_pages: int | None = None,
|
|
363
|
+
) -> Iterator[Any]:
|
|
364
|
+
return iter_paginated(
|
|
365
|
+
lambda p: self._get_friends_page(user, limit=limit, page=p),
|
|
366
|
+
lambda r: r.friends,
|
|
367
|
+
start_page=start_page,
|
|
368
|
+
max_pages=max_pages,
|
|
369
|
+
raw_json=self._client.raw_json,
|
|
370
|
+
)
|
|
371
|
+
|
|
372
|
+
def get_weekly_artist_chart(
|
|
373
|
+
self,
|
|
374
|
+
user: str,
|
|
375
|
+
*,
|
|
376
|
+
from_ts: int | None = None,
|
|
377
|
+
to_ts: int | None = None,
|
|
378
|
+
limit: int = 50,
|
|
379
|
+
page: int = 1,
|
|
380
|
+
) -> Any:
|
|
381
|
+
_require_cookies(self._client.has_cookies, "user.get_weekly_artist_chart")
|
|
382
|
+
params = _date_range_params(
|
|
383
|
+
from_ts, to_ts, has_cookies=self._client.has_cookies, method="user.get_weekly_artist_chart"
|
|
384
|
+
)
|
|
385
|
+
if page > 1:
|
|
386
|
+
params["page"] = page
|
|
387
|
+
path = f"/user/{quote(user, safe='')}/library/artists"
|
|
388
|
+
resp = self._client.get(path, params=params or None)
|
|
389
|
+
res = parse_user_top_artists(resp.text, url=str(resp.url), user=user, page=page, limit=limit)
|
|
390
|
+
res.root_key = "weeklyartistchart"
|
|
391
|
+
return self._client.format_result(res)
|
|
392
|
+
|
|
393
|
+
def get_weekly_album_chart(
|
|
394
|
+
self,
|
|
395
|
+
user: str,
|
|
396
|
+
*,
|
|
397
|
+
from_ts: int | None = None,
|
|
398
|
+
to_ts: int | None = None,
|
|
399
|
+
limit: int = 50,
|
|
400
|
+
page: int = 1,
|
|
401
|
+
) -> Any:
|
|
402
|
+
_require_cookies(self._client.has_cookies, "user.get_weekly_album_chart")
|
|
403
|
+
params = _date_range_params(
|
|
404
|
+
from_ts, to_ts, has_cookies=self._client.has_cookies, method="user.get_weekly_album_chart"
|
|
405
|
+
)
|
|
406
|
+
if page > 1:
|
|
407
|
+
params["page"] = page
|
|
408
|
+
path = f"/user/{quote(user, safe='')}/library/albums"
|
|
409
|
+
resp = self._client.get(path, params=params or None)
|
|
410
|
+
res = parse_user_top_albums(resp.text, url=str(resp.url), user=user, page=page, limit=limit)
|
|
411
|
+
res.root_key = "weeklyalbumchart"
|
|
412
|
+
return self._client.format_result(res)
|
|
413
|
+
|
|
414
|
+
def get_weekly_track_chart(
|
|
415
|
+
self,
|
|
416
|
+
user: str,
|
|
417
|
+
*,
|
|
418
|
+
from_ts: int | None = None,
|
|
419
|
+
to_ts: int | None = None,
|
|
420
|
+
limit: int = 50,
|
|
421
|
+
page: int = 1,
|
|
422
|
+
) -> Any:
|
|
423
|
+
_require_cookies(self._client.has_cookies, "user.get_weekly_track_chart")
|
|
424
|
+
params = _date_range_params(
|
|
425
|
+
from_ts, to_ts, has_cookies=self._client.has_cookies, method="user.get_weekly_track_chart"
|
|
426
|
+
)
|
|
427
|
+
if page > 1:
|
|
428
|
+
params["page"] = page
|
|
429
|
+
path = f"/user/{quote(user, safe='')}/library/tracks"
|
|
430
|
+
resp = self._client.get(path, params=params or None)
|
|
431
|
+
return self._client.format_result(
|
|
432
|
+
parse_user_top_tracks(
|
|
433
|
+
resp.text,
|
|
434
|
+
url=str(resp.url),
|
|
435
|
+
user=user,
|
|
436
|
+
page=page,
|
|
437
|
+
limit=limit,
|
|
438
|
+
root_key="weeklytrackchart",
|
|
439
|
+
)
|
|
440
|
+
)
|
|
441
|
+
|
|
442
|
+
def get_weekly_chart_list(self, user: str) -> Any:
|
|
443
|
+
raise NotSupportedError("user.get_weekly_chart_list has no public equivalent on last.fm.")
|
|
444
|
+
|
|
445
|
+
def get_personal_tags(
|
|
446
|
+
self,
|
|
447
|
+
user: str,
|
|
448
|
+
tag: str,
|
|
449
|
+
*,
|
|
450
|
+
tagging_type: str = "artist",
|
|
451
|
+
limit: int = 50,
|
|
452
|
+
page: int = 1,
|
|
453
|
+
) -> Any:
|
|
454
|
+
path = f"/user/{quote(user, safe='')}/tags/{quote(tag, safe='')}"
|
|
455
|
+
params: dict[str, Any] = {}
|
|
456
|
+
if tagging_type in ("artist", "album", "track"):
|
|
457
|
+
params["tagging_type"] = tagging_type
|
|
458
|
+
if page > 1:
|
|
459
|
+
params["page"] = page
|
|
460
|
+
resp = self._client.get(path, params=params or None)
|
|
461
|
+
return self._client.format_result(
|
|
462
|
+
parse_user_personal_tags(
|
|
463
|
+
resp.text,
|
|
464
|
+
url=str(resp.url),
|
|
465
|
+
user=user,
|
|
466
|
+
tag=tag,
|
|
467
|
+
tagging_type=tagging_type,
|
|
468
|
+
page=page,
|
|
469
|
+
limit=limit,
|
|
470
|
+
)
|
|
471
|
+
)
|
|
472
|
+
|
|
473
|
+
|
|
474
|
+
class AsyncUserAPI:
|
|
475
|
+
"""Asynchronous `user.*` methods."""
|
|
476
|
+
|
|
477
|
+
def __init__(self, client: AsyncLastFmClient) -> None:
|
|
478
|
+
self._client = client
|
|
479
|
+
|
|
480
|
+
async def get_info(self, user: str) -> Any:
|
|
481
|
+
_require_cookies(self._client.has_cookies, "user.get_info")
|
|
482
|
+
path = f"/user/{quote(user, safe='')}"
|
|
483
|
+
resp = await self._client.get(path)
|
|
484
|
+
return self._client.format_result(parse_user_info(resp.text, url=str(resp.url)))
|
|
485
|
+
|
|
486
|
+
async def _get_recent_tracks_page(
|
|
487
|
+
self,
|
|
488
|
+
user: str,
|
|
489
|
+
*,
|
|
490
|
+
limit: int = 50,
|
|
491
|
+
page: int = 1,
|
|
492
|
+
from_ts: int | None = None,
|
|
493
|
+
to_ts: int | None = None,
|
|
494
|
+
) -> RecentTracksPage:
|
|
495
|
+
params = _date_range_params(
|
|
496
|
+
from_ts, to_ts, has_cookies=self._client.has_cookies, method="user.get_recent_tracks"
|
|
497
|
+
)
|
|
498
|
+
if page > 1:
|
|
499
|
+
params["page"] = page
|
|
500
|
+
path = f"/user/{quote(user, safe='')}/library"
|
|
501
|
+
resp = await self._client.get(path, params=params or None)
|
|
502
|
+
return parse_user_recent_tracks(resp.text, url=str(resp.url), user=user, page=page, limit=limit)
|
|
503
|
+
|
|
504
|
+
async def get_recent_tracks(
|
|
505
|
+
self,
|
|
506
|
+
user: str,
|
|
507
|
+
*,
|
|
508
|
+
limit: int = 50,
|
|
509
|
+
page: int = 1,
|
|
510
|
+
from_ts: int | None = None,
|
|
511
|
+
to_ts: int | None = None,
|
|
512
|
+
) -> Any:
|
|
513
|
+
return self._client.format_result(
|
|
514
|
+
await self._get_recent_tracks_page(
|
|
515
|
+
user, limit=limit, page=page, from_ts=from_ts, to_ts=to_ts
|
|
516
|
+
)
|
|
517
|
+
)
|
|
518
|
+
|
|
519
|
+
def iter_recent_tracks(
|
|
520
|
+
self,
|
|
521
|
+
user: str,
|
|
522
|
+
*,
|
|
523
|
+
limit: int = 50,
|
|
524
|
+
start_page: int = 1,
|
|
525
|
+
max_pages: int | None = None,
|
|
526
|
+
) -> AsyncIterator[Any]:
|
|
527
|
+
return aiter_paginated(
|
|
528
|
+
lambda p: self._get_recent_tracks_page(user, limit=limit, page=p),
|
|
529
|
+
lambda r: r.tracks,
|
|
530
|
+
start_page=start_page,
|
|
531
|
+
max_pages=max_pages,
|
|
532
|
+
raw_json=self._client.raw_json,
|
|
533
|
+
)
|
|
534
|
+
|
|
535
|
+
async def get_top_artists(
|
|
536
|
+
self, user: str, *, period: str = "overall", limit: int = 50, page: int = 1
|
|
537
|
+
) -> Any:
|
|
538
|
+
date_preset = validate_period(
|
|
539
|
+
period, method="user.get_top_artists", has_cookies=self._client.has_cookies
|
|
540
|
+
)
|
|
541
|
+
params: dict[str, Any] = {}
|
|
542
|
+
if date_preset is not None:
|
|
543
|
+
params["date_preset"] = date_preset
|
|
544
|
+
if page > 1:
|
|
545
|
+
params["page"] = page
|
|
546
|
+
path = f"/user/{quote(user, safe='')}/library/artists"
|
|
547
|
+
resp = await self._client.get(path, params=params or None)
|
|
548
|
+
return self._client.format_result(
|
|
549
|
+
parse_user_top_artists(resp.text, url=str(resp.url), user=user, page=page, limit=limit)
|
|
550
|
+
)
|
|
551
|
+
|
|
552
|
+
async def get_top_albums(
|
|
553
|
+
self, user: str, *, period: str = "overall", limit: int = 50, page: int = 1
|
|
554
|
+
) -> Any:
|
|
555
|
+
date_preset = validate_period(
|
|
556
|
+
period, method="user.get_top_albums", has_cookies=self._client.has_cookies
|
|
557
|
+
)
|
|
558
|
+
params: dict[str, Any] = {}
|
|
559
|
+
if date_preset is not None:
|
|
560
|
+
params["date_preset"] = date_preset
|
|
561
|
+
if page > 1:
|
|
562
|
+
params["page"] = page
|
|
563
|
+
path = f"/user/{quote(user, safe='')}/library/albums"
|
|
564
|
+
resp = await self._client.get(path, params=params or None)
|
|
565
|
+
return self._client.format_result(
|
|
566
|
+
parse_user_top_albums(resp.text, url=str(resp.url), user=user, page=page, limit=limit)
|
|
567
|
+
)
|
|
568
|
+
|
|
569
|
+
async def get_top_tracks(
|
|
570
|
+
self, user: str, *, period: str = "overall", limit: int = 50, page: int = 1
|
|
571
|
+
) -> Any:
|
|
572
|
+
_require_cookies(self._client.has_cookies, "user.get_top_tracks")
|
|
573
|
+
date_preset = validate_period(
|
|
574
|
+
period, method="user.get_top_tracks", has_cookies=self._client.has_cookies
|
|
575
|
+
)
|
|
576
|
+
params: dict[str, Any] = {}
|
|
577
|
+
if date_preset is not None:
|
|
578
|
+
params["date_preset"] = date_preset
|
|
579
|
+
if page > 1:
|
|
580
|
+
params["page"] = page
|
|
581
|
+
path = f"/user/{quote(user, safe='')}/library/tracks"
|
|
582
|
+
resp = await self._client.get(path, params=params or None)
|
|
583
|
+
return self._client.format_result(
|
|
584
|
+
parse_user_top_tracks(resp.text, url=str(resp.url), user=user, page=page, limit=limit)
|
|
585
|
+
)
|
|
586
|
+
|
|
587
|
+
async def get_loved_tracks(self, user: str, *, limit: int = 50, page: int = 1) -> Any:
|
|
588
|
+
_require_cookies(self._client.has_cookies, "user.get_loved_tracks")
|
|
589
|
+
path = f"/user/{quote(user, safe='')}/loved"
|
|
590
|
+
params = {"page": page} if page > 1 else None
|
|
591
|
+
resp = await self._client.get(path, params=params)
|
|
592
|
+
return self._client.format_result(
|
|
593
|
+
parse_user_top_tracks(
|
|
594
|
+
resp.text, url=str(resp.url), user=user, page=page, limit=limit, root_key="lovedtracks"
|
|
595
|
+
)
|
|
596
|
+
)
|
|
597
|
+
|
|
598
|
+
async def get_top_tags(self, user: str, *, limit: int | None = None) -> Any:
|
|
599
|
+
_require_cookies(self._client.has_cookies, "user.get_top_tags")
|
|
600
|
+
path = f"/user/{quote(user, safe='')}/tags"
|
|
601
|
+
resp = await self._client.get(path)
|
|
602
|
+
return self._client.format_result(parse_user_top_tags(resp.text, url=str(resp.url), limit=limit))
|
|
603
|
+
|
|
604
|
+
async def get_friends(self, user: str, *, limit: int = 50, page: int = 1) -> Any:
|
|
605
|
+
path = f"/user/{quote(user, safe='')}/following"
|
|
606
|
+
params = {"page": page} if page > 1 else None
|
|
607
|
+
resp = await self._client.get(path, params=params)
|
|
608
|
+
return self._client.format_result(
|
|
609
|
+
parse_user_friends(resp.text, url=str(resp.url), user=user, page=page, limit=limit)
|
|
610
|
+
)
|
|
611
|
+
|
|
612
|
+
async def get_personal_tags(
|
|
613
|
+
self,
|
|
614
|
+
user: str,
|
|
615
|
+
tag: str,
|
|
616
|
+
*,
|
|
617
|
+
tagging_type: str = "artist",
|
|
618
|
+
limit: int = 50,
|
|
619
|
+
page: int = 1,
|
|
620
|
+
) -> Any:
|
|
621
|
+
path = f"/user/{quote(user, safe='')}/tags/{quote(tag, safe='')}"
|
|
622
|
+
params: dict[str, Any] = {}
|
|
623
|
+
if tagging_type in ("artist", "album", "track"):
|
|
624
|
+
params["tagging_type"] = tagging_type
|
|
625
|
+
if page > 1:
|
|
626
|
+
params["page"] = page
|
|
627
|
+
resp = await self._client.get(path, params=params or None)
|
|
628
|
+
return self._client.format_result(
|
|
629
|
+
parse_user_personal_tags(
|
|
630
|
+
resp.text,
|
|
631
|
+
url=str(resp.url),
|
|
632
|
+
user=user,
|
|
633
|
+
tag=tag,
|
|
634
|
+
tagging_type=tagging_type,
|
|
635
|
+
page=page,
|
|
636
|
+
limit=limit,
|
|
637
|
+
)
|
|
638
|
+
)
|