337 lines
11 KiB
Python
337 lines
11 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.playable import Track
|
|
from zotify.printer import Printer, PrintChannel
|
|
from zotify.utils import API_URL, AudioFormat, b62_to_hex
|
|
|
|
|
|
def client(args: Namespace) -> None:
|
|
config = Config(args)
|
|
Printer(config)
|
|
with Loader("Logging in..."):
|
|
if config.credentials is False:
|
|
session = Session()
|
|
else:
|
|
session = Session(
|
|
cred_file=config.credentials, save=True, language=config.language
|
|
)
|
|
selection = Selection(session)
|
|
|
|
try:
|
|
if args.search:
|
|
ids = selection.search(args.search, args.category)
|
|
elif args.playlist:
|
|
ids = selection.get("playlists", "items")
|
|
elif args.followed:
|
|
ids = selection.get("following?type=artist", "artists")
|
|
elif args.liked_tracks:
|
|
ids = selection.get("tracks", "items")
|
|
elif args.liked_episodes:
|
|
ids = selection.get("episodes", "items")
|
|
elif args.download:
|
|
ids = []
|
|
for x in args.download:
|
|
ids.extend(selection.from_file(x))
|
|
elif args.urls:
|
|
ids = args.urls
|
|
except (FileNotFoundError, ValueError):
|
|
Printer.print(PrintChannel.WARNINGS, "there is nothing to do")
|
|
return
|
|
|
|
app = App(config, session)
|
|
with Loader("Parsing input..."):
|
|
try:
|
|
app.parse(ids)
|
|
except (IndexError, TypeError) as e:
|
|
Printer.print(PrintChannel.ERRORS, str(e))
|
|
app.download()
|
|
|
|
|
|
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)
|
|
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, item: str, suffix: str) -> list[str]:
|
|
resp = self.__session.api().invoke_url(f"{API_URL}me/{item}", limit=50)[suffix]
|
|
for i in range(len(resp)):
|
|
self.__print(i + 1, resp[i])
|
|
return self.__get_selection(resp)
|
|
|
|
@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,3 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
|
|
|
|
@staticmethod
|
|
def __print(i: int, item: dict[str, Any]) -> None:
|
|
print("{:<2} {:<77}".format(i, item["name"]))
|
|
|
|
|
|
class PlayableType(Enum):
|
|
TRACK = "track"
|
|
EPISODE = "episode"
|
|
|
|
|
|
class PlayableData(NamedTuple):
|
|
type: PlayableType
|
|
id: PlayableId
|
|
library: Path
|
|
output: str
|
|
|
|
|
|
class App:
|
|
__playable_list: list[PlayableData]
|
|
|
|
def __init__(
|
|
self,
|
|
config: Config,
|
|
session: Session,
|
|
):
|
|
self.__config = config
|
|
self.__session = session
|
|
self.__playable_list = []
|
|
|
|
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 in artist.album_group + artist.single_group:
|
|
album = self.__session.api().get_metadata_4_album(
|
|
AlbumId.from_hex(album.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 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 IndexError(f'Parsing Error: Could not parse "{link}"')
|
|
|
|
if id_type == "album":
|
|
self.__parse_album(b62_to_hex(_id))
|
|
elif id_type == "artist":
|
|
self.__parse_artist(b62_to_hex(_id))
|
|
elif id_type == "playlist":
|
|
self.__parse_playlist(_id)
|
|
elif id_type == "show":
|
|
self.__parse_show(b62_to_hex(_id))
|
|
elif id_type == "track":
|
|
self.__parse_track(b62_to_hex(_id))
|
|
elif id_type == "episode":
|
|
self.__parse_episode(b62_to_hex(_id))
|
|
else:
|
|
raise TypeError(f'Parsing Error: Unknown type "{id_type}"')
|
|
|
|
def get_playable_list(self) -> list[PlayableData]:
|
|
"""Returns list of Playable items"""
|
|
return self.__playable_list
|
|
|
|
def download(self) -> None:
|
|
"""Downloads playable to local file"""
|
|
for playable in self.__playable_list:
|
|
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}"',
|
|
)
|
|
continue
|
|
|
|
try:
|
|
output = track.create_output(playable.library, playable.output)
|
|
except FileExistsError as e:
|
|
Printer.print(PrintChannel.SKIPS, str(e))
|
|
continue
|
|
|
|
file = track.write_audio_stream(
|
|
output,
|
|
self.__config.chunk_size,
|
|
)
|
|
if self.__config.save_lyrics and isinstance(track, 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
|
|
if self.__config.transcode_bitrate > 0
|
|
else None,
|
|
True,
|
|
self.__config.ffmpeg_path
|
|
if self.__config.ffmpeg_path != ""
|
|
else "ffmpeg",
|
|
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)
|
|
)
|