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.

@@ -0,0 +1,462 @@
1
+ """Parsers for user library lists, friends, and personal tags."""
2
+
3
+ from __future__ import annotations
4
+
5
+ from bs4 import BeautifulSoup
6
+
7
+ from fmscrape.errors import ParseError
8
+ from fmscrape.models import (
9
+ AlbumEntry,
10
+ AlbumListPage,
11
+ ArtistEntry,
12
+ ArtistListPage,
13
+ ArtistRef,
14
+ FriendsPage,
15
+ LibraryPlays,
16
+ PaginationAttr,
17
+ TagsListResult,
18
+ TrackEntry,
19
+ TrackListPage,
20
+ UserEntry,
21
+ UserInfo,
22
+ )
23
+ from fmscrape.normalize import absolute_url, parse_int
24
+ from fmscrape.parsers.common import images_from_element, parse_pagination_total, parse_tags
25
+
26
+ CHARTLIST_ROW_SELECTOR = "tr.chartlist-row:not(.chartlist__placeholder-row)"
27
+ NAME_LINK_SELECTOR = "td.chartlist-name a"
28
+ ARTIST_LINK_SELECTOR = "td.chartlist-artist a"
29
+ COUNT_BAR_SELECTOR = "td.chartlist-bar .chartlist-count-bar-value"
30
+ INDEX_SELECTOR = "td.chartlist-index"
31
+ USER_LIST_ITEM_SELECTOR = ".user-list-item"
32
+ USER_LIST_LINK_SELECTOR = ".user-list-name a"
33
+
34
+
35
+ def parse_user_top_artists(
36
+ html: str,
37
+ *,
38
+ url: str,
39
+ user: str,
40
+ page: int = 1,
41
+ limit: int | None = None,
42
+ ) -> ArtistListPage:
43
+ soup = BeautifulSoup(html, "lxml")
44
+ rows = soup.select(CHARTLIST_ROW_SELECTOR)
45
+ if not rows and soup.select_one(".chartlist, .library-top-header") is None:
46
+ raise ParseError("User top artists table not found", url=url, selector=CHARTLIST_ROW_SELECTOR)
47
+
48
+ artists: list[ArtistEntry] = []
49
+ for idx, row in enumerate(rows, start=1):
50
+ name_el = row.select_one(NAME_LINK_SELECTOR)
51
+ if name_el is None:
52
+ raise ParseError("Missing artist name link", url=url, selector=NAME_LINK_SELECTOR)
53
+ name = name_el.get_text(strip=True)
54
+ href = name_el.get("href")
55
+ count_el = row.select_one(COUNT_BAR_SELECTOR)
56
+ playcount = parse_int(count_el.get_text(strip=True) if count_el else None)
57
+ rank_el = row.select_one(INDEX_SELECTOR)
58
+ rank = parse_int(rank_el.get_text(strip=True) if rank_el else None) or ((page - 1) * 50 + idx)
59
+ artists.append(
60
+ ArtistEntry(
61
+ name=name,
62
+ url=absolute_url(href if isinstance(href, str) else ""),
63
+ images=images_from_element(row),
64
+ playcount=playcount or 0,
65
+ rank=rank,
66
+ )
67
+ )
68
+
69
+ if limit is not None and limit >= 0:
70
+ artists = artists[:limit]
71
+
72
+ total_pages = parse_pagination_total(soup, page)
73
+ per_page = limit if limit is not None else 50
74
+ return ArtistListPage(
75
+ artists=artists,
76
+ attr=PaginationAttr(
77
+ page=page,
78
+ per_page=per_page,
79
+ total_pages=total_pages,
80
+ total=total_pages * per_page,
81
+ user=user,
82
+ ),
83
+ root_key="topartists",
84
+ )
85
+
86
+
87
+ def parse_user_top_albums(
88
+ html: str,
89
+ *,
90
+ url: str,
91
+ user: str,
92
+ page: int = 1,
93
+ limit: int | None = None,
94
+ ) -> AlbumListPage:
95
+ soup = BeautifulSoup(html, "lxml")
96
+ rows = soup.select(CHARTLIST_ROW_SELECTOR)
97
+ if not rows and soup.select_one(".chartlist, .library-top-header") is None:
98
+ raise ParseError("User top albums table not found", url=url, selector=CHARTLIST_ROW_SELECTOR)
99
+
100
+ albums: list[AlbumEntry] = []
101
+ for idx, row in enumerate(rows, start=1):
102
+ name_el = row.select_one(NAME_LINK_SELECTOR)
103
+ artist_el = row.select_one(ARTIST_LINK_SELECTOR)
104
+ if name_el is None:
105
+ raise ParseError("Missing album name link", url=url, selector=NAME_LINK_SELECTOR)
106
+ name = name_el.get_text(strip=True)
107
+ href = name_el.get("href")
108
+ artist_name = artist_el.get_text(strip=True) if artist_el else ""
109
+ artist_href = artist_el.get("href") if artist_el else None
110
+ count_el = row.select_one(COUNT_BAR_SELECTOR)
111
+ playcount = parse_int(count_el.get_text(strip=True) if count_el else None)
112
+ rank_el = row.select_one(INDEX_SELECTOR)
113
+ rank = parse_int(rank_el.get_text(strip=True) if rank_el else None) or ((page - 1) * 50 + idx)
114
+ albums.append(
115
+ AlbumEntry(
116
+ name=name,
117
+ artist=ArtistRef(
118
+ name=artist_name,
119
+ url=absolute_url(artist_href if isinstance(artist_href, str) else ""),
120
+ ),
121
+ url=absolute_url(href if isinstance(href, str) else ""),
122
+ images=images_from_element(row),
123
+ playcount=playcount or 0,
124
+ rank=rank,
125
+ )
126
+ )
127
+
128
+ if limit is not None and limit >= 0:
129
+ albums = albums[:limit]
130
+
131
+ total_pages = parse_pagination_total(soup, page)
132
+ per_page = limit if limit is not None else 50
133
+ return AlbumListPage(
134
+ albums=albums,
135
+ attr=PaginationAttr(
136
+ page=page,
137
+ per_page=per_page,
138
+ total_pages=total_pages,
139
+ total=total_pages * per_page,
140
+ user=user,
141
+ ),
142
+ root_key="topalbums",
143
+ )
144
+
145
+
146
+ def parse_user_friends(
147
+ html: str,
148
+ *,
149
+ url: str,
150
+ user: str,
151
+ page: int = 1,
152
+ limit: int | None = None,
153
+ ) -> FriendsPage:
154
+ soup = BeautifulSoup(html, "lxml")
155
+ items = soup.select(USER_LIST_ITEM_SELECTOR)
156
+ if not items and soup.select_one(".user-list, .content-top") is None:
157
+ raise ParseError("User friends list not found", url=url, selector=USER_LIST_ITEM_SELECTOR)
158
+
159
+ friends: list[UserEntry] = []
160
+ for item in items:
161
+ link = item.select_one(USER_LIST_LINK_SELECTOR)
162
+ if link is None:
163
+ continue
164
+ name = link.get_text(strip=True)
165
+ href = link.get("href")
166
+ real_el = item.select_one(".user-list-description p")
167
+ friends.append(
168
+ UserEntry(
169
+ name=name,
170
+ url=absolute_url(href if isinstance(href, str) else ""),
171
+ images=images_from_element(item),
172
+ realname=real_el.get_text(strip=True) if real_el else "",
173
+ )
174
+ )
175
+
176
+ if limit is not None and limit >= 0:
177
+ friends = friends[:limit]
178
+
179
+ total_pages = parse_pagination_total(soup, page)
180
+ per_page = limit if limit is not None else max(len(friends), 1)
181
+ return FriendsPage(
182
+ friends=friends,
183
+ attr=PaginationAttr(
184
+ page=page,
185
+ per_page=per_page,
186
+ total_pages=total_pages,
187
+ total=total_pages * per_page,
188
+ user=user,
189
+ ),
190
+ )
191
+
192
+
193
+ def parse_user_personal_tags(
194
+ html: str,
195
+ *,
196
+ url: str,
197
+ user: str,
198
+ tag: str,
199
+ tagging_type: str = "artist",
200
+ page: int = 1,
201
+ limit: int | None = None,
202
+ ) -> ArtistListPage | AlbumListPage | TrackListPage:
203
+ soup = BeautifulSoup(html, "lxml")
204
+ rows = soup.select(CHARTLIST_ROW_SELECTOR)
205
+ if not rows and soup.select_one(".chartlist, .content-top") is None:
206
+ raise ParseError("Personal tags table not found", url=url, selector=CHARTLIST_ROW_SELECTOR)
207
+
208
+ total_pages = parse_pagination_total(soup, page)
209
+ per_page = limit if limit is not None else 20
210
+
211
+ if tagging_type == "album":
212
+ albums: list[AlbumEntry] = []
213
+ for row in rows:
214
+ name_el = row.select_one(NAME_LINK_SELECTOR)
215
+ if name_el is None:
216
+ continue
217
+ artist_el = row.select_one(ARTIST_LINK_SELECTOR)
218
+ href = name_el.get("href")
219
+ ahref = artist_el.get("href") if artist_el else None
220
+ albums.append(
221
+ AlbumEntry(
222
+ name=name_el.get_text(strip=True),
223
+ artist=ArtistRef(
224
+ name=artist_el.get_text(strip=True) if artist_el else "",
225
+ url=absolute_url(ahref if isinstance(ahref, str) else ""),
226
+ ),
227
+ url=absolute_url(href if isinstance(href, str) else ""),
228
+ images=images_from_element(row),
229
+ )
230
+ )
231
+ if limit is not None and limit >= 0:
232
+ albums = albums[:limit]
233
+ return AlbumListPage(
234
+ albums=albums,
235
+ attr=PaginationAttr(page=page, per_page=per_page, total_pages=total_pages, total=len(albums), user=user, tag=tag),
236
+ root_key="taggings",
237
+ )
238
+
239
+ if tagging_type == "track":
240
+ tracks: list[TrackEntry] = []
241
+ for row in rows:
242
+ name_el = row.select_one(NAME_LINK_SELECTOR)
243
+ if name_el is None:
244
+ continue
245
+ artist_el = row.select_one(ARTIST_LINK_SELECTOR)
246
+ href = name_el.get("href")
247
+ ahref = artist_el.get("href") if artist_el else None
248
+ tracks.append(
249
+ TrackEntry(
250
+ name=name_el.get_text(strip=True),
251
+ artist=ArtistRef(
252
+ name=artist_el.get_text(strip=True) if artist_el else "",
253
+ url=absolute_url(ahref if isinstance(ahref, str) else ""),
254
+ ),
255
+ url=absolute_url(href if isinstance(href, str) else ""),
256
+ images=images_from_element(row),
257
+ )
258
+ )
259
+ if limit is not None and limit >= 0:
260
+ tracks = tracks[:limit]
261
+ return TrackListPage(
262
+ tracks=tracks,
263
+ attr=PaginationAttr(page=page, per_page=per_page, total_pages=total_pages, total=len(tracks), user=user, tag=tag),
264
+ root_key="taggings",
265
+ )
266
+
267
+ artists: list[ArtistEntry] = []
268
+ for row in rows:
269
+ name_el = row.select_one(NAME_LINK_SELECTOR)
270
+ if name_el is None:
271
+ continue
272
+ href = name_el.get("href")
273
+ artists.append(
274
+ ArtistEntry(
275
+ name=name_el.get_text(strip=True),
276
+ url=absolute_url(href if isinstance(href, str) else ""),
277
+ images=images_from_element(row),
278
+ )
279
+ )
280
+ if limit is not None and limit >= 0:
281
+ artists = artists[:limit]
282
+ return ArtistListPage(
283
+ artists=artists,
284
+ attr=PaginationAttr(page=page, per_page=per_page, total_pages=total_pages, total=len(artists), user=user, tag=tag),
285
+ root_key="taggings",
286
+ )
287
+
288
+
289
+ def parse_user_info(html: str, *, url: str) -> UserInfo:
290
+ """Parse `/user/<username>` profile page into `UserInfo`."""
291
+ soup = BeautifulSoup(html, "lxml")
292
+ title_el = soup.select_one("h1.header-title, h1")
293
+ if title_el is None:
294
+ raise ParseError("User profile title not found", url=url, selector="h1.header-title, h1")
295
+ name = title_el.get_text(strip=True)
296
+
297
+ realname = ""
298
+ registered = ""
299
+ sec_el = soup.select_one(".header-title-secondary")
300
+ if sec_el is not None:
301
+ sec_text = sec_el.get_text(" ", strip=True)
302
+ if "scrobbling since" in sec_text:
303
+ parts = sec_text.split("scrobbling since", 1)
304
+ registered = parts[1].strip()
305
+ realname = parts[0].replace("•", "").strip()
306
+ else:
307
+ realname = sec_text
308
+
309
+ playcount = 0
310
+ artist_count = 0
311
+ for item in soup.select(".header-metadata-item"):
312
+ text = item.get_text(" ", strip=True).lower()
313
+ val = parse_int(text)
314
+ if val is None:
315
+ continue
316
+ if "scrobble" in text:
317
+ playcount = val
318
+ elif "artist" in text:
319
+ artist_count = val
320
+
321
+ avatar = soup.select_one(".header-avatar")
322
+ return UserInfo(
323
+ name=name,
324
+ url=url,
325
+ realname=realname,
326
+ images=images_from_element(avatar),
327
+ playcount=playcount,
328
+ artist_count=artist_count,
329
+ registered=registered,
330
+ )
331
+
332
+
333
+ def parse_user_top_tracks(
334
+ html: str,
335
+ *,
336
+ url: str,
337
+ user: str,
338
+ page: int = 1,
339
+ limit: int | None = None,
340
+ root_key: str = "toptracks",
341
+ ) -> TrackListPage:
342
+ """Parse `/user/<user>/library/tracks` or `/user/<user>/loved` into `TrackListPage`."""
343
+ soup = BeautifulSoup(html, "lxml")
344
+ rows = soup.select(CHARTLIST_ROW_SELECTOR)
345
+ if not rows and soup.select_one(".chartlist, .library-top-header, h1") is None:
346
+ raise ParseError("User tracks table not found", url=url, selector=CHARTLIST_ROW_SELECTOR)
347
+
348
+ tracks: list[TrackEntry] = []
349
+ for idx, row in enumerate(rows, start=1):
350
+ name_el = row.select_one(NAME_LINK_SELECTOR)
351
+ if name_el is None:
352
+ continue
353
+ href = name_el.get("href")
354
+ artist_el = row.select_one(ARTIST_LINK_SELECTOR)
355
+ ahref = artist_el.get("href") if artist_el else None
356
+ count_el = row.select_one(COUNT_BAR_SELECTOR)
357
+ playcount = parse_int(count_el.get_text(strip=True) if count_el else None)
358
+ rank_el = row.select_one(INDEX_SELECTOR)
359
+ rank = parse_int(rank_el.get_text(strip=True) if rank_el else None) or ((page - 1) * 50 + idx)
360
+ tracks.append(
361
+ TrackEntry(
362
+ name=name_el.get_text(strip=True),
363
+ artist=ArtistRef(
364
+ name=artist_el.get_text(strip=True) if artist_el else "",
365
+ url=absolute_url(ahref if isinstance(ahref, str) else ""),
366
+ ),
367
+ url=absolute_url(href if isinstance(href, str) else ""),
368
+ images=images_from_element(row),
369
+ playcount=playcount,
370
+ rank=rank,
371
+ )
372
+ )
373
+
374
+ if limit is not None and limit >= 0:
375
+ tracks = tracks[:limit]
376
+
377
+ total_pages = parse_pagination_total(soup, page)
378
+ per_page = limit if limit is not None else 50
379
+ return TrackListPage(
380
+ tracks=tracks,
381
+ attr=PaginationAttr(
382
+ page=page,
383
+ per_page=per_page,
384
+ total_pages=total_pages,
385
+ total=total_pages * per_page,
386
+ user=user,
387
+ ),
388
+ root_key=root_key,
389
+ )
390
+
391
+
392
+ def parse_user_top_tags(html: str, *, url: str, limit: int | None = None) -> TagsListResult:
393
+ """Parse `/user/<user>/tags` into `TagsListResult`."""
394
+ soup = BeautifulSoup(html, "lxml")
395
+ if soup.select_one("h1") is None:
396
+ raise ParseError("User tags page invalid", url=url, selector="h1")
397
+ tags = parse_tags(soup)
398
+ if limit is not None and limit >= 0:
399
+ tags = tags[:limit]
400
+ return TagsListResult(tags=tags, root_key="toptags")
401
+
402
+
403
+ def parse_library_plays(
404
+ html: str,
405
+ *,
406
+ url: str,
407
+ user: str,
408
+ artist: str,
409
+ album: str | None = None,
410
+ track: str | None = None,
411
+ ) -> LibraryPlays:
412
+ """Parse `/user/<user>/library/music/<artist>[/<album>|/_/<track>]` into `LibraryPlays`."""
413
+ soup = BeautifulSoup(html, "lxml")
414
+ if soup.select_one("h1, .metadata-item, .metadata-display") is None:
415
+ raise ParseError("Library plays page invalid", url=url, selector=".metadata-item")
416
+
417
+ playcount = 0
418
+ for item in soup.select(".metadata-item"):
419
+ text = item.get_text(" ", strip=True).lower()
420
+ if "scrobble" in text:
421
+ val = parse_int(text)
422
+ if val is not None:
423
+ playcount = val
424
+ break
425
+ if playcount == 0:
426
+ disp = soup.select_one(".metadata-display")
427
+ if disp is not None:
428
+ val = parse_int(disp.get_text(strip=True))
429
+ if val is not None:
430
+ playcount = val
431
+
432
+ tracks: list[TrackEntry] = []
433
+ if track is None:
434
+ for idx, row in enumerate(soup.select(CHARTLIST_ROW_SELECTOR), start=1):
435
+ name_el = row.select_one(NAME_LINK_SELECTOR)
436
+ if name_el is None:
437
+ continue
438
+ href = name_el.get("href")
439
+ count_el = row.select_one(COUNT_BAR_SELECTOR)
440
+ t_plays = parse_int(count_el.get_text(strip=True) if count_el else None)
441
+ rank_el = row.select_one(INDEX_SELECTOR)
442
+ rank = parse_int(rank_el.get_text(strip=True) if rank_el else None) or idx
443
+ tracks.append(
444
+ TrackEntry(
445
+ name=name_el.get_text(strip=True),
446
+ artist=ArtistRef(name=artist),
447
+ url=absolute_url(href if isinstance(href, str) else ""),
448
+ images=images_from_element(row),
449
+ playcount=t_plays,
450
+ rank=rank,
451
+ )
452
+ )
453
+
454
+ return LibraryPlays(
455
+ user=user,
456
+ artist=artist,
457
+ album=album,
458
+ track=track,
459
+ playcount=playcount,
460
+ url=url,
461
+ tracks=tracks,
462
+ )
@@ -0,0 +1,190 @@
1
+ """Parser for Last.fm user recent tracks page (/user/<username>/library)."""
2
+
3
+ from __future__ import annotations
4
+
5
+ from bs4 import BeautifulSoup, Tag
6
+
7
+ from fmscrape.errors import ParseError
8
+ from fmscrape.models import (
9
+ AlbumRef,
10
+ ArtistRef,
11
+ DateInfo,
12
+ Image,
13
+ PaginationAttr,
14
+ RecentTrack,
15
+ RecentTracksPage,
16
+ )
17
+ from fmscrape.normalize import (
18
+ absolute_url,
19
+ expand_images,
20
+ parse_int,
21
+ parse_utc_timestamp,
22
+ )
23
+
24
+ # Isolated CSS selectors for /user/<user>/library
25
+ ROW_SELECTOR = "tr.chartlist-row:not(.chartlist__placeholder-row)"
26
+ TRACK_LINK_SELECTOR = "td.chartlist-name a"
27
+ PLAY_LINK_SELECTOR = "a.chartlist-play-button"
28
+ ARTIST_LINK_SELECTOR = "td.chartlist-artist a"
29
+ ALBUM_COVER_SELECTOR = "td.chartlist-image a.cover-art"
30
+ ALBUM_IMG_SELECTOR = "td.chartlist-image img"
31
+ LOVED_STATE_SELECTOR = "td.chartlist-loved [data-toggle-button-current-state]"
32
+ TIMESTAMP_SELECTOR = "td.chartlist-timestamp span[title], td.chartlist-timestamp a"
33
+ NOW_PLAYING_ROW_CLASS = "chartlist-row--now-scrobbling"
34
+ TOTAL_SCROBBLES_SELECTOR = ".metadata-display"
35
+ PAGINATION_PAGE_SELECTOR = ".pagination-page"
36
+
37
+
38
+ def _parse_images(row: Tag) -> list[Image]:
39
+ img_el = row.select_one(ALBUM_IMG_SELECTOR)
40
+ src = img_el.get("src") if img_el else None
41
+ raw_src = src if isinstance(src, str) else None
42
+ return [Image(url=item["#text"], size=item["size"]) for item in expand_images(raw_src)]
43
+
44
+
45
+ def _parse_row(row: Tag, *, url: str) -> RecentTrack:
46
+ track_link = row.select_one(TRACK_LINK_SELECTOR)
47
+ play_link = row.select_one(PLAY_LINK_SELECTOR)
48
+ artist_link = row.select_one(ARTIST_LINK_SELECTOR)
49
+
50
+ track_name = ""
51
+ track_url = ""
52
+ if track_link is not None:
53
+ track_name = track_link.get_text(strip=True)
54
+ href = track_link.get("href")
55
+ track_url = absolute_url(href if isinstance(href, str) else "")
56
+ elif play_link is not None:
57
+ tn = play_link.get("data-track-name")
58
+ tu = play_link.get("data-track-url")
59
+ track_name = tn if isinstance(tn, str) else ""
60
+ track_url = absolute_url(tu if isinstance(tu, str) else "")
61
+
62
+ if not track_name:
63
+ raise ParseError(
64
+ "Could not extract track name from recent tracks row",
65
+ url=url,
66
+ selector=TRACK_LINK_SELECTOR,
67
+ )
68
+
69
+ artist_name = ""
70
+ artist_url = ""
71
+ if artist_link is not None:
72
+ artist_name = artist_link.get_text(strip=True)
73
+ ahref = artist_link.get("href")
74
+ artist_url = absolute_url(ahref if isinstance(ahref, str) else "")
75
+ elif play_link is not None:
76
+ an = play_link.get("data-artist-name")
77
+ au = play_link.get("data-artist-url")
78
+ artist_name = an if isinstance(an, str) else ""
79
+ artist_url = absolute_url(au if isinstance(au, str) else "")
80
+
81
+ if not artist_name:
82
+ raise ParseError(
83
+ "Could not extract artist name from recent tracks row",
84
+ url=url,
85
+ selector=ARTIST_LINK_SELECTOR,
86
+ )
87
+
88
+ album_name = ""
89
+ album_url = ""
90
+ album_cover = row.select_one(ALBUM_COVER_SELECTOR)
91
+ album_img = row.select_one(ALBUM_IMG_SELECTOR)
92
+ if album_cover is not None:
93
+ chref = album_cover.get("href")
94
+ album_url = absolute_url(chref if isinstance(chref, str) else "")
95
+ if album_img is not None:
96
+ alt = album_img.get("alt")
97
+ if isinstance(alt, str) and alt.strip():
98
+ album_name = alt.strip()
99
+
100
+ loved_el = row.select_one(LOVED_STATE_SELECTOR)
101
+ loved = (
102
+ loved_el is not None
103
+ and loved_el.get("data-toggle-button-current-state") == "loved"
104
+ )
105
+
106
+ row_classes = row.get("class") or []
107
+ ts_el = row.select_one(TIMESTAMP_SELECTOR)
108
+ ts_title = ts_el.get("title") if ts_el else None
109
+ ts_text = ts_el.get_text(strip=True) if ts_el else ""
110
+ now_playing = (
111
+ NOW_PLAYING_ROW_CLASS in row_classes
112
+ or "scrobbling now" in ts_text.lower()
113
+ )
114
+
115
+ date_info: DateInfo | None = None
116
+ if not now_playing:
117
+ raw_date = ts_title if isinstance(ts_title, str) and ts_title.strip() else ts_text
118
+ parsed_dt = parse_utc_timestamp(raw_date)
119
+ if parsed_dt is not None:
120
+ date_info = DateInfo(uts=parsed_dt[0], text=parsed_dt[1])
121
+
122
+ return RecentTrack(
123
+ name=track_name,
124
+ artist=ArtistRef(name=artist_name, url=artist_url),
125
+ album=AlbumRef(name=album_name, url=album_url),
126
+ url=track_url,
127
+ images=_parse_images(row),
128
+ date=date_info,
129
+ loved=loved,
130
+ now_playing=now_playing,
131
+ )
132
+
133
+
134
+ def _parse_total_pages(soup: BeautifulSoup, current_page: int) -> int:
135
+ max_page = current_page
136
+ for el in soup.select(PAGINATION_PAGE_SELECTOR):
137
+ val = parse_int(el.get_text(strip=True))
138
+ if val is not None and val > max_page:
139
+ max_page = val
140
+ return max_page
141
+
142
+
143
+ def _parse_total_scrobbles(soup: BeautifulSoup, row_count: int) -> int:
144
+ el = soup.select_one(TOTAL_SCROBBLES_SELECTOR)
145
+ if el is not None:
146
+ val = parse_int(el.get_text(strip=True))
147
+ if val is not None:
148
+ return val
149
+ return row_count
150
+
151
+
152
+ def parse_user_recent_tracks(
153
+ html: str,
154
+ *,
155
+ url: str,
156
+ user: str,
157
+ page: int = 1,
158
+ limit: int | None = None,
159
+ ) -> RecentTracksPage:
160
+ """Parse `/user/<user>/library` HTML into a `RecentTracksPage`."""
161
+ soup = BeautifulSoup(html, "lxml")
162
+ rows = soup.select(ROW_SELECTOR)
163
+ if not rows:
164
+ # Check if it's genuinely an empty library or a broken page/layout
165
+ if soup.select_one("section.library-scrobbles, .library-top-header, .chartlist") is None:
166
+ raise ParseError(
167
+ "Recent tracks table not found on page",
168
+ url=url,
169
+ selector=ROW_SELECTOR,
170
+ )
171
+
172
+ tracks = [_parse_row(row, url=url) for row in rows]
173
+ if limit is not None and limit >= 0:
174
+ tracks = tracks[:limit]
175
+
176
+ total_pages = _parse_total_pages(soup, current_page=page)
177
+ total = _parse_total_scrobbles(soup, row_count=len(tracks))
178
+ per_page = limit if limit is not None else 50
179
+
180
+ return RecentTracksPage(
181
+ tracks=tracks,
182
+ attr=PaginationAttr(
183
+ page=page,
184
+ per_page=per_page,
185
+ total_pages=total_pages,
186
+ total=total,
187
+ user=user,
188
+ ),
189
+ )
190
+