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/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
+ )