feat: build

music_kraken/download/page_attributes.py

@@ -0,0 +1,133 @@
+from typing import Tuple, Type, Dict, Set
+
+from .results import SearchResults
+from ..objects import DatabaseObject, Source
+
+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.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,
+}
+
+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) -> None:
+        # 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()
+            self._source_to_page[page_type.SOURCE_TYPE] = page_type
+            
+    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, music_object: DatabaseObject, stop_at_level: int = 1) -> DatabaseObject:
+        if not isinstance(music_object, INDEPENDENT_DB_OBJECTS):
+            return music_object
+        
+        for source_page in music_object.source_collection.source_pages:
+            if source_page not in self._source_to_page:
+                continue
+
+            page_type = self._source_to_page[source_page]
+            
+            if page_type in self._pages_set:
+                music_object.merge(self._page_instances[page_type].fetch_details(music_object=music_object, stop_at_level=stop_at_level))
+        
+        return music_object
+
+    def is_downloadable(self, music_object: DatabaseObject) -> 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 download(self, music_object: DatabaseObject, genre: str, download_all: bool = False, process_metadata_anyway: bool = False) -> DownloadResult:
+        if not isinstance(music_object, INDEPENDENT_DB_OBJECTS):
+            return DownloadResult(error_message=f"{type(music_object).__name__} can't be downloaded.")
+
+        self.fetch_details(music_object)
+
+        _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)
+        
+        for download_page in audio_pages:
+            return self._page_instances[download_page].download(music_object=music_object, genre=genre, download_all=download_all, process_metadata_anyway=process_metadata_anyway)
+        
+        return DownloadResult(error_message=f"No audio source has been found for {music_object}.")
+
+    def fetch_url(self, url: str, stop_at_level: int = 2) -> Tuple[Type[Page], DatabaseObject]:
+        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)

music_kraken/download/results.py

@@ -0,0 +1,94 @@
+from typing import Tuple, Type, Dict, List, Generator, Union
+from dataclasses import dataclass
+
+from ..objects import DatabaseObject
+from ..utils.enums.source import SourcePages
+from ..pages import Page, EncyclopaediaMetallum, Musify
+
+
+@dataclass
+class Option:
+    index: int
+    music_object: DatabaseObject
+
+
+class Results:
+    def __init__(self) -> None:
+        self._by_index: Dict[int, DatabaseObject] = dict()
+        self._page_by_index: Dict[int: Type[Page]] = dict()
+        
+    def __iter__(self) -> Generator[DatabaseObject, None, None]:
+        for option in self.formated_generator():
+            if isinstance(option, Option):
+                yield option.music_object
+    
+    def formated_generator(self, max_items_per_page: int = 10) -> Generator[Union[Type[Page], Option], None, None]:
+        self._by_index = dict()
+        self._page_by_index = dict()
+    
+    def get_music_object_by_index(self, index: int) -> Tuple[Type[Page], DatabaseObject]:
+        # if this throws a key error, either the formatted generator needs to be iterated, or the option doesn't exist.
+        return self._page_by_index[index], self._by_index[index]
+
+
+class SearchResults(Results):
+    def __init__(
+        self,
+        pages: Tuple[Type[Page], ...] = None
+        
+    ) -> None:
+        super().__init__()
+        
+        self.pages = pages or []
+        # this would initialize a list for every page, which I don't think I want
+        # self.results = Dict[Type[Page], List[DatabaseObject]] = {page: [] for page in self.pages}
+        self.results: Dict[Type[Page], List[DatabaseObject]] = {}
+        
+    def add(self, page: Type[Page], search_result: List[DatabaseObject]):
+        """
+        adds a list of found music objects to the according page
+        WARNING: if a page already has search results, they are just gonna be overwritten
+        """
+        
+        self.results[page] = search_result
+
+    def get_page_results(self, page: Type[Page]) -> "PageResults":
+        return PageResults(page, self.results.get(page, []))
+    
+    def formated_generator(self, max_items_per_page: int = 10):
+        super().formated_generator()
+        i = 0
+        
+        for page in self.results:
+            yield page
+            
+            j = 0
+            for option in self.results[page]:
+                yield Option(i, option)
+                self._by_index[i] = option
+                self._page_by_index[i] = page
+                i += 1
+                j += 1
+                
+                if j >= max_items_per_page:
+                    break
+
+
+class PageResults(Results):
+    def __init__(self, page: Type[Page], results: List[DatabaseObject]) -> None:
+        super().__init__()
+        
+        self.page: Type[Page] = page
+        self.results: List[DatabaseObject] = results
+        
+    def formated_generator(self, max_items_per_page: int = 10):
+        super().formated_generator()
+        i = 0
+        
+        yield self.page
+        
+        for option in self.results:
+            yield Option(i, option)
+            self._by_index[i] = option
+            self._page_by_index[i] = self.page
+            i += 1