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
|
@@ -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
|
+
|