music-kraken-core/music_kraken/download/page_attributes.py

327 lines
12 KiB
Python
Raw Normal View History

2024-05-13 19:45:12 +00:00
from typing import Tuple, Type, Dict, Set, Optional, List
from collections import defaultdict
2024-05-13 22:28:05 +00:00
from pathlib import Path
2024-05-14 13:18:17 +00:00
import re
2024-05-15 11:16:11 +00:00
import logging
2023-03-28 10:50:23 +00:00
2024-05-13 19:45:12 +00:00
from . import FetchOptions, DownloadOptions
from .results import SearchResults
2024-05-14 13:18:17 +00:00
from ..objects import (
DatabaseObject as DataObject,
Collection,
Target,
Source,
Options,
Song,
Album,
Artist,
Label,
)
2024-05-15 10:18:08 +00:00
from ..audio import write_metadata_to_target, correct_codec
2024-05-15 11:16:11 +00:00
from ..utils import output, BColors
2024-05-13 19:51:32 +00:00
from ..utils.string_processing import fit_to_file_system
2024-05-14 13:18:17 +00:00
from ..utils.config import youtube_settings, main_settings
from ..utils.path_manager import LOCATIONS
2024-05-15 12:21:15 +00:00
from ..utils.enums import SourceType, ALL_SOURCE_TYPES
2023-10-23 14:21:44 +00:00
from ..utils.support_classes.download_result import DownloadResult
from ..utils.support_classes.query import Query
2024-05-13 19:45:12 +00:00
from ..utils.support_classes.download_result import DownloadResult
2024-05-14 13:18:17 +00:00
from ..utils.exception import MKMissingNameException
from ..utils.exception.download import UrlNotFoundException
2023-09-12 08:58:44 +00:00
from ..utils.shared import DEBUG_PAGES
2023-08-30 19:14:03 +00:00
from ..pages import Page, EncyclopaediaMetallum, Musify, YouTube, YoutubeMusic, Bandcamp, INDEPENDENT_DB_OBJECTS
2023-09-12 08:58:44 +00:00
2023-05-23 11:59:24 +00:00
2023-05-26 08:11:36 +00:00
ALL_PAGES: Set[Type[Page]] = {
# EncyclopaediaMetallum,
2023-06-12 19:53:40 +00:00
Musify,
2023-09-14 08:09:51 +00:00
YoutubeMusic,
Bandcamp
2023-05-26 08:11:36 +00:00
}
2023-09-12 09:16:25 +00:00
if youtube_settings["use_youtube_alongside_youtube_music"]:
ALL_PAGES.add(YouTube)
2023-05-26 08:11:36 +00:00
AUDIO_PAGES: Set[Type[Page]] = {
Musify,
2023-06-12 19:53:40 +00:00
YouTube,
YoutubeMusic,
Bandcamp
2023-05-26 08:11:36 +00:00
}
2023-05-26 08:11:36 +00:00
SHADY_PAGES: Set[Type[Page]] = {
Musify,
2023-05-26 08:11:36 +00:00
}
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)
2023-12-29 14:43:33 +00:00
2023-05-26 08:11:36 +00:00
class Pages:
2024-05-13 19:45:12 +00:00
def __init__(self, exclude_pages: Set[Type[Page]] = None, exclude_shady: bool = False, download_options: DownloadOptions = None, fetch_options: FetchOptions = None):
2024-05-15 11:16:11 +00:00
self.LOGGER = logging.getLogger("download")
2024-05-13 19:45:12 +00:00
self.download_options: DownloadOptions = download_options or DownloadOptions()
self.fetch_options: FetchOptions = fetch_options or FetchOptions()
2023-05-26 08:11:36 +00:00
# initialize all page instances
self._page_instances: Dict[Type[Page], Page] = dict()
2024-05-14 13:18:17 +00:00
self._source_to_page: Dict[SourceType, Type[Page]] = dict()
2023-05-26 08:11:36 +00:00
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)
2023-06-12 12:56:14 +00:00
self.pages: Tuple[Type[Page], ...] = _set_to_tuple(self._pages_set)
2024-05-13 19:45:12 +00:00
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)
2023-05-26 08:11:36 +00:00
for page_type in self.pages:
2024-05-13 19:45:12 +00:00
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
2024-05-14 13:18:17 +00:00
def _get_page_from_enum(self, source_page: SourceType) -> 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()
2023-05-26 08:11:36 +00:00
for page_type in self.pages:
result.add(
page=page_type,
search_result=self._page_instances[page_type].search(query=query)
)
return result
2024-05-13 19:45:12 +00:00
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
2024-05-15 11:16:11 +00:00
for source in data_object.source_collection.get_sources(source_type_sorting={
"only_with_page": True,
}):
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]:
2024-05-15 10:18:08 +00:00
if not source.has_page:
return None
2024-05-15 11:16:11 +00:00
source_type = source.page.get_source_type(source=source)
if source_type is None:
self.LOGGER.debug(f"Could not determine source type for {source}.")
return None
func = getattr(source.page, fetch_map[source_type])
2024-05-13 16:09:11 +00:00
# fetching the data object and marking it as fetched
2024-05-15 11:16:11 +00:00
data_object: DataObject = func(source=source, **kwargs)
data_object.mark_as_fetched(source.hash_url)
return data_object
2024-01-16 09:08:08 +00:00
2024-05-13 16:09:11 +00:00
def fetch_from_url(self, url: str) -> Optional[DataObject]:
2024-05-15 12:21:15 +00:00
source = Source.match_url(url, ALL_SOURCE_TYPES.MANUAL)
2024-05-13 16:09:11 +00:00
if source is None:
return None
return self.fetch_from_source(source=source)
2024-05-13 19:45:12 +00:00
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
2024-01-15 11:48:36 +00:00
2024-05-13 19:45:12 +00:00
def download(self, data_object: DataObject, genre: str, **kwargs) -> DownloadResult:
# fetch the given object
self.fetch_details(data_object)
2024-05-15 12:10:32 +00:00
output(f"\nDownloading {data_object.option_string}...", color=BColors.BOLD)
2024-05-13 19:45:12 +00:00
# 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]
2024-01-15 11:48:36 +00:00
2024-05-13 19:45:12 +00:00
while len(to_fetch) > 0:
new_to_fetch = []
for d in to_fetch:
if self._skip_object(d):
continue
2023-09-13 14:01:01 +00:00
2024-05-13 19:45:12 +00:00
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()
2024-05-15 11:16:11 +00:00
for c in data_object.get_child_collections():
2024-05-13 19:45:12 +00:00
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"]],
2024-05-13 19:45:12 +00:00
})
return download_result
2024-05-14 13:18:17 +00:00
def _extract_fields_from_template(self, path_template: str) -> Set[str]:
return set(re.findall(r"{([^}]+)}", path_template))
def _parse_path_template(self, path_template: str, naming: Dict[str, List[str]]) -> str:
field_names: Set[str] = self._extract_fields_from_template(path_template)
for field in field_names:
if len(naming[field]) == 0:
raise MKMissingNameException(f"Missing field for {field}.")
path_template = path_template.replace(f"{{{field}}}", naming[field][0])
2024-05-15 11:16:11 +00:00
return path_template
2024-05-14 13:18:17 +00:00
2024-05-13 19:45:12 +00:00
def _download_song(self, song: Song, naming: dict) -> DownloadOptions:
2024-05-14 13:18:17 +00:00
"""
TODO
Search the song in the file system.
"""
r = DownloadResult(total=1)
2024-05-13 19:51:32 +00:00
# pre process the data recursively
song.compile()
2024-05-13 19:45:12 +00:00
# manage the naming
naming: Dict[str, List[str]] = defaultdict(list, naming)
2024-05-16 15:30:53 +00:00
naming["song"].append(song.title_value)
2024-05-13 19:45:12 +00:00
naming["isrc"].append(song.isrc)
2024-05-16 15:30:53 +00:00
naming["album"].extend(a.title_value for a in song.album_collection)
2024-05-13 19:45:12 +00:00
naming["album_type"].extend(a.album_type.value for a in song.album_collection)
naming["artist"].extend(a.name for a in song.artist_collection)
2024-05-13 19:45:12 +00:00
naming["artist"].extend(a.name for a in song.feature_artist_collection)
for a in song.album_collection:
2024-05-16 15:30:53 +00:00
naming["label"].extend([l.title_value for l in a.label_collection])
2024-05-13 19:51:32 +00:00
# removing duplicates from the naming, and process the strings
2024-05-13 19:45:12 +00:00
for key, value in naming.items():
# https://stackoverflow.com/a/17016257
2024-05-15 11:16:11 +00:00
naming[key] = list(dict.fromkeys(value))
2024-05-15 12:51:30 +00:00
song.genre = naming["genre"][0]
2024-05-13 19:51:32 +00:00
2024-05-14 13:18:17 +00:00
# manage the targets
tmp: Target = Target.temp(file_extension=main_settings["audio_format"])
song.target_collection.append(Target(
relative_to_music_dir=True,
file_path=Path(
self._parse_path_template(main_settings["download_path"], naming=naming),
self._parse_path_template(main_settings["download_file"], naming=naming),
)
))
for target in song.target_collection:
2024-05-15 11:16:11 +00:00
if target.exists:
2024-05-15 12:10:32 +00:00
output(f'{target.file_path} {BColors.OKGREEN.value}[already exists]', color=BColors.GREY)
2024-05-14 13:18:17 +00:00
r.found_on_disk += 1
2024-05-15 10:18:08 +00:00
2024-05-15 12:10:32 +00:00
if not self.download_options.download_again_if_found:
2024-05-15 10:18:08 +00:00
target.copy_content(tmp)
2024-05-14 13:18:17 +00:00
else:
2024-05-15 11:16:11 +00:00
target.create_path()
2024-05-15 12:10:32 +00:00
output(f'{target.file_path}', color=BColors.GREY)
2024-05-14 13:18:17 +00:00
2024-05-15 10:18:08 +00:00
# this streams from every available source until something succeeds, setting the skip intervals to the values of the according source
used_source: Optional[Source] = None
skip_intervals: List[Tuple[float, float]] = []
for source in song.source_collection.get_sources(source_type_sorting={
"only_with_page": True,
"sort_key": lambda page: page.download_priority,
"reverse": True,
}):
if tmp.exists:
break
used_source = source
streaming_results = source.page.download_song_to_target(source=source, target=tmp, desc="download")
skip_intervals = source.page.get_skip_intervals(song=song, source=source)
# if something has been downloaded but it somehow failed, delete the file
if streaming_results.is_fatal_error and tmp.exists:
tmp.delete()
# if everything went right, the file should exist now
if not tmp.exists:
2024-05-15 10:30:54 +00:00
if used_source is None:
r.error_message = f"No source found for {song.option_string}."
else:
r.error_message = f"Something went wrong downloading {song.option_string}."
2024-05-15 10:18:08 +00:00
return r
# post process the audio
2024-05-15 10:30:54 +00:00
found_on_disk = used_source is None
if not found_on_disk or self.download_options.process_audio_if_found:
correct_codec(target=tmp, skip_intervals=skip_intervals)
r.sponsor_segments = len(skip_intervals)
if used_source is not None:
used_source.page.post_process_hook(song=song, temp_target=tmp)
2024-05-15 11:16:11 +00:00
if not found_on_disk or self.download_options.process_metadata_if_found:
2024-05-15 10:30:54 +00:00
write_metadata_to_target(metadata=song.metadata, target=tmp, song=song)
2024-05-13 19:45:12 +00:00
# copy the tmp target to the final locations
for target in song.target_collection:
tmp.copy_content(target)
2024-05-15 10:30:54 +00:00
tmp.delete()
2024-05-14 13:18:17 +00:00
return r
def fetch_url(self, url: str, stop_at_level: int = 2) -> Tuple[Type[Page], DataObject]:
2024-05-15 12:21:15 +00:00
source = Source.match_url(url, ALL_SOURCE_TYPES.MANUAL)
if source is None:
raise UrlNotFoundException(url=url)
2024-05-14 13:18:17 +00:00
_actual_page = self._source_to_page[source.source_type]
2023-06-12 15:40:54 +00:00
return _actual_page, self._page_instances[_actual_page].fetch_object_from_source(source=source, stop_at_level=stop_at_level)