235 lines
8.9 KiB
Python
235 lines
8.9 KiB
Python
from typing import Tuple, Type, Dict, Set, Optional, List
|
|
from collections import defaultdict
|
|
|
|
from . import FetchOptions, DownloadOptions
|
|
from .results import SearchResults
|
|
from ..objects import DatabaseObject as DataObject, Source, Album, Song, Artist, Label
|
|
|
|
from ..utils.string_processing import fit_to_file_system
|
|
from ..utils.config import youtube_settings
|
|
from ..utils.enums.source import SourcePages
|
|
from ..utils.support_classes.download_result import DownloadResult
|
|
from ..utils.support_classes.query import Query
|
|
from ..utils.support_classes.download_result import DownloadResult
|
|
from ..utils.exception.download import UrlNotFoundException
|
|
from ..utils.shared import DEBUG_PAGES
|
|
|
|
from ..pages import Page, EncyclopaediaMetallum, Musify, YouTube, YoutubeMusic, Bandcamp, INDEPENDENT_DB_OBJECTS
|
|
|
|
|
|
ALL_PAGES: Set[Type[Page]] = {
|
|
# EncyclopaediaMetallum,
|
|
Musify,
|
|
YoutubeMusic,
|
|
Bandcamp
|
|
}
|
|
|
|
if youtube_settings["use_youtube_alongside_youtube_music"]:
|
|
ALL_PAGES.add(YouTube)
|
|
|
|
AUDIO_PAGES: Set[Type[Page]] = {
|
|
Musify,
|
|
YouTube,
|
|
YoutubeMusic,
|
|
Bandcamp
|
|
}
|
|
|
|
SHADY_PAGES: Set[Type[Page]] = {
|
|
Musify,
|
|
}
|
|
|
|
fetch_map = {
|
|
Song: "fetch_song",
|
|
Album: "fetch_album",
|
|
Artist: "fetch_artist",
|
|
Label: "fetch_label",
|
|
}
|
|
|
|
if DEBUG_PAGES:
|
|
DEBUGGING_PAGE = Bandcamp
|
|
print(f"Only downloading from page {DEBUGGING_PAGE}.")
|
|
|
|
ALL_PAGES = {DEBUGGING_PAGE}
|
|
AUDIO_PAGES = ALL_PAGES.union(AUDIO_PAGES)
|
|
|
|
|
|
class Pages:
|
|
def __init__(self, exclude_pages: Set[Type[Page]] = None, exclude_shady: bool = False, download_options: DownloadOptions = None, fetch_options: FetchOptions = None):
|
|
self.download_options: DownloadOptions = download_options or DownloadOptions()
|
|
self.fetch_options: FetchOptions = fetch_options or FetchOptions()
|
|
|
|
# initialize all page instances
|
|
self._page_instances: Dict[Type[Page], Page] = dict()
|
|
self._source_to_page: Dict[SourcePages, Type[Page]] = dict()
|
|
|
|
exclude_pages = exclude_pages if exclude_pages is not None else set()
|
|
|
|
if exclude_shady:
|
|
exclude_pages = exclude_pages.union(SHADY_PAGES)
|
|
|
|
if not exclude_pages.issubset(ALL_PAGES):
|
|
raise ValueError(f"The excluded pages have to be a subset of all pages: {exclude_pages} | {ALL_PAGES}")
|
|
|
|
def _set_to_tuple(page_set: Set[Type[Page]]) -> Tuple[Type[Page], ...]:
|
|
return tuple(sorted(page_set, key=lambda page: page.__name__))
|
|
|
|
self._pages_set: Set[Type[Page]] = ALL_PAGES.difference(exclude_pages)
|
|
self.pages: Tuple[Type[Page], ...] = _set_to_tuple(self._pages_set)
|
|
|
|
self._audio_pages_set: Set[Type[Page]] = self._pages_set.intersection(AUDIO_PAGES)
|
|
self.audio_pages: Tuple[Type[Page], ...] = _set_to_tuple(self._audio_pages_set)
|
|
|
|
for page_type in self.pages:
|
|
self._page_instances[page_type] = page_type(fetch_options=self.fetch_options, download_options=self.download_options)
|
|
self._source_to_page[page_type.SOURCE_TYPE] = page_type
|
|
|
|
def _get_page_from_enum(self, source_page: SourcePages) -> Page:
|
|
if source_page not in self._source_to_page:
|
|
return None
|
|
return self._page_instances[self._source_to_page[source_page]]
|
|
|
|
def search(self, query: Query) -> SearchResults:
|
|
result = SearchResults()
|
|
|
|
for page_type in self.pages:
|
|
result.add(
|
|
page=page_type,
|
|
search_result=self._page_instances[page_type].search(query=query)
|
|
)
|
|
|
|
return result
|
|
|
|
def fetch_details(self, data_object: DataObject, stop_at_level: int = 1, **kwargs) -> DataObject:
|
|
if not isinstance(data_object, INDEPENDENT_DB_OBJECTS):
|
|
return data_object
|
|
|
|
source: Source
|
|
for source in data_object.source_collection.get_sources():
|
|
new_data_object = self.fetch_from_source(source=source, stop_at_level=stop_at_level)
|
|
if new_data_object is not None:
|
|
data_object.merge(new_data_object)
|
|
|
|
return data_object
|
|
|
|
def fetch_from_source(self, source: Source, **kwargs) -> Optional[DataObject]:
|
|
page: Page = self._get_page_from_enum(source.page_enum)
|
|
if page is None:
|
|
return None
|
|
|
|
# getting the appropriate function for the page and the object type
|
|
source_type = page.get_source_type(source)
|
|
if not hasattr(page, fetch_map[source_type]):
|
|
return None
|
|
func = getattr(page, fetch_map[source_type])(source=source, **kwargs)
|
|
|
|
# fetching the data object and marking it as fetched
|
|
data_object: DataObject = func(source=source)
|
|
data_object.mark_as_fetched(source.hash_url)
|
|
return data_object
|
|
|
|
def fetch_from_url(self, url: str) -> Optional[DataObject]:
|
|
source = Source.match_url(url, SourcePages.MANUAL)
|
|
if source is None:
|
|
return None
|
|
|
|
return self.fetch_from_source(source=source)
|
|
|
|
def is_downloadable(self, music_object: DataObject) -> bool:
|
|
_page_types = set(self._source_to_page)
|
|
for src in music_object.source_collection.source_pages:
|
|
if src in self._source_to_page:
|
|
_page_types.add(self._source_to_page[src])
|
|
|
|
audio_pages = self._audio_pages_set.intersection(_page_types)
|
|
return len(audio_pages) > 0
|
|
|
|
def _skip_object(self, data_object: DataObject) -> bool:
|
|
if isinstance(data_object, Album):
|
|
if not self.download_options.download_all and data_object.album_type in self.download_options.album_type_blacklist:
|
|
return True
|
|
|
|
return False
|
|
|
|
def download(self, data_object: DataObject, genre: str, **kwargs) -> DownloadResult:
|
|
# fetch the given object
|
|
self.fetch_details(data_object)
|
|
|
|
# fetching all parent objects (e.g. if you only download a song)
|
|
if not kwargs.get("fetched_upwards", False):
|
|
to_fetch: List[DataObject] = [data_object]
|
|
|
|
while len(to_fetch) > 0:
|
|
new_to_fetch = []
|
|
for d in to_fetch:
|
|
if self._skip_object(d):
|
|
continue
|
|
|
|
self.fetch_details(d)
|
|
|
|
for c in d.get_parent_collections():
|
|
new_to_fetch.extend(c)
|
|
|
|
to_fetch = new_to_fetch
|
|
|
|
kwargs["fetched_upwards"] = True
|
|
|
|
# download all children
|
|
download_result: DownloadResult = DownloadResult()
|
|
for c in data_object.get_children():
|
|
for d in c:
|
|
if self._skip_object(d):
|
|
continue
|
|
|
|
download_result.merge(self.download(d, genre, **kwargs))
|
|
|
|
# actually download if the object is a song
|
|
if isinstance(data_object, Song):
|
|
"""
|
|
TODO
|
|
add the traced artist and album to the naming.
|
|
I am able to do that, because duplicate values are removed later on.
|
|
"""
|
|
|
|
self._download_song(data_object, naming={
|
|
"genre": [genre],
|
|
"audio_format": main_settings["audio_format"],
|
|
})
|
|
|
|
return download_result
|
|
|
|
def _download_song(self, song: Song, naming: dict) -> DownloadOptions:
|
|
# pre process the data recursively
|
|
song.compile()
|
|
|
|
# manage the naming
|
|
naming: Dict[str, List[str]] = defaultdict(list, naming)
|
|
naming["song"].append(song.title_string)
|
|
naming["isrc"].append(song.isrc)
|
|
naming["album"].extend(a.title_string for a in song.album_collection)
|
|
naming["album_type"].extend(a.album_type.value for a in song.album_collection)
|
|
naming["artist"].extend(a.name for a in song.main_artist_collection)
|
|
naming["artist"].extend(a.name for a in song.feature_artist_collection)
|
|
for a in song.album_collection:
|
|
naming["label"].extend([l.title_string for l in a.label_collection])
|
|
# removing duplicates from the naming, and process the strings
|
|
for key, value in naming.items():
|
|
# https://stackoverflow.com/a/17016257
|
|
naming[key] = list(dict.fromkeys(items))
|
|
naming[key] = [fit_to_file_system(i) for i in naming[key] if i is not None]
|
|
|
|
# get every possible path
|
|
path_format = [*main_settings["download_path"].split("/"), main_settings["download_file"]]
|
|
every_possible_path: Set[str] = set()
|
|
|
|
|
|
return DownloadOptions()
|
|
|
|
def fetch_url(self, url: str, stop_at_level: int = 2) -> Tuple[Type[Page], DataObject]:
|
|
source = Source.match_url(url, SourcePages.MANUAL)
|
|
|
|
if source is None:
|
|
raise UrlNotFoundException(url=url)
|
|
|
|
_actual_page = self._source_to_page[source.page_enum]
|
|
|
|
return _actual_page, self._page_instances[_actual_page].fetch_object_from_source(source=source, stop_at_level=stop_at_level) |