413 lines
14 KiB
Python
413 lines
14 KiB
Python
from argparse import Namespace
|
|
from enum import Enum
|
|
from pathlib import Path
|
|
from typing import Any, NamedTuple
|
|
|
|
from librespot.metadata import (
|
|
AlbumId,
|
|
ArtistId,
|
|
EpisodeId,
|
|
PlayableId,
|
|
PlaylistId,
|
|
ShowId,
|
|
TrackId,
|
|
)
|
|
from librespot.util import bytes_to_hex
|
|
|
|
from zotify import Session
|
|
from zotify.config import Config
|
|
from zotify.file import TranscodingError
|
|
from zotify.loader import Loader
|
|
from zotify.printer import PrintChannel, Printer
|
|
from zotify.utils import API_URL, AudioFormat, b62_to_hex
|
|
|
|
|
|
class ParseError(ValueError):
|
|
...
|
|
|
|
|
|
class PlayableType(Enum):
|
|
TRACK = "track"
|
|
EPISODE = "episode"
|
|
|
|
|
|
class PlayableData(NamedTuple):
|
|
type: PlayableType
|
|
id: PlayableId
|
|
library: Path
|
|
output: str
|
|
metadata: dict[str, Any] = {}
|
|
|
|
|
|
class Selection:
|
|
def __init__(self, session: Session):
|
|
self.__session = session
|
|
|
|
def search(
|
|
self,
|
|
search_text: str,
|
|
category: list = [
|
|
"track",
|
|
"album",
|
|
"artist",
|
|
"playlist",
|
|
"show",
|
|
"episode",
|
|
],
|
|
) -> list[str]:
|
|
categories = ",".join(category)
|
|
with Loader("Searching..."):
|
|
resp = self.__session.api().invoke_url(
|
|
API_URL + "search",
|
|
{
|
|
"q": search_text,
|
|
"type": categories,
|
|
"include_external": "audio",
|
|
"market": self.__session.country(),
|
|
},
|
|
limit=10,
|
|
offset=0,
|
|
)
|
|
|
|
count = 0
|
|
links = []
|
|
for c in categories.split(","):
|
|
label = c + "s"
|
|
if len(resp[label]["items"]) > 0:
|
|
print(f"\n### {label.capitalize()} ###")
|
|
for item in resp[label]["items"]:
|
|
links.append(item)
|
|
self.__print(count + 1, item)
|
|
count += 1
|
|
return self.__get_selection(links)
|
|
|
|
def get(self, category: str, name: str = "", content: str = "") -> list[str]:
|
|
with Loader("Fetching items..."):
|
|
r = self.__session.api().invoke_url(f"{API_URL}me/{category}", limit=50)
|
|
if content != "":
|
|
r = r[content]
|
|
resp = r["items"]
|
|
|
|
items = []
|
|
for i in range(len(resp)):
|
|
try:
|
|
item = resp[i][name]
|
|
except KeyError:
|
|
item = resp[i]
|
|
items.append(item)
|
|
self.__print(i + 1, item)
|
|
return self.__get_selection(items)
|
|
|
|
@staticmethod
|
|
def from_file(file_path: Path) -> list[str]:
|
|
with open(file_path, "r", encoding="utf-8") as f:
|
|
return [line.strip() for line in f.readlines()]
|
|
|
|
@staticmethod
|
|
def __get_selection(items: list[dict[str, Any]]) -> list[str]:
|
|
print("\nResults to save (eg: 1,2,5 1-3)")
|
|
selection = ""
|
|
while len(selection) == 0:
|
|
selection = input("==> ")
|
|
ids = []
|
|
selections = selection.split(",")
|
|
for i in selections:
|
|
if "-" in i:
|
|
split = i.split("-")
|
|
for x in range(int(split[0]), int(split[1]) + 1):
|
|
ids.append(items[x - 1]["uri"])
|
|
else:
|
|
ids.append(items[int(i) - 1]["uri"])
|
|
return ids
|
|
|
|
def __print(self, i: int, item: dict[str, Any]) -> None:
|
|
match item["type"]:
|
|
case "album":
|
|
self.__print_album(i, item)
|
|
case "playlist":
|
|
self.__print_playlist(i, item)
|
|
case "track":
|
|
self.__print_track(i, item)
|
|
case "show":
|
|
self.__print_show(i, item)
|
|
case _:
|
|
print(
|
|
"{:<2} {:<77}".format(i, self.__fix_string_length(item["name"], 77))
|
|
)
|
|
|
|
def __print_album(self, i: int, item: dict[str, Any]) -> None:
|
|
artists = ", ".join([artist["name"] for artist in item["artists"]])
|
|
print(
|
|
"{:<2} {:<38} {:<38}".format(
|
|
i,
|
|
self.__fix_string_length(item["name"], 38),
|
|
self.__fix_string_length(artists, 38),
|
|
)
|
|
)
|
|
|
|
def __print_playlist(self, i: int, item: dict[str, Any]) -> None:
|
|
print(
|
|
"{:<2} {:<38} {:<38}".format(
|
|
i,
|
|
self.__fix_string_length(item["name"], 38),
|
|
self.__fix_string_length(item["owner"]["display_name"], 38),
|
|
)
|
|
)
|
|
|
|
def __print_track(self, i: int, item: dict[str, Any]) -> None:
|
|
artists = ", ".join([artist["name"] for artist in item["artists"]])
|
|
print(
|
|
"{:<2} {:<38} {:<38} {:<38}".format(
|
|
i,
|
|
self.__fix_string_length(item["name"], 38),
|
|
self.__fix_string_length(artists, 38),
|
|
self.__fix_string_length(item["album"]["name"], 38),
|
|
)
|
|
)
|
|
|
|
def __print_show(self, i: int, item: dict[str, Any]) -> None:
|
|
print(
|
|
"{:<2} {:<38} {:<38}".format(
|
|
i,
|
|
self.__fix_string_length(item["name"], 38),
|
|
self.__fix_string_length(item["publisher"], 38),
|
|
)
|
|
)
|
|
|
|
@staticmethod
|
|
def __fix_string_length(text: str, max_length: int) -> str:
|
|
if len(text) > max_length:
|
|
return text[: max_length - 3] + "..."
|
|
return text
|
|
|
|
|
|
class App:
|
|
__playable_list: list[PlayableData] = []
|
|
|
|
def __init__(self, args: Namespace):
|
|
self.__config = Config(args)
|
|
Printer(self.__config)
|
|
|
|
if self.__config.audio_format == AudioFormat.VORBIS and (
|
|
self.__config.ffmpeg_args != "" or self.__config.ffmpeg_path != ""
|
|
):
|
|
Printer.print(
|
|
PrintChannel.WARNINGS,
|
|
"FFmpeg options will be ignored since no transcoding is required",
|
|
)
|
|
|
|
with Loader("Logging in..."):
|
|
if (
|
|
args.username != "" and args.password != ""
|
|
) or not self.__config.credentials.is_file():
|
|
self.__session = Session.from_userpass(
|
|
args.username,
|
|
args.password,
|
|
self.__config.credentials,
|
|
self.__config.language,
|
|
)
|
|
else:
|
|
self.__session = Session.from_file(
|
|
self.__config.credentials, self.__config.language
|
|
)
|
|
|
|
ids = self.get_selection(args)
|
|
with Loader("Parsing input..."):
|
|
try:
|
|
self.parse(ids)
|
|
except ParseError as e:
|
|
Printer.print(PrintChannel.ERRORS, str(e))
|
|
self.download_all()
|
|
|
|
def get_selection(self, args: Namespace) -> list[str]:
|
|
selection = Selection(self.__session)
|
|
try:
|
|
if args.search:
|
|
return selection.search(" ".join(args.search), args.category)
|
|
elif args.playlist:
|
|
return selection.get("playlists")
|
|
elif args.followed:
|
|
return selection.get("following?type=artist", content="artists")
|
|
elif args.liked_tracks:
|
|
return selection.get("tracks", "track")
|
|
elif args.liked_episodes:
|
|
return selection.get("episodes")
|
|
elif args.download:
|
|
ids = []
|
|
for x in args.download:
|
|
ids.extend(selection.from_file(x))
|
|
return ids
|
|
elif args.urls:
|
|
return args.urls
|
|
except (FileNotFoundError, ValueError):
|
|
Printer.print(PrintChannel.WARNINGS, "there is nothing to do")
|
|
except KeyboardInterrupt:
|
|
Printer.print(PrintChannel.WARNINGS, "\nthere is nothing to do")
|
|
exit()
|
|
|
|
def parse(self, links: list[str]) -> None:
|
|
"""
|
|
Parses list of selected tracks/playlists/shows/etc...
|
|
Args:
|
|
links: List of links
|
|
"""
|
|
for link in links:
|
|
link = link.rsplit("?", 1)[0]
|
|
try:
|
|
split = link.split(link[-23])
|
|
_id = split[-1]
|
|
id_type = split[-2]
|
|
except IndexError:
|
|
raise ParseError(f'Could not parse "{link}"')
|
|
|
|
match id_type:
|
|
case "album":
|
|
self.__parse_album(b62_to_hex(_id))
|
|
case "artist":
|
|
self.__parse_artist(b62_to_hex(_id))
|
|
case "show":
|
|
self.__parse_show(b62_to_hex(_id))
|
|
case "track":
|
|
self.__parse_track(b62_to_hex(_id))
|
|
case "episode":
|
|
self.__parse_episode(b62_to_hex(_id))
|
|
case "playlist":
|
|
self.__parse_playlist(_id)
|
|
case _:
|
|
raise ParseError(f'Unknown content type "{id_type}"')
|
|
|
|
def __parse_album(self, hex_id: str) -> None:
|
|
album = self.__session.api().get_metadata_4_album(AlbumId.from_hex(hex_id))
|
|
for disc in album.disc:
|
|
for track in disc.track:
|
|
self.__playable_list.append(
|
|
PlayableData(
|
|
PlayableType.TRACK,
|
|
TrackId.from_hex(bytes_to_hex(track.gid)),
|
|
self.__config.music_library,
|
|
self.__config.output_album,
|
|
)
|
|
)
|
|
|
|
def __parse_artist(self, hex_id: str) -> None:
|
|
artist = self.__session.api().get_metadata_4_artist(ArtistId.from_hex(hex_id))
|
|
for album_group in artist.album_group and artist.single_group:
|
|
album = self.__session.api().get_metadata_4_album(
|
|
AlbumId.from_hex(album_group.album[0].gid)
|
|
)
|
|
for disc in album.disc:
|
|
for track in disc.track:
|
|
self.__playable_list.append(
|
|
PlayableData(
|
|
PlayableType.TRACK,
|
|
TrackId.from_hex(bytes_to_hex(track.gid)),
|
|
self.__config.music_library,
|
|
self.__config.output_album,
|
|
)
|
|
)
|
|
|
|
def __parse_playlist(self, b62_id: str) -> None:
|
|
playlist = self.__session.api().get_playlist(PlaylistId(b62_id))
|
|
for item in playlist.contents.items:
|
|
split = item.uri.split(":")
|
|
playable_type = PlayableType(split[1])
|
|
id_map = {PlayableType.TRACK: TrackId, PlayableType.EPISODE: EpisodeId}
|
|
playable_id = id_map[playable_type].from_base62(split[2])
|
|
self.__playable_list.append(
|
|
PlayableData(
|
|
playable_type,
|
|
playable_id,
|
|
self.__config.playlist_library,
|
|
self.__config.get(f"output_playlist_{playable_type.value}"),
|
|
)
|
|
)
|
|
|
|
def __parse_show(self, hex_id: str) -> None:
|
|
show = self.__session.api().get_metadata_4_show(ShowId.from_hex(hex_id))
|
|
for episode in show.episode:
|
|
self.__playable_list.append(
|
|
PlayableData(
|
|
PlayableType.EPISODE,
|
|
EpisodeId.from_hex(bytes_to_hex(episode.gid)),
|
|
self.__config.podcast_library,
|
|
self.__config.output_podcast,
|
|
)
|
|
)
|
|
|
|
def __parse_track(self, hex_id: str) -> None:
|
|
self.__playable_list.append(
|
|
PlayableData(
|
|
PlayableType.TRACK,
|
|
TrackId.from_hex(hex_id),
|
|
self.__config.music_library,
|
|
self.__config.output_album,
|
|
)
|
|
)
|
|
|
|
def __parse_episode(self, hex_id: str) -> None:
|
|
self.__playable_list.append(
|
|
PlayableData(
|
|
PlayableType.EPISODE,
|
|
EpisodeId.from_hex(hex_id),
|
|
self.__config.podcast_library,
|
|
self.__config.output_podcast,
|
|
)
|
|
)
|
|
|
|
def get_playable_list(self) -> list[PlayableData]:
|
|
"""Returns list of Playable items"""
|
|
return self.__playable_list
|
|
|
|
def download_all(self) -> None:
|
|
"""Downloads playable to local file"""
|
|
for playable in self.__playable_list:
|
|
self.__download(playable)
|
|
|
|
def __download(self, playable: PlayableData) -> None:
|
|
if playable.type == PlayableType.TRACK:
|
|
with Loader("Fetching track..."):
|
|
track = self.__session.get_track(
|
|
playable.id, self.__config.download_quality
|
|
)
|
|
elif playable.type == PlayableType.EPISODE:
|
|
with Loader("Fetching episode..."):
|
|
track = self.__session.get_episode(playable.id)
|
|
else:
|
|
Printer.print(
|
|
PrintChannel.SKIPS,
|
|
f'Download Error: Unknown playable content "{playable.type}"',
|
|
)
|
|
return
|
|
|
|
output = track.create_output(playable.library, playable.output)
|
|
file = track.write_audio_stream(
|
|
output,
|
|
self.__config.chunk_size,
|
|
)
|
|
|
|
if self.__config.save_lyrics_file and playable.type == PlayableType.TRACK:
|
|
with Loader("Fetching lyrics..."):
|
|
try:
|
|
track.get_lyrics().save(output)
|
|
except FileNotFoundError as e:
|
|
Printer.print(PrintChannel.SKIPS, str(e))
|
|
|
|
Printer.print(PrintChannel.DOWNLOADS, f"\nDownloaded {track.name}")
|
|
|
|
if self.__config.audio_format != AudioFormat.VORBIS:
|
|
try:
|
|
with Loader(PrintChannel.PROGRESS, "Converting audio..."):
|
|
file.transcode(
|
|
self.__config.audio_format,
|
|
self.__config.transcode_bitrate,
|
|
True,
|
|
self.__config.ffmpeg_path,
|
|
self.__config.ffmpeg_args.split(),
|
|
)
|
|
except TranscodingError as e:
|
|
Printer.print(PrintChannel.ERRORS, str(e))
|
|
|
|
if self.__config.save_metadata:
|
|
with Loader("Writing metadata..."):
|
|
file.write_metadata(track.metadata)
|
|
file.write_cover_art(track.get_cover_art(self.__config.artwork_size))
|