def get_api_token(self) -> str:
if self.api_token:
return self.api_token
for script in extract_scripts_from_main_page(
get_request_sync("https://soundcloud.com")):
script_src = get_request_sync(script)
api_token = extract_token_from_script(script_src)
if not api_token:
continue
self.api_token = api_token
return self.api_token
def search(self,
search_term: str,
search_type: SearchTypes,
search_results=30):
url = build_search_url(search_term=search_term,
search_type=search_type,
client_id=self.get_api_token(),
search_results=search_results)
api_response: str = get_request_sync(url=url,
extra_headers=COMMON_HEADERS)
if search_type in [SearchTypes.GO_TRACK, SearchTypes.TRACK]:
return parse_search_result_track(api_response)
if search_type == SearchTypes.ARTIST:
return parse_search_result_artist(api_response)
if search_type == SearchTypes.ALBUM:
return parse_search_result_album(api_response)
if search_type == SearchTypes.ALL:
try:
return parse_search_result_track(api_response)
except:
try:
return parse_search_result_artist(api_response)
except:
try:
return parse_search_result_album(api_response)
except:
pass
return None
def get_album_tracks(album_id: int) -> List:
return [
genius.Lyrics.from_api_response(json.dumps(x))
for x in json.loads(
get_request_sync(get_album_tracks_url(album_id), build_header())
)["response"]["tracks"]
]
def get_albums_by_id(artist_id: str, token: str):
url: str = f"https://api.spotify.com/v1/artists/{artist_id}/albums"
parsed_response: dict = json.loads(
get_request_sync(url, extra_headers=build_auth_header(token)))
return [
spotify.Album.from_api_response(json.dumps(x))
for x in parsed_response["items"]
]
def from_id(playlist_id: str, token: str):
url = f"https://api.spotify.com/v1/playlists/{playlist_id}"
response: str = get_request_sync(
url=url, extra_headers=build_auth_header(token=token))
parsed_response: dict = json.loads(response)
copied_parsed_response: dict = dict(parsed_response)
while (copied_parsed_response["tracks"]["next"] if "tracks"
in copied_parsed_response else copied_parsed_response["next"]):
response: str = get_request_sync(
url=copied_parsed_response["tracks"]["next"] if "tracks"
in copied_parsed_response else copied_parsed_response["next"],
extra_headers=build_auth_header(token=token),
)
copied_parsed_response = json.loads(response)
parsed_response["tracks"]["items"].extend(
copied_parsed_response["items"])
return Playlist.from_api_response(json.dumps(parsed_response))
def get_top_tracks_by_id(artist_id: str, token: str, country="us"):
url = (f"https://api.spotify.com/v1/artists/"
f"{artist_id}/top-tracks?country={country}")
parsed_response: dict = json.loads(
get_request_sync(url,
extra_headers=build_auth_header(token=token)))
return [
spotify.Track.from_api_response(json.dumps(x))
for x in parsed_response["tracks"]
]
def search(
search_term: str,
token: str,
search_result_count: int = 5,
search_type: Type[SearchType] = SearchType.TRACK,
) -> List[typing.Union["spotify.Album", "spotify.Artist", "spotify.Playlist",
"spotify.Track", ]]:
if search_type in [SearchType.SHOW, SearchType.EPISODE]:
raise NotImplemented
response: dict = json.loads(
get_request_sync(
url=BASE_URL.format(
urllib.parse.quote(search_term),
search_type,
search_result_count,
),
extra_headers=build_auth_header(token),
))
return _parse_search_response(response, search_type)
def from_id(artist_id: str, token: str):
url = f"https://api.spotify.com/v1/artists/{artist_id}"
return Artist.from_api_response(
get_request_sync(url=url,
extra_headers=build_auth_header(token=token)))
def search_genius(search_term: str):
return prepare_search_results(
get_request_sync(
build_search_url(search_term=search_term), extra_headers=HEADERS
)
)
def resolve_url(url: str) -> str:
return get_request_sync(
get_lookup_url(url), extra_headers=build_header()
)
def from_id(track_id: str, token: str) -> "Track":
return Track.from_api_response(
get_request_sync(
url=f"https://api.spotify.com/v1/tracks/{track_id}",
extra_headers=build_auth_header(token=token),
))
def from_id(album_id: str, token: str) -> "Album":
url = f"https://api.spotify.com/v1/albums/{album_id}"
return Album.from_api_response(
get_request_sync(url=url,
extra_headers=build_auth_header(token=token)))
def request_referents(referent_list: List[str]) -> str:
return get_request_sync(
url=f"https://genius.com/api/referents/multi?ids="
f"{quote(','.join(referent_list))}",
extra_headers=REFERENCE_HEADERS,
).replace("\xa0", " ")
def request_id(song_id: str) -> str:
return get_request_sync(
url=build_url(song_id=song_id), extra_headers=build_header()
).replace("\xa0", " ")
