.vscode/settings.json

@@ -20,18 +20,12 @@
         "APIC",
         "Bandcamp",
         "bitrate",
-        "CALLSTACK",
-        "DEEZER",
         "dotenv",
         "encyclopaedia",
         "ENDC",
         "Gitea",
-        "iframe",
-        "isrc",
-        "itemprop",
         "levenshtein",
         "metallum",
-        "MUSICBRAINZ",
         "musify",
         "OKBLUE",
         "OKGREEN",

development/actual_donwload.py

@@ -1,13 +1,13 @@
-import logging
-
 import music_kraken
 
+import logging
 print("Setting logging-level to DEBUG")
 logging.getLogger().setLevel(logging.DEBUG)
 
 if __name__ == "__main__":
     commands = [
-        "s: #a Ghost Bath",
+        "s: #a Psychonaut 4",
+        "d: 0",
     ]
 
     

development/objects_collection.py

@@ -13,7 +13,7 @@ if __name__ == "__main__":
 
     song_2 = Song(
         title = "song",
-        artist_list=[other_artist]
+        main_artist_list=[other_artist]
     )
 
     other_artist.name = "main_artist"
@@ -21,5 +21,5 @@ if __name__ == "__main__":
     song_1.merge(song_2)
 
     print("#" * 120)
-    print("main", *song_1.artist_collection)
+    print("main", *song_1.main_artist_collection)
     print("feat", *song_1.feature_artist_collection)

music_kraken/audio/codec.py

@@ -10,12 +10,12 @@ from ..objects import Target
 LOGGER = logging_settings["codex_logger"]
 
 
-def correct_codec(target: Target, bitrate_kb: int = main_settings["bitrate"], audio_format: str = main_settings["audio_format"], skip_intervals: List[Tuple[float, float]] = None):
+def correct_codec(target: Target, bitrate_kb: int = main_settings["bitrate"], audio_format: str = main_settings["audio_format"], interval_list: List[Tuple[float, float]] = None):
     if not target.exists:
         LOGGER.warning(f"Target doesn't exist: {target.file_path}")
         return
     
-    skip_intervals = skip_intervals or []
+    interval_list = interval_list or []
 
     bitrate_b = int(bitrate_kb / 1024)
 
@@ -29,7 +29,7 @@ def correct_codec(target: Target, bitrate_kb: int = main_settings["bitrate"], au
     
     start = 0
     next_start = 0
-    for end, next_start in skip_intervals:
+    for end, next_start in interval_list:
         aselect_list.append(f"between(t,{start},{end})")
         start = next_start
     aselect_list.append(f"gte(t,{next_start})")

music_kraken/audio/metadata.py

@@ -1,21 +1,20 @@
-import logging
+import mutagen
+from mutagen.id3 import ID3, Frame, APIC
 from pathlib import Path
 from typing import List
-
-import mutagen
-from mutagen.id3 import APIC, ID3, USLT, Frame
+import logging
 from PIL import Image
 
-from ..connection import Connection
-from ..objects import Metadata, Song, Target
-from ..objects.metadata import Mapping
 from ..utils.config import logging_settings, main_settings
+from ..objects import Song, Target, Metadata
+from ..connection import Connection
 
 LOGGER = logging_settings["tagging_logger"]
 
 
 artwork_connection: Connection = Connection()
 
+
 class AudioMetadata:
     def __init__(self, file_location: str = None) -> None:
         self._file_location = None
@@ -67,14 +66,13 @@ def write_metadata_to_target(metadata: Metadata, target: Target, song: Song):
     id3_object = AudioMetadata(file_location=target.file_path)
 
     LOGGER.info(str(metadata))
-    ## REWRITE COMPLETLY !!!!!!!!!!!!
-    if len(song.artwork._data) != 0:
-        variants = song.artwork._data.__getitem__(0)
-        best_variant = variants.variants.__getitem__(0)
+
+    if song.artwork.best_variant is not None:
+        best_variant = song.artwork.best_variant
 
         r = artwork_connection.get(
-            url=best_variant.url,
-            name=best_variant.url,
+            url=best_variant["url"],
+            name=song.artwork.get_variant_name(best_variant),
         )
 
         temp_target: Target = Target.temp()
@@ -94,10 +92,6 @@ def write_metadata_to_target(metadata: Metadata, target: Target, song: Song):
             # resize the image to the preferred resolution
             img.thumbnail((main_settings["preferred_artwork_resolution"], main_settings["preferred_artwork_resolution"]))
 
-            # https://stackoverflow.com/a/59476938/16804841
-            if img.mode != 'RGB':
-                img = img.convert('RGB')
-
             img.save(converted_target.file_path, "JPEG")
 
         # https://stackoverflow.com/questions/70228440/mutagen-how-can-i-correctly-embed-album-art-into-mp3-file-so-that-i-can-see-t
@@ -108,14 +102,11 @@ def write_metadata_to_target(metadata: Metadata, target: Target, song: Song):
                 mime="image/jpeg",
                 type=3,
                 desc=u"Cover",
-                data=converted_target.raw_content,
+                data=converted_target.read_bytes(),
             )
         )
-        id3_object.frames.delall("USLT")
-        uslt_val = metadata.get_id3_value(Mapping.UNSYNCED_LYRICS)
-        id3_object.frames.add(
-            USLT(encoding=3, lang=u'eng', desc=u'desc', text=uslt_val)
-        )
+
+        mutagen_file = mutagen.File(target.file_path)
 
     id3_object.add_metadata(metadata)
     id3_object.save()

music_kraken/cli/main_downloader.py

@@ -178,6 +178,8 @@ class Downloader:
         page_count = 0
         for option in self.current_results.formatted_generator():
             if isinstance(option, Option):
+                _downloadable = self.pages.is_downloadable(option.music_object)
+
                 r = f"{BColors.GREY.value}{option.index:0{self.option_digits}}{BColors.ENDC.value} {option.music_object.option_string}"
                 print(r)
             else:
@@ -226,7 +228,7 @@ class Downloader:
             if album is not None:
                 song.album_collection.append(album)
             if artist is not None:
-                song.artist_collection.append(artist)
+                song.main_artist_collection.append(artist)
             return Query(raw_query=query, music_object=song)
 
         if album is not None:
@@ -317,7 +319,7 @@ class Downloader:
 
         for database_object in data_objects:
             r = self.pages.download(
-                data_object=database_object, 
+                music_object=database_object, 
                 genre=self.genre, 
                 **kwargs
             )
@@ -354,41 +356,37 @@ class Downloader:
                 command, query = _[0], ":".join(_[1:])
 
             do_search = "s" in command
-            do_fetch = "f" in command
             do_download = "d" in command
             do_merge = "m" in command
 
-            if do_search and (do_download or do_fetch or do_merge):
-                raise MKInvalidInputException(message="You can't search and do another operation at the same time.")
+            if do_search and do_download:
+                raise MKInvalidInputException(message="You can't search and download at the same time.")
+
+            if do_search and do_merge:
+                raise MKInvalidInputException(message="You can't search and merge at the same time.")
 
             if do_search:
                 self.search(":".join(input_str.split(":")[1:]))
                 return False
 
-            def get_selected_objects(q: str):
-                if q.strip().lower() == "all":
-                    return list(self.current_results)
+            indices = []
+            for possible_index in query.split(","):
+                possible_index = possible_index.strip()
+                if possible_index == "":
+                    continue
+                
+                i = 0
+                try:
+                    i = int(possible_index)
+                except ValueError:
+                    raise MKInvalidInputException(message=f"The index \"{possible_index}\" is not a number.")
 
-                indices = []
-                for possible_index in q.split(","):
-                    possible_index = possible_index.strip()
-                    if possible_index == "":
-                        continue
-                    
-                    i = 0
-                    try:
-                        i = int(possible_index)
-                    except ValueError:
-                        raise MKInvalidInputException(message=f"The index \"{possible_index}\" is not a number.")
+                if i < 0 or i >= len(self.current_results):
+                    raise MKInvalidInputException(message=f"The index \"{i}\" is not within the bounds of 0-{len(self.current_results) - 1}.")
+                
+                indices.append(i)
 
-                    if i < 0 or i >= len(self.current_results):
-                        raise MKInvalidInputException(message=f"The index \"{i}\" is not within the bounds of 0-{len(self.current_results) - 1}.")
-                    
-                    indices.append(i)
-
-                return [self.current_results[i] for i in indices]
-
-            selected_objects = get_selected_objects(query)
+            selected_objects = [self.current_results[i] for i in indices]
 
             if do_merge:
                 old_selected_objects = selected_objects
@@ -401,13 +399,6 @@ class Downloader:
 
                 selected_objects = [a]
 
-            if do_fetch:
-                for data_object in selected_objects:
-                    self.pages.fetch_details(data_object)
-
-                self.print_current_options()
-                return False
-
             if do_download:
                 self.download(selected_objects)
                 return False

music_kraken/connection/cache.py

@@ -6,7 +6,6 @@ from typing import List, Optional
 from functools import lru_cache
 import logging
 
-from ..utils import output, BColors
 from ..utils.config import main_settings
 from ..utils.string_processing import fit_to_file_system
 
@@ -137,13 +136,13 @@ class Cache:
         )
         self._write_attribute(cache_attribute)
 
-        cache_path = fit_to_file_system(Path(module_path, name.replace("/", "_")), hidden_ok=True)
+        cache_path = fit_to_file_system(Path(module_path, name), hidden_ok=True)
         with cache_path.open("wb") as content_file:
             self.logger.debug(f"writing cache to {cache_path}")
             content_file.write(content)
 
     def get(self, name: str) -> Optional[CacheResult]:
-        path = fit_to_file_system(Path(self._dir, self.module, name.replace("/", "_")), hidden_ok=True)
+        path = fit_to_file_system(Path(self._dir, self.module, name), hidden_ok=True)
 
         if not path.is_file():
             return None
@@ -166,7 +165,7 @@ class Cache:
             if ca.name == "":
                 continue
 
-            file = fit_to_file_system(Path(self._dir, ca.module, ca.name.replace("/", "_")), hidden_ok=True)
+            file = fit_to_file_system(Path(self._dir, ca.module, ca.name), hidden_ok=True)
 
             if not ca.is_valid:
                 self.logger.debug(f"deleting cache {ca.id}")
@@ -205,12 +204,9 @@ class Cache:
         for path in self._dir.iterdir():
             if path.is_dir():
                 for file in path.iterdir():
-                    output(f"Deleting file {file}", color=BColors.GREY)
                     file.unlink()
-                output(f"Deleting folder {path}", color=BColors.HEADER)
                 path.rmdir()
             else:
-                output(f"Deleting folder {path}", color=BColors.HEADER)
                 path.unlink()
 
         self.cached_attributes.clear()

music_kraken/connection/connection.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
-import copy
-import inspect
 import logging
 import threading
 import time
-from typing import TYPE_CHECKING, Dict, List, Optional, Set
-from urllib.parse import ParseResult, urlparse, urlunsplit
+from typing import List, Dict, Optional, Set
+from urllib.parse import urlparse, urlunsplit, ParseResult
+import copy
+import inspect
 
 import requests
 import responses
@@ -14,15 +14,12 @@ from tqdm import tqdm
 
 from .cache import Cache
 from .rotating import RotatingProxy
-
-if TYPE_CHECKING:
-    from ..objects import Target
-
+from ..objects import Target
 from ..utils import request_trace
-from ..utils.config import main_settings
-from ..utils.hacking import merge_args
 from ..utils.string_processing import shorten_display_url
+from ..utils.config import main_settings
 from ..utils.support_classes.download_result import DownloadResult
+from ..utils.hacking import merge_args
 
 
 class Connection:
@@ -320,7 +317,7 @@ class Connection:
             name = kwargs.pop("description")
 
         if progress > 0:
-            headers = kwargs.get("headers", dict())
+            headers = dict() if headers is None else headers
             headers["Range"] = f"bytes={target.size}-"
 
         r = self.request(
@@ -369,7 +366,6 @@ class Connection:
             if retry:
                 self.LOGGER.warning(f"Retrying stream...")
                 accepted_response_codes.add(206)
-                stream_kwargs["progress"] = progress
                 return Connection.stream_into(**stream_kwargs)
 
             return DownloadResult()

music_kraken/download/__init__.py

@@ -1,21 +0,0 @@
-from dataclasses import dataclass, field
-from typing import Set
-
-from ..utils.config import main_settings
-from ..utils.enums.album import AlbumType
-
-
-@dataclass
-class FetchOptions:
-    download_all: bool = False
-    album_type_blacklist: Set[AlbumType] = field(default_factory=lambda: set(AlbumType(a) for a in main_settings["album_type_blacklist"]))
-
-
-@dataclass
-class DownloadOptions:
-    download_all: bool = False
-    album_type_blacklist: Set[AlbumType] = field(default_factory=lambda: set(AlbumType(a) for a in main_settings["album_type_blacklist"]))
-
-    download_again_if_found: bool = False
-    process_audio_if_found: bool = False
-    process_metadata_if_found: bool = True

music_kraken/download/page_attributes.py

@@ -1,45 +1,20 @@
-from typing import Tuple, Type, Dict, Set, Optional, List
-from collections import defaultdict
-from pathlib import Path
-import re
-import logging
-import subprocess
+from typing import Tuple, Type, Dict, Set
 
-from PIL import Image
-
-from . import FetchOptions, DownloadOptions
 from .results import SearchResults
-from ..objects import (
-    DatabaseObject as DataObject,
-    Collection,
-    Target,
-    Source,
-    Options,
-    Song,
-    Album,
-    Artist,
-    Label,
-)
-from ..objects.artwork import ArtworkVariant
-from ..audio import write_metadata_to_target, correct_codec
-from ..utils import output, BColors
-from ..utils.string_processing import fit_to_file_system
-from ..utils.config import youtube_settings, main_settings
-from ..utils.path_manager import LOCATIONS
-from ..utils.enums import SourceType, ALL_SOURCE_TYPES
+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.support_classes.download_result import DownloadResult
-from ..utils.exception import MKMissingNameException
 from ..utils.exception.download import UrlNotFoundException
 from ..utils.shared import DEBUG_PAGES
-from ..connection import Connection
 
-from ..pages import Page, EncyclopaediaMetallum, Musify, YouTube, YoutubeMusic, Bandcamp, Genius, INDEPENDENT_DB_OBJECTS
+from ..pages import Page, EncyclopaediaMetallum, Musify, YouTube, YoutubeMusic, Bandcamp, INDEPENDENT_DB_OBJECTS
+
 
 ALL_PAGES: Set[Type[Page]] = {
     # EncyclopaediaMetallum,
-    Genius,
     Musify,
     YoutubeMusic,
     Bandcamp
@@ -59,13 +34,6 @@ 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}.")
@@ -75,308 +43,91 @@ if DEBUG_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.LOGGER = logging.getLogger("download")
-
-        self.download_options: DownloadOptions = download_options or DownloadOptions()
-        self.fetch_options: FetchOptions = fetch_options or FetchOptions()
-
+    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[SourceType, Type[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}")
-
+            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)
-
+                                                           
+        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._page_instances[page_type] = page_type()
             self._source_to_page[page_type.SOURCE_TYPE] = page_type
-
-    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()
-
+        
         for page_type in self.pages:
             result.add(
                 page=page_type,
-                search_result=self._page_instances[page_type].search(
-                    query=query)
+                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
 
-    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
+            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
 
-        source: Source
-        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)
+    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])
 
-        return data_object
+        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.")
 
-    def fetch_from_source(self, source: Source, **kwargs) -> Optional[DataObject]:
-        if not source.has_page:
-            return None
+        self.fetch_details(music_object)
 
-        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
+        _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])
 
-        func = getattr(source.page, fetch_map[source_type])
-
-        # fetching the data object and marking it as fetched
-        data_object: DataObject = func(source=source, **kwargs)
-        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, ALL_SOURCE_TYPES.MANUAL)
-        if source is None:
-            return None
-
-        return self.fetch_from_source(source=source)
-
-    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 _fetch_artist_artwork(self, artist: Artist, naming: dict):
-        naming: Dict[str, List[str]] = defaultdict(list, naming)
-        naming["artist"].append(artist.name)
-        naming["label"].extend(
-            [l.title_value for l in artist.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(value))
-
-        artwork_collection: ArtworkCollection = artist.artwork
-        artwork_collection.compile()
-        for image_number, artwork in enumerate(artwork_collection):
-            for artwork_variant in artwork.variants:
-                naming["image_number"] = [str(image_number)]
-                target = Target(
-                    relative_to_music_dir=True,
-                    file_path=Path(self._parse_path_template(
-                        main_settings["artist_artwork_path"], naming=naming))
-                )
-                if not target.file_path.parent.exists():
-                    target.create_path()
-                    subprocess.Popen(["gio", "set", target.file_path.parent, "metadata::custom-icon", "file://"+str(target.file_path)])
-                with Image.open(artwork_variant.target.file_path) as img:
-                    img.save(target.file_path, main_settings["image_format"])
-                    artwork_variant.target = Target
-
-    def download(self, data_object: DataObject, genre: str, **kwargs) -> DownloadResult:
-        # fetch the given object
-        self.fetch_details(data_object)
-        output(
-            f"\nDownloading {data_object.option_string}...", color=BColors.BOLD)
-
-        # 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
-
-        naming = kwargs.get("naming", {
-            "genre": [genre],
-            "audio_format": [main_settings["audio_format"]],
-            "image_format": [main_settings["image_format"]]
-        })
-
-        # download artist artwork
-        if isinstance(data_object, Artist):
-            self._fetch_artist_artwork(artist=data_object, naming=naming)
-
-        # download all children
-        download_result: DownloadResult = DownloadResult()
-        for c in data_object.get_child_collections():
-            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=naming)
-
-        return download_result
-
-    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])
-
-        return path_template
-
-    def _download_song(self, song: Song, naming: dict) -> DownloadOptions:
-        """
-        TODO
-        Search the song in the file system.
-        """
-        r = DownloadResult(total=1)
-
-        # pre process the data recursively
-        song.compile()
-
-        # manage the naming
-        naming: Dict[str, List[str]] = defaultdict(list, naming)
-        naming["song"].append(song.title_value)
-        naming["isrc"].append(song.isrc)
-        naming["album"].extend(a.title_value 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.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_value 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(value))
-        song.genre = naming["genre"][0]
-
-        # 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:
-            if target.exists:
-                output(
-                    f'{target.file_path} {BColors.OKGREEN.value}[already exists]', color=BColors.GREY)
-                r.found_on_disk += 1
-
-                if not self.download_options.download_again_if_found:
-                    target.copy_content(tmp)
-            else:
-                target.create_path()
-                output(f'{target.file_path}', color=BColors.GREY)
-
-        # 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:
-            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}."
-            return r
-
-        # post process the audio
-        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)
-
-        if not found_on_disk or self.download_options.process_metadata_if_found:
-            write_metadata_to_target(
-                metadata=song.metadata, target=tmp, song=song)
-
-        # copy the tmp target to the final locations
-        for target in song.target_collection:
-            tmp.copy_content(target)
-
-        tmp.delete()
-        return r
-
-    def fetch_url(self, url: str, stop_at_level: int = 2) -> Tuple[Type[Page], DataObject]:
-        source = Source.match_url(url, ALL_SOURCE_TYPES.MANUAL)
+        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)
+        
+        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.source_type]
-
-        return _actual_page, self._page_instances[_actual_page].fetch_object_from_source(source=source, stop_at_level=stop_at_level)
+        
+        _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

@@ -2,6 +2,7 @@ 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
 
 

music_kraken/objects/__init__.py

@@ -1,16 +1,27 @@
 from typing_extensions import TypeVar
-
-from .artwork import ArtworkCollection
-from .collection import Collection
-from .contact import Contact
-from .country import Country
-from .formatted_text import FormattedText
-from .metadata import ID3Timestamp
-from .metadata import Mapping as ID3Mapping
-from .metadata import Metadata
 from .option import Options
-from .parents import OuterProxy
-from .song import Album, Artist, Label, Lyrics, Song, Target
-from .source import Source, SourceType
 
-DatabaseObject = OuterProxy
+from .metadata import Metadata, Mapping as ID3Mapping, ID3Timestamp
+
+from .source import Source, SourcePages, SourceTypes
+
+from .song import (
+    Song,
+    Album,
+    Artist,
+    Target,
+    Lyrics,
+    Label
+)
+
+from .formatted_text import FormattedText
+from .collection import Collection
+
+from .country import Country
+from .contact import Contact
+
+from .parents import OuterProxy
+
+from .artwork import Artwork
+
+DatabaseObject = TypeVar('T', bound=OuterProxy)

music_kraken/objects/artwork.py

@@ -1,243 +1,62 @@
 from __future__ import annotations
 
-from copy import copy
-from dataclasses import dataclass, field
-from functools import cached_property
-from typing import Dict, List, Optional, Set, Tuple, Type, TypedDict, Union
+from typing import List, Optional, Dict, Tuple, Type, Union, TypedDict
 
-from ..connection import Connection
-from ..utils import create_dataclass_instance, custom_hash
-from ..utils.config import main_settings
-from ..utils.enums import PictureType
-from ..utils.string_processing import hash_url, unify
 from .collection import Collection
-from .metadata import ID3Timestamp
-from .metadata import Mapping as id3Mapping
-from .metadata import Metadata
+from .metadata import (
+    Mapping as id3Mapping,
+    ID3Timestamp,
+    Metadata
+)
+from ..utils.string_processing import unify, hash_url
+
 from .parents import OuterProxy as Base
-from .target import Target
-from PIL import Image
 
-import imagehash
-
-artwork_connection: Connection = Connection(module="artwork")
+from ..utils.config import main_settings
 
 
-@dataclass
-class ArtworkVariant:
+class ArtworkVariant(TypedDict):
     url: str
-    width: Optional[int] = None
-    heigth: Optional[int] = None
-    image_format: Optional[str] = None
+    width: int
+    height: int
+    deviation: float
 
-    def __hash__(self) -> int:
-        return custom_hash(self.url)
 
-    def __eq__(self, other: ArtworkVariant) -> bool:
-        return hash(self) == hash(other)
-
-    def __contains__(self, other: str) -> bool:
-        return custom_hash(other) == hash(self.url)
-
-    def __merge__(self, other: ArtworkVariant) -> None:
-        for key, value in other.__dict__.items():
-            if value is None:
-                continue
-
-            if getattr(self, key) is None:
-                setattr(self, key, value)
-
-    @cached_property
-    def target(self) -> Target:
-        return Target.temp()
-
-    def fetch(self) -> None:
-        global artwork_connection
-
-        r = artwork_connection.get(self.url, name=hash_url(self.url))
-        if r is None:
-            return
-
-        self.target.raw_content = r.content
-
-@dataclass
 class Artwork:
-    variants: List[ArtworkVariant] = field(default_factory=list)
+    def __init__(self, *variants: List[ArtworkVariant]) -> None:
+        self._variant_mapping: Dict[str, ArtworkVariant] = {}
 
-    artwork_type: PictureType = PictureType.OTHER
+        for variant in variants:
+            self.append(**variant)
 
-    def search_variant(self, url: str) -> Optional[ArtworkVariant]:
-        if url is None: 
-            return None
+    @staticmethod
+    def _calculate_deviation(*dimensions: List[int]) -> float:
+        return sum(abs(d - main_settings["preferred_artwork_resolution"]) for d in dimensions) / len(dimensions)
 
-        for variant in self.variants:
-            if url in variant:
-                return variant
-
-        return None
-
-    def __contains__(self, other: str) -> bool:
-        return self.search_variant(other) is not None
-
-    def add_data(self, **kwargs) -> None:
-        variant = self.search_variant(kwargs.get("url"))
-
-        if variant is None:
-            variant, kwargs = create_dataclass_instance(ArtworkVariant, kwargs)
-            self.variants.append(variant)
-
-        variant.__dict__.update(kwargs)
+    def append(self, url: str, width: int = main_settings["preferred_artwork_resolution"], height: int = main_settings["preferred_artwork_resolution"], **kwargs) -> None:
+        if url is None:
+            return
+        
+        self._variant_mapping[hash_url(url=url)] = {
+            "url": url,
+            "width": width,
+            "height": height,
+            "deviation": self._calculate_deviation(width, height),
+        }
 
     @property
-    def url(self) -> Optional[str]:
-        if len(self.variants) <= 0:
+    def best_variant(self) -> ArtworkVariant:
+        if len(self._variant_mapping.keys()) <= 0:
             return None
-        return self.variants[0].url
+        return min(self._variant_mapping.values(), key=lambda x: x["deviation"])
 
-    def fetch(self) -> None:
-        for variant in self.variants:
-            variant.fetch()
+    def get_variant_name(self, variant: ArtworkVariant) -> str:
+        return f"artwork_{variant['width']}x{variant['height']}_{hash_url(variant['url']).replace('/', '_')}"
 
+    def __merge__(self, other: Artwork, **kwargs) -> None:
+        for key, value in other._variant_mapping.items():
+            if key not in self._variant_mapping:
+                self._variant_mapping[key] = value
 
-class ArtworkCollection:
-    """
-    Stores all the images/artworks for one data object.
-    
-    There could be duplicates before calling ArtworkCollection.compile()  
-    _this is called before one object is downloaded automatically._
-    """
-
-    artwork_type: PictureType = PictureType.OTHER
-
-    def __init__(
-        self, 
-        *data: List[Artwork], 
-        parent_artworks: Set[ArtworkCollection] = None, 
-        crop_images: bool = True,
-    ) -> None:
-        # this is used for the song artwork, to fall back to the song artwork
-        self.parent_artworks: Set[ArtworkCollection] = parent_artworks or set()
-        self.crop_images: bool = crop_images
-        
-        self._data = []
-        self.extend(data)
-
-    def search_artwork(self, url: str) -> Optional[ArtworkVariant]:
-        for artwork in self._data:
-            if url in artwork:
-                return artwork
-
-        return None
-    
-    def __contains__(self, other: str) -> bool:
-        return self.search_artwork(other) is not None
-
-    def _create_new_artwork(self, **kwargs) -> Tuple[Artwork, dict]:
-        kwargs["artwork_type"] = kwargs.get("artwork_type", self.artwork_type)
-
-        return create_dataclass_instance(Artwork, dict(**kwargs))
-
-    def add_data(self, url: str, **kwargs) -> Artwork:
-        kwargs["url"] = url
-
-        artwork = self.search_artwork(url)
-
-        if artwork is None:
-            artwork, kwargs = self._create_new_artwork(**kwargs)
-            self._data.append(artwork)
-
-        artwork.add_data(**kwargs)
-        return artwork
-
-    def append(self, value: Union[Artwork, ArtworkVariant, dict], **kwargs):
-        """
-        You can append the types Artwork, ArtworkVariant or dict 
-        the best option would be to use Artwork and avoid the other options.
-        """
-        if isinstance(value, dict):
-            kwargs.update(value)
-            value, kwargs = create_dataclass_instance(ArtworkVariant, kwargs)
-        
-        if isinstance(value, ArtworkVariant):
-            kwargs["variants"] = [value]
-            value, kwargs = create_dataclass_instance(Artwork, kwargs)
-
-        if isinstance(value, Artwork):
-            self._data.append(value)
-            return
-    
-    def extend(self, values: List[Union[Artwork, ArtworkVariant, dict]], **kwargs):
-        for value in values:
-            self.append(value, **kwargs)
-
-    def compile(self, **kwargs) -> None:
-        """
-        This will make the artworks ready for download and delete duplicates.
-        """
-        artwork_hashes: list = list()
-        artwork_urls: list = list()
-        for artwork in self._data:
-            index = 0
-            for artwork_variant in artwork.variants:
-                r = artwork_connection.get(
-                    url=artwork_variant.url,
-                    name=artwork_variant.url,
-                )
-
-                if artwork_variant.url in artwork_urls:
-                    artwork.variants.pop(index)
-                    continue
-                artwork_urls.append(artwork_variant.url)
-
-                target: Target = artwork_variant.target
-                with target.open("wb") as f:
-                    f.write(r.content)
-
-                with Image.open(target.file_path) as img:
-                    # https://stackoverflow.com/a/59476938/16804841
-                    if img.mode != 'RGB':
-                        img = img.convert('RGB')
-                    
-                    try:
-                        image_hash = imagehash.crop_resistant_hash(img)
-                    except Exception as e:
-                        continue
-
-                    if image_hash in artwork_hashes:
-                        artwork.variants.pop(index)
-                        target.delete()
-                        continue
-                    artwork_hashes.append(image_hash)
-                    width, height = img.size
-                    if width != height:
-                        if width > height:
-                            img = img.crop((width // 2 - height // 2, 0, width // 2 + height // 2, height))
-                        else:
-                            img = img.crop((0, height // 2 - width // 2, width, height // 2 + width // 2))
-
-                        # resize the image to the preferred resolution
-                        img.thumbnail((main_settings["preferred_artwork_resolution"], main_settings["preferred_artwork_resolution"]))
-                        index =+ 1
-                    
-                    
-
-    def __merge__(self, other: ArtworkCollection, **kwargs) -> None:
-        self.parent_artworks.update(other.parent_artworks)
-        for other_artwork in other._data:
-            for other_variant in other_artwork.variants:
-                if self.__contains__(other_variant.url):
-                    continue
-                self.append(ArtworkVariant(other_variant.url))
-
-
-    def __hash__(self) -> int:
-        return id(self)
-
-    def __iter__(self) -> Generator[Artwork, None, None]:
-        yield from self._data
-
-    def get_urls(self) -> Generator[str, None, None]:
-        yield from (artwork.url for artwork in self._data if artwork.url is not None)
-
-    
-    
+    def __eq__(self, other: Artwork) -> bool:
+        return any(a == b for a, b in zip(self._variant_mapping.keys(), other._variant_mapping.keys()))

music_kraken/objects/collection.py

@@ -1,43 +1,16 @@
 from __future__ import annotations
 
-import copy
 from collections import defaultdict
-from dataclasses import dataclass
-from typing import (Any, Callable, Dict, Generator, Generic, Iterable,
-                    Iterator, List, Optional, Set, Tuple, TypeVar, Union)
+from typing import TypeVar, Generic, Dict, Optional, Iterable, List, Iterator, Tuple, Generator, Union, Any, Set
+import copy
 
-from ..utils import BColors, object_trace, output
-from .parents import InnerData, OuterProxy
+from .parents import OuterProxy
+from ..utils import object_trace
+from ..utils import output, BColors
 
 T = TypeVar('T', bound=OuterProxy)
 
 
-@dataclass
-class AppendHookArguments:
-    """
-    This class is used to store the arguments for the append hook.
-    The best explanation is with an examples:
-    
-    ```
-    album = Album()  
-    song = Song()  
-    album.song_collection.append(song)  
-    ```
-
-    In this case, the append hook is triggered with the following arguments:
-    ```
-    AppendHookArguments(  
-        collection=album.song_collection,  
-        new_object=song,  
-        collection_root_objects=[album]  
-    )  
-    ```
-    """
-
-    collection: Collection
-    new_object: T
-    collection_root_objects: Set[InnerData]
-
 class Collection(Generic[T]):
     __is_collection__ = True
 
@@ -54,7 +27,6 @@ class Collection(Generic[T]):
             sync_on_append: Dict[str, Collection] = None,
             append_object_to_attribute: Dict[str, T] = None,
             extend_object_to_attribute: Dict[str, Collection] = None,
-            append_callbacks: Set[Callable[[AppendHookArguments], None]] = None,
     ) -> None:
         self._collection_for: dict = dict()
 
@@ -69,7 +41,6 @@ class Collection(Generic[T]):
         self.sync_on_append: Dict[str, Collection] = sync_on_append or {}
         self.pull_from: List[Collection] = []
         self.push_to: List[Collection] = []
-        self.append_callbacks: Set[Callable[[AppendHookArguments], None]] = append_callbacks or set()
 
         # This is to cleanly unmap previously mapped items by their id
         self._indexed_from_id: Dict[int, Dict[str, Any]] = defaultdict(dict)
@@ -144,6 +115,13 @@ class Collection(Generic[T]):
         self._data.append(other)
         other._inner._is_in_collection.add(self)
 
+        # all of the existing hooks to get the defined datastructures
+        for collection_attribute, generator in self.extend_object_to_attribute.items():
+            other.__getattribute__(collection_attribute).extend(generator, **kwargs)
+
+        for attribute, new_object in self.append_object_to_attribute.items():
+            other.__getattribute__(attribute).append(new_object, **kwargs)
+
         for attribute, a in self.sync_on_append.items():
             # syncing two collections by reference
             b = other.__getattribute__(attribute)
@@ -163,21 +141,6 @@ class Collection(Generic[T]):
 
             a.extend(b_data, **kwargs)
 
-        # all of the existing hooks to get the defined datastructures
-        for collection_attribute, generator in self.extend_object_to_attribute.items():
-            other.__getattribute__(collection_attribute).extend(generator, **kwargs)
-
-        for attribute, new_object in self.append_object_to_attribute.items():
-            other.__getattribute__(attribute).append(new_object, **kwargs)
-
-        append_hook_args = AppendHookArguments(
-            collection=self,
-            new_object=other,
-            collection_root_objects=self._collection_for.keys(),
-        )
-        for callback in self.append_callbacks:
-            callback(append_hook_args)
-
     def append(self, other: Optional[T], **kwargs):
         """
         If an object, that represents the same entity exists in a relevant collection,
@@ -197,7 +160,6 @@ class Collection(Generic[T]):
 
         object_trace(f"Appending {other.option_string} to {self}")
 
-
         # switching collection in the case of push to
         for c in self.push_to:
             r = c._find_object(other)

music_kraken/objects/formatted_text.py

@@ -37,22 +37,9 @@ class FormattedText:
     @property
     def markdown(self) -> str:
         return md(self.html).strip()
-    
-    @markdown.setter
-    def markdown(self, value: str) -> None:
-        self.html = mistune.markdown(value)
-
-    @property
-    def plain(self) -> str:
-        md = self.markdown
-        return md.replace("\n\n", "\n")
-    
-    @plain.setter
-    def plain(self, value: str) -> None:
-        self.html = mistune.markdown(plain_to_markdown(value))
 
     def __str__(self) -> str:
         return self.markdown
 
-    plaintext = plain
+    plaintext = markdown
     

music_kraken/objects/lyrics.py

@@ -34,6 +34,6 @@ class Lyrics(OuterProxy):
     @property
     def metadata(self) -> Metadata:
         return Metadata({
-            id3Mapping.UNSYNCED_LYRICS: [self.text.plaintext]
+            id3Mapping.UNSYNCED_LYRICS: [self.text.markdown]
         })
 

music_kraken/objects/metadata.py

@@ -92,7 +92,7 @@ class Mapping(Enum):
         key = attribute.value
 
         if key[0] == 'T':
-            # a text field
+            # a text fiel
             return cls.get_text_instance(key, value)
         if key[0] == "W":
             # an url field
@@ -355,12 +355,7 @@ class Metadata:
             return None
 
         list_data = self.id3_dict[field]
-        #correct duplications
-        correct_list_data = list()
-        for data in list_data:
-            if data not in correct_list_data:
-                correct_list_data.append(data)
-        list_data = correct_list_data
+
         # convert for example the time objects to timestamps
         for i, element in enumerate(list_data):
             # for performance’s sake I don't do other checks if it is already the right type
@@ -373,7 +368,7 @@ class Metadata:
             if type(element) == ID3Timestamp:
                 list_data[i] = element.timestamp
                 continue
-            
+
         """
         Version 2.4 of the specification prescribes that all text fields (the fields that start with a T, except for TXXX) can contain multiple values separated by a null character. 
         Thus if above conditions are met, I concatenate the list,
@@ -381,7 +376,7 @@ class Metadata:
         """
         if field.value[0].upper() == "T" and field.value.upper() != "TXXX":
             return self.NULL_BYTE.join(list_data)
-        
+
         return list_data[0]
 
     def get_mutagen_object(self, field):
@@ -400,5 +395,6 @@ class Metadata:
         """
         # set the tagging timestamp to the current time
         self.__setitem__(Mapping.TAGGING_TIME, [ID3Timestamp.now()])
+
         for field in self.id3_dict:
             yield self.get_mutagen_object(field)

music_kraken/objects/parents.py

@@ -8,7 +8,6 @@ from typing import Optional, Dict, Tuple, List, Type, Generic, Any, TypeVar, Set
 from pathlib import Path
 import inspect
 
-from .source import SourceCollection
 from .metadata import Metadata
 from ..utils import get_unix_time, object_trace, generate_id
 from ..utils.config import logging_settings, main_settings
@@ -100,9 +99,7 @@ class OuterProxy:
     Wraps the inner data, and provides apis, to naturally access those values.
     """
 
-    source_collection: SourceCollection
-
-    _default_factories: dict = {"source_collection": SourceCollection}
+    _default_factories: dict = {}
     _outer_attribute: Set[str] = {"options", "metadata", "indexing_values", "option_string"}
 
     DOWNWARDS_COLLECTION_STRING_ATTRIBUTES = tuple()
@@ -206,7 +203,6 @@ class OuterProxy:
         if __other is None:
             return
 
-        a_id = self.id
 
         a = self
         b = __other
@@ -229,8 +225,6 @@ class OuterProxy:
         a._inner.__merge__(old_inner, **kwargs)
         del old_inner
 
-        self.id = a_id
-
     def __merge__(self, __other: Optional[OuterProxy], **kwargs):
         self.merge(__other, **kwargs)
 
@@ -307,49 +301,10 @@ class OuterProxy:
 
         return r
 
-    @property
-    def root_collections(self) -> List[Collection]:
-        if len(self.UPWARDS_COLLECTION_STRING_ATTRIBUTES) == 0:
-            return [self]
-
-        r = []
-        for collection_string_attribute in self.UPWARDS_COLLECTION_STRING_ATTRIBUTES:
-            r.extend(self.__getattribute__(collection_string_attribute))
-
-        return r
-
-    def _compile(self, **kwargs):
-        pass
-
-    def compile(self, from_root=False, **kwargs):
-        # compile from the root
-        if not from_root:
-            for c in self.root_collections:
-                c.compile(from_root=True, **kwargs)
-            return
-
-        self._compile(**kwargs)
-
-        for c_attribute in self.DOWNWARDS_COLLECTION_STRING_ATTRIBUTES:
-            for c in self.__getattribute__(c_attribute):
-                c.compile(from_root=True, **kwargs)
-
     TITEL = "id"
     @property
     def title_string(self) -> str:
         return str(self.__getattribute__(self.TITEL)) + (f" {self.id}" if DEBUG_PRINT_ID else "")
 
-    @property
-    def title_value(self) -> str:
-        return str(self.__getattribute__(self.TITEL))
-
     def __repr__(self):
         return f"{type(self).__name__}({self.title_string})"
-
-    def get_child_collections(self):
-        for collection_string_attribute in self.DOWNWARDS_COLLECTION_STRING_ATTRIBUTES:
-            yield self.__getattribute__(collection_string_attribute)
-
-    def get_parent_collections(self):
-        for collection_string_attribute in self.UPWARDS_COLLECTION_STRING_ATTRIBUTES:
-            yield self.__getattribute__(collection_string_attribute)

music_kraken/objects/song.py

@@ -1,32 +1,35 @@
 from __future__ import annotations
 
-import copy
 import random
 from collections import defaultdict
-from typing import Dict, List, Optional, Tuple, Type, Union
+from typing import List, Optional, Dict, Tuple, Type, Union
+import copy
 
 import pycountry
 
-from ..utils.config import main_settings
-from ..utils.enums.album import AlbumStatus, AlbumType
-from ..utils.enums.colors import BColors
-from ..utils.shared import DEBUG_PRINT_ID
-from ..utils.string_processing import unify
-from .artwork import ArtworkCollection
-from .collection import AppendHookArguments, Collection
-from .contact import Contact
-from .country import Country, Language
+from ..utils.enums.album import AlbumType, AlbumStatus
+from .collection import Collection
 from .formatted_text import FormattedText
 from .lyrics import Lyrics
-from .metadata import ID3Timestamp
-from .metadata import Mapping as id3Mapping
-from .metadata import Metadata
+from .contact import Contact
+from .artwork import Artwork
+from .metadata import (
+    Mapping as id3Mapping,
+    ID3Timestamp,
+    Metadata
+)
 from .option import Options
-from .parents import OuterProxy
-from .parents import OuterProxy as Base
-from .parents import P
+from .parents import OuterProxy, P
 from .source import Source, SourceCollection
 from .target import Target
+from .country import Language, Country
+from ..utils.shared import DEBUG_PRINT_ID
+from ..utils.string_processing import unify
+
+from .parents import OuterProxy as Base
+
+from ..utils.config import main_settings
+from ..utils.enums.colors import BColors
 
 """
 All Objects dependent 
@@ -86,13 +89,13 @@ class Song(Base):
     genre: str
     note: FormattedText
     tracksort: int
-    artwork: ArtworkCollection
+    artwork: Artwork
 
     source_collection: SourceCollection
     target_collection: Collection[Target]
     lyrics_collection: Collection[Lyrics]
 
-    artist_collection: Collection[Artist]
+    main_artist_collection: Collection[Artist]
     feature_artist_collection: Collection[Artist]
     album_collection: Collection[Album]
 
@@ -102,10 +105,10 @@ class Song(Base):
         "source_collection": SourceCollection,
         "target_collection": Collection,
         "lyrics_collection": Collection,
-        "artwork": ArtworkCollection,
+        "artwork": Artwork,
 
+        "main_artist_collection": Collection,
         "album_collection": Collection,
-        "artist_collection": Collection,
         "feature_artist_collection": Collection,
 
         "title": lambda: None,
@@ -126,11 +129,11 @@ class Song(Base):
         source_list: List[Source] = None,
         target_list: List[Target] = None, 
         lyrics_list: List[Lyrics] = None,
-        artist_list: List[Artist] = None, 
+        main_artist_list: List[Artist] = None, 
         feature_artist_list: List[Artist] = None,
         album_list: List[Album] = None, 
         tracksort: int = 0, 
-        artwork: Optional[ArtworkCollection] = None, 
+        artwork: Optional[Artwork] = None, 
         **kwargs
     ) -> None:
         real_kwargs = copy.copy(locals())
@@ -138,35 +141,26 @@ class Song(Base):
 
         Base.__init__(**real_kwargs)
 
-    UPWARDS_COLLECTION_STRING_ATTRIBUTES = ("artist_collection", "feature_artist_collection", "album_collection")
+    UPWARDS_COLLECTION_STRING_ATTRIBUTES = ("main_artist_collection", "feature_artist_collection", "album_collection")
     TITEL = "title"
 
-    @staticmethod
-    def register_artwork_parent(append_hook_arguments: AppendHookArguments):
-        album: Album = append_hook_arguments.new_object
-
-        song: Song
-        for song in append_hook_arguments.collection_root_objects:
-            song.artwork.parent_artworks.add(album.artwork)
-
     def __init_collections__(self) -> None:
-        self.feature_artist_collection.push_to = [self.artist_collection]
-        self.artist_collection.pull_from = [self.feature_artist_collection]
-
         self.album_collection.sync_on_append = {
-            "artist_collection": self.artist_collection,
+            "artist_collection": self.main_artist_collection,
         }
 
         self.album_collection.append_object_to_attribute = {
             "song_collection": self,
         }
-        self.artist_collection.extend_object_to_attribute = {
-            "album_collection": self.album_collection
+        self.main_artist_collection.extend_object_to_attribute = {
+            "main_album_collection": self.album_collection
         }
-        self.feature_artist_collection.extend_object_to_attribute = {
-            "album_collection": self.album_collection
+        self.feature_artist_collection.append_object_to_attribute = {
+            "feature_song_collection": self
         }
-        self.album_collection.append_callbacks = set((Song.register_artwork_parent, ))
+
+        self.feature_artist_collection.push_to = [self.main_artist_collection]
+        self.main_artist_collection.pull_from = [self.feature_artist_collection]
 
     def _add_other_db_objects(self, object_type: Type[OuterProxy], object_list: List[OuterProxy]):
         if object_type is Song:
@@ -184,10 +178,6 @@ class Song(Base):
             self.album_collection.extend(object_list)
             return
 
-    def _compile(self):
-        self.artwork.compile()
-
-
     INDEX_DEPENDS_ON = ("title", "isrc", "source_collection")
 
     @property
@@ -213,14 +203,14 @@ class Song(Base):
 
         # metadata.merge_many([s.get_song_metadata() for s in self.source_collection])  album sources have no relevant metadata for id3
         metadata.merge_many([a.metadata for a in self.album_collection])
-        metadata.merge_many([a.metadata for a in self.artist_collection])
+        metadata.merge_many([a.metadata for a in self.main_artist_collection])
         metadata.merge_many([a.metadata for a in self.feature_artist_collection])
         metadata.merge_many([lyrics.metadata for lyrics in self.lyrics_collection])
 
         return metadata
 
     def get_artist_credits(self) -> str:
-        main_artists = ", ".join([artist.name for artist in self.artist_collection])
+        main_artists = ", ".join([artist.name for artist in self.main_artist_collection])
         feature_artists = ", ".join([artist.name for artist in self.feature_artist_collection])
 
         if len(feature_artists) == 0:
@@ -229,11 +219,10 @@ class Song(Base):
 
     @property
     def option_string(self) -> str:
-        r = "song "
-        r += OPTION_FOREGROUND.value + self.title_string + BColors.ENDC.value + OPTION_BACKGROUND.value
+        r = OPTION_FOREGROUND.value + self.title_string + BColors.ENDC.value + OPTION_BACKGROUND.value
         r += get_collection_string(self.album_collection, " from {}", ignore_titles={self.title})
-        r += get_collection_string(self.artist_collection, " by {}")
-        r += get_collection_string(self.feature_artist_collection, " feat. {}" if len(self.artist_collection) > 0 else " by {}")
+        r += get_collection_string(self.main_artist_collection, " by {}")
+        r += get_collection_string(self.feature_artist_collection, " feat. {}")
         return r
 
     @property
@@ -248,6 +237,11 @@ class Song(Base):
         return f"{self.tracksort}/{len(self.album_collection[0].song_collection) or 1}"
 
 
+"""
+All objects dependent on Album
+"""
+
+
 class Album(Base):
     title: str
     unified_title: str
@@ -259,12 +253,10 @@ class Album(Base):
     albumsort: int
     notes: FormattedText
 
-    artwork: ArtworkCollection
     source_collection: SourceCollection
 
-    song_collection: Collection[Song]
     artist_collection: Collection[Artist]
-    feature_artist_collection: Collection[Artist]
+    song_collection: Collection[Song]
     label_collection: Collection[Label]
 
     _default_factories = {
@@ -279,12 +271,9 @@ class Album(Base):
         "date": ID3Timestamp,
         "notes": FormattedText,
 
-        "artwork": lambda: ArtworkCollection(crop_images=False),
         "source_collection": SourceCollection,
-
-        "song_collection": Collection,
         "artist_collection": Collection,
-        "feature_artist_collection": Collection,
+        "song_collection": Collection,
         "label_collection": Collection,
     }
 
@@ -302,7 +291,6 @@ class Album(Base):
         barcode: str = None, 
         albumsort: int = None, 
         notes: FormattedText = None,
-        artwork: ArtworkCollection = None,
         source_list: List[Source] = None, 
         artist_list: List[Artist] = None, 
         song_list: List[Song] = None,
@@ -317,33 +305,21 @@ class Album(Base):
     DOWNWARDS_COLLECTION_STRING_ATTRIBUTES = ("song_collection",)
     UPWARDS_COLLECTION_STRING_ATTRIBUTES = ("label_collection", "artist_collection")
 
-    @staticmethod
-    def register_artwork_parent(append_hook_arguments: AppendHookArguments):
-        song: Song = append_hook_arguments.new_object
-
-        for root_object in append_hook_arguments.collection_root_objects:
-            song.artwork.parent_artworks.add(root_object.artwork)
-
     def __init_collections__(self):
-        self.feature_artist_collection.push_to = [self.artist_collection]
-        self.artist_collection.pull_from = [self.feature_artist_collection]
-
         self.song_collection.append_object_to_attribute = {
             "album_collection": self
         }
         self.song_collection.sync_on_append = {
-            "artist_collection": self.artist_collection
+            "main_artist_collection": self.artist_collection
         }
 
         self.artist_collection.append_object_to_attribute = {
-            "album_collection": self
+            "main_album_collection": self
         }
         self.artist_collection.extend_object_to_attribute = {
             "label_collection": self.label_collection
         }
 
-        self.song_collection.append_callbacks = set((Album.register_artwork_parent, ))
-
     def _add_other_db_objects(self, object_type: Type[OuterProxy], object_list: List[OuterProxy]):
         if object_type is Song:
             self.song_collection.extend(object_list)
@@ -392,37 +368,14 @@ class Album(Base):
 
     @property
     def option_string(self) -> str:
-        r = "album "
-        r += OPTION_FOREGROUND.value + self.title_string + BColors.ENDC.value + OPTION_BACKGROUND.value
+        r = OPTION_FOREGROUND.value + self.title_string + BColors.ENDC.value + OPTION_BACKGROUND.value
         r += get_collection_string(self.artist_collection, " by {}")
-        if len(self.artist_collection) <= 0:
-            r += get_collection_string(self.feature_artist_collection, " by {}")
         r += get_collection_string(self.label_collection, " under {}")
 
         if len(self.song_collection) > 0:
             r += f" with {len(self.song_collection)} songs"
         return r
 
-    def _compile(self):
-        self.analyze_implied_album_type()
-        self.update_tracksort()
-        self.fix_artist_collection()
-
-    def analyze_implied_album_type(self):
-        # if the song collection has only one song, it is reasonable to assume that it is a single
-        if len(self.song_collection) == 1:
-            self.album_type = AlbumType.SINGLE
-            return
-
-        # if the album already has an album type, we don't need to do anything
-        if self.album_type is not AlbumType.OTHER:
-            return
-
-        # for information on EP's I looked at https://www.reddit.com/r/WeAreTheMusicMakers/comments/a354ql/whats_the_cutoff_length_between_ep_and_album/
-        if len(self.song_collection) < 9:
-            self.album_type = AlbumType.EP
-            return
-
     def update_tracksort(self):
         """
         This updates the tracksort attributes, of the songs in
@@ -448,16 +401,6 @@ class Album(Base):
                 tracksort_map[i] = existing_list.pop(0)
                 tracksort_map[i].tracksort = i
 
-    def fix_artist_collection(self):
-        """
-        I add artists, that could only be feature artists to the feature artist collection.
-        They get automatically moved to main artist collection, if a matching artist exists in the main artist collection or is appended to it later on.
-        If I am not sure for any artist, I try to analyze the most common artist in the song collection of one album.
-        """
-
-        # move all artists that are in all feature_artist_collections, of every song, to the artist_collection
-        pass
-
     @property
     def copyright(self) -> str:
         if self.date is None:
@@ -499,12 +442,11 @@ class Artist(Base):
     general_genre: str
     unformatted_location: str
 
-    artwork: ArtworkCollection
-
     source_collection: SourceCollection
     contact_collection: Collection[Contact]
 
-    album_collection: Collection[Album]
+    feature_song_collection: Collection[Song]
+    main_album_collection: Collection[Album]
     label_collection: Collection[Label]
 
     _default_factories = {
@@ -517,10 +459,9 @@ class Artist(Base):
         "lyrical_themes": list,
         "general_genre": lambda: "",
 
-        "artwork": ArtworkCollection,
-
         "source_collection": SourceCollection,
-        "album_collection": Collection,
+        "feature_song_collection": Collection,
+        "main_album_collection": Collection,
         "contact_collection": Collection,
         "label_collection": Collection,
     }
@@ -537,12 +478,11 @@ class Artist(Base):
         notes: FormattedText = None, 
         lyrical_themes: List[str] = None,
         general_genre: str = None, 
-        artwork: ArtworkCollection = None,
         unformatted_location: str = None, 
         source_list: List[Source] = None,
         contact_list: List[Contact] = None, 
         feature_song_list: List[Song] = None,
-        album_list: List[Album] = None, 
+        main_album_list: List[Album] = None, 
         label_list: List[Label] = None, 
         **kwargs
     ) -> None:
@@ -552,14 +492,18 @@ class Artist(Base):
         Base.__init__(**real_kwargs)
 
 
-    DOWNWARDS_COLLECTION_STRING_ATTRIBUTES = ("album_collection",)
+    DOWNWARDS_COLLECTION_STRING_ATTRIBUTES = ("main_album_collection", "feature_song_collection")
     UPWARDS_COLLECTION_STRING_ATTRIBUTES = ("label_collection",)
 
     def __init_collections__(self):
-        self.album_collection.append_object_to_attribute = {
+        self.feature_song_collection.append_object_to_attribute = {
             "feature_artist_collection": self
         }
 
+        self.main_album_collection.append_object_to_attribute = {
+            "artist_collection": self
+        }
+
         self.label_collection.append_object_to_attribute = {
             "current_artist_collection": self
         }
@@ -567,32 +511,33 @@ class Artist(Base):
     def _add_other_db_objects(self, object_type: Type[OuterProxy], object_list: List[OuterProxy]):
         if object_type is Song:
             # this doesn't really make sense
+            # self.feature_song_collection.extend(object_list)
             return
 
         if object_type is Artist:
             return
 
         if object_type is Album:
-            self.album_collection.extend(object_list)
+            self.main_album_collection.extend(object_list)
             return
 
         if object_type is Label:
             self.label_collection.extend(object_list)
             return
 
-    def _compile(self):
-        self.update_albumsort()
-
     def update_albumsort(self):
         """
         This updates the albumsort attributes, of the albums in
-        `self.album_collection`, and sorts the albums, if possible.
+        `self.main_album_collection`, and sorts the albums, if possible.
 
         It is advised to only call this function, once all the albums are
         added to the artist.
 
         :return:
         """
+        if len(self.main_album_collection) <= 0:
+            return
+
         type_section: Dict[AlbumType, int] = defaultdict(lambda: 2, {
             AlbumType.OTHER: 0,  # if I don't know it, I add it to the first section
             AlbumType.STUDIO_ALBUM: 0,
@@ -604,7 +549,7 @@ class Artist(Base):
 
         # order albums in the previously defined section
         album: Album
-        for album in self.album_collection:
+        for album in self.main_album_collection:
             sections[type_section[album.album_type]].append(album)
 
         def sort_section(_section: List[Album], last_albumsort: int) -> int:
@@ -635,7 +580,7 @@ class Artist(Base):
             album_list.extend(sections[section_index])
 
         # replace the old collection with the new one
-        self.album_collection._data = album_list
+        self.main_album_collection: Collection = Collection(data=album_list, element_type=Album)
 
     INDEX_DEPENDS_ON = ("name", "source_collection", "contact_collection")
     @property
@@ -657,14 +602,15 @@ class Artist(Base):
 
     @property
     def option_string(self) -> str:
-        r = "artist "
-        r += OPTION_FOREGROUND.value + self.title_string + BColors.ENDC.value + OPTION_BACKGROUND.value
+        r = OPTION_FOREGROUND.value + self.title_string + BColors.ENDC.value + OPTION_BACKGROUND.value
         r += get_collection_string(self.label_collection, " under {}")
         
         r += OPTION_BACKGROUND.value
-        if len(self.album_collection) > 0:
-            r += f" with {len(self.album_collection)} albums"
+        if len(self.main_album_collection) > 0:
+            r += f" with {len(self.main_album_collection)} albums"
         
+        if len(self.feature_song_collection) > 0:
+            r += f" featured in {len(self.feature_song_collection)} songs"
         r += BColors.ENDC.value
 
         return r
@@ -751,4 +697,4 @@ class Label(Base):
 
     @property
     def option_string(self):
-        return "label " + OPTION_FOREGROUND.value + self.name + BColors.ENDC.value
+        return OPTION_FOREGROUND.value + self.name + BColors.ENDC.value

music_kraken/objects/source.py

@@ -2,48 +2,40 @@ from __future__ import annotations
 
 from collections import defaultdict
 from enum import Enum
-from typing import (
-    List, 
-    Dict, 
-    Set, 
-    Tuple, 
-    Optional, 
-    Iterable, 
-    Generator, 
-    TypedDict, 
-    Callable, 
-    Any,
-    TYPE_CHECKING
-)
+from typing import List, Dict, Set, Tuple, Optional, Iterable, Generator
 from urllib.parse import urlparse, ParseResult
 from dataclasses import dataclass, field
 from functools import cached_property
 
 from ..utils import generate_id
-from ..utils.enums import SourceType, ALL_SOURCE_TYPES
+from ..utils.enums.source import SourcePages, SourceTypes
 from ..utils.config import youtube_settings
 from ..utils.string_processing import hash_url, shorten_display_url
 
 from .metadata import Mapping, Metadata
-if TYPE_CHECKING:
-    from ..pages.abstract import Page
+from .parents import OuterProxy
+from .collection import Collection
 
 
 
 @dataclass
 class Source:
-    source_type: SourceType
+    page_enum: SourcePages
     url: str
-    referrer_page: SourceType = None
+    referrer_page: SourcePages = None
     audio_url: Optional[str] = None
 
     additional_data: dict = field(default_factory=dict)
 
     def __post_init__(self):
-        self.referrer_page = self.referrer_page or self.source_type
+        self.referrer_page = self.referrer_page or self.page_enum
+    
+    @property
+    def parsed_url(self) -> ParseResult:
+        return urlparse(self.url)
 
     @classmethod
-    def match_url(cls, url: str, referrer_page: SourceType) -> Optional[Source]:
+    def match_url(cls, url: str, referrer_page: SourcePages) -> Optional[Source]:
         """
         this shouldn't be used, unless you are not certain what the source is for
         the reason is that it is more inefficient
@@ -52,50 +44,38 @@ class Source:
         url = parsed_url.geturl()
         
         if "musify" in parsed_url.netloc:
-            return cls(ALL_SOURCE_TYPES.MUSIFY, url, referrer_page=referrer_page)
+            return cls(SourcePages.MUSIFY, url, referrer_page=referrer_page)
 
         if parsed_url.netloc in [_url.netloc for _url in youtube_settings['youtube_url']]:
-            return cls(ALL_SOURCE_TYPES.YOUTUBE, url, referrer_page=referrer_page)
+            return cls(SourcePages.YOUTUBE, url, referrer_page=referrer_page)
 
         if url.startswith("https://www.deezer"):
-            return cls(ALL_SOURCE_TYPES.DEEZER, url, referrer_page=referrer_page)
+            return cls(SourcePages.DEEZER, url, referrer_page=referrer_page)
         
         if url.startswith("https://open.spotify.com"):
-            return cls(ALL_SOURCE_TYPES.SPOTIFY, url, referrer_page=referrer_page)
+            return cls(SourcePages.SPOTIFY, url, referrer_page=referrer_page)
 
         if "bandcamp" in url:
-            return cls(ALL_SOURCE_TYPES.BANDCAMP, url, referrer_page=referrer_page)
+            return cls(SourcePages.BANDCAMP, url, referrer_page=referrer_page)
 
         if "wikipedia" in parsed_url.netloc:
-            return cls(ALL_SOURCE_TYPES.WIKIPEDIA, url, referrer_page=referrer_page)
+            return cls(SourcePages.WIKIPEDIA, url, referrer_page=referrer_page)
 
         if url.startswith("https://www.metal-archives.com/"):
-            return cls(ALL_SOURCE_TYPES.ENCYCLOPAEDIA_METALLUM, url, referrer_page=referrer_page)
+            return cls(SourcePages.ENCYCLOPAEDIA_METALLUM, url, referrer_page=referrer_page)
 
         # the less important once
         if url.startswith("https://www.facebook"):
-            return cls(ALL_SOURCE_TYPES.FACEBOOK, url, referrer_page=referrer_page)
+            return cls(SourcePages.FACEBOOK, url, referrer_page=referrer_page)
 
         if url.startswith("https://www.instagram"):
-            return cls(ALL_SOURCE_TYPES.INSTAGRAM, url, referrer_page=referrer_page)
+            return cls(SourcePages.INSTAGRAM, url, referrer_page=referrer_page)
 
         if url.startswith("https://twitter"):
-            return cls(ALL_SOURCE_TYPES.TWITTER, url, referrer_page=referrer_page)
+            return cls(SourcePages.TWITTER, url, referrer_page=referrer_page)
 
         if url.startswith("https://myspace.com"):
-            return cls(ALL_SOURCE_TYPES.MYSPACE, url, referrer_page=referrer_page)
-
-    @property
-    def has_page(self) -> bool:
-        return self.source_type.page is not None
-    
-    @property
-    def page(self) -> Page:
-        return self.source_type.page
-
-    @property
-    def parsed_url(self) -> ParseResult:
-        return urlparse(self.url)
+            return cls(SourcePages.MYSPACE, url, referrer_page=referrer_page)
 
     @property
     def hash_url(self) -> str:
@@ -109,82 +89,37 @@ class Source:
         return r
 
     def __repr__(self) -> str:
-        return f"Src({self.source_type.value}: {shorten_display_url(self.url)})"
+        return f"Src({self.page_enum.value}: {shorten_display_url(self.url)})"
 
     def __merge__(self, other: Source, **kwargs):
         if self.audio_url is None:
             self.audio_url = other.audio_url
         self.additional_data.update(other.additional_data)
 
-    page_str = property(fget=lambda self: self.source_type.value)
-
-
-class SourceTypeSorting(TypedDict):
-    sort_key: Callable[[SourceType], Any]
-    reverse: bool
-    only_with_page: bool
+    page_str = property(fget=lambda self: self.page_enum.value)
 
 
 class SourceCollection:
     __change_version__ = generate_id()
 
     _indexed_sources: Dict[str, Source]
-    _sources_by_type: Dict[SourceType, List[Source]]
+    _page_to_source_list: Dict[SourcePages, List[Source]]
 
     def __init__(self, data: Optional[Iterable[Source]] = None, **kwargs):
-        self._sources_by_type = defaultdict(list)
+        self._page_to_source_list = defaultdict(list)
         self._indexed_sources = {}
 
         self.extend(data or [])
 
-    def source_types(
-        self, 
-        only_with_page: bool = False, 
-        sort_key = lambda page: page.name, 
-        reverse: bool = False
-    ) -> Iterable[SourceType]:
-        """
-        Returns a list of all source types contained in this source collection.
+    def has_source_page(self, *source_pages: SourcePages) -> bool:
+        return any(source_page in self._page_to_source_list for source_page in source_pages)
 
-        Args:
-            only_with_page (bool, optional): If True, only returns source types that have a page, meaning you can download from them.
-            sort_key (function, optional): A function that defines the sorting key for the source types. Defaults to lambda page: page.name.
-            reverse (bool, optional): If True, sorts the source types in reverse order. Defaults to False.
+    def get_sources(self, *source_pages: List[Source]) -> Generator[Source]:
+        if not len(source_pages):
+            source_pages = self.source_pages
 
-        Returns:
-            Iterable[SourceType]: A list of source types.
-        """
-
-        source_types: List[SourceType] = self._sources_by_type.keys()
-        if only_with_page:
-            source_types = filter(lambda st: st.has_page, source_types)
-
-        return sorted(
-            source_types, 
-            key=sort_key, 
-            reverse=reverse
-        )
-
-    def get_sources(self, *source_types: List[SourceType], source_type_sorting: SourceTypeSorting = None) -> Generator[Source]:
-            """
-            Retrieves sources based on the provided source types and source type sorting.
-
-            Args:
-                *source_types (List[Source]): Variable number of source types to filter the sources.
-                source_type_sorting (SourceTypeSorting): Sorting criteria for the source types. This is only relevant if no source types are provided.
-
-            Yields:
-                Generator[Source]: A generator that yields the sources based on the provided filters.
-
-            Returns:
-                None
-            """
-            if not len(source_types):
-                source_type_sorting = source_type_sorting or {}
-                source_types = self.source_types(**source_type_sorting)
-
-            for source_type in source_types:
-                yield from self._sources_by_type[source_type]
+        for page in source_pages:
+            yield from self._page_to_source_list[page]
 
     def append(self, source: Source):
         if source is None:
@@ -200,7 +135,7 @@ class SourceCollection:
             existing_source.__merge__(source)
             source = existing_source
         else:
-            self._sources_by_type[source.source_type].append(source)
+            self._page_to_source_list[source.page_enum].append(source)
 
         changed = False
         for key in source.indexing_values:
@@ -221,6 +156,10 @@ class SourceCollection:
     def __merge__(self, other: SourceCollection, **kwargs):
         self.extend(other)
         
+    @property
+    def source_pages(self) -> Iterable[SourcePages]:
+        return sorted(self._page_to_source_list.keys(), key=lambda page: page.value)
+
     @property
     def hash_url_list(self) -> List[str]:
         return [hash_url(source.url) for source in self.get_sources()]
@@ -231,7 +170,7 @@ class SourceCollection:
 
     @property
     def homepage_list(self) -> List[str]:
-        return [source_type.homepage for source_type in self._sources_by_type.keys()]
+        return [source.homepage for source in self.source_pages]
 
     def indexing_values(self) -> Generator[Tuple[str, str], None, None]:
         for index in self._indexed_sources:

music_kraken/objects/target.py

@@ -1,17 +1,17 @@
 from __future__ import annotations
 
+from pathlib import Path
+from typing import List, Tuple, TextIO, Union
 import logging
 import random
-from pathlib import Path
-from typing import List, Optional, TextIO, Tuple, Union
-
 import requests
 from tqdm import tqdm
 
-from ..utils.config import logging_settings, main_settings
-from ..utils.shared import HIGHEST_ID
-from ..utils.string_processing import fit_to_file_system
 from .parents import OuterProxy
+from ..utils.shared import HIGHEST_ID
+from ..utils.config import main_settings, logging_settings
+from ..utils.string_processing import fit_to_file_system
+
 
 LOGGER = logging.getLogger("target")
 
@@ -31,11 +31,7 @@ class Target(OuterProxy):
     }
 
     @classmethod
-    def temp(cls, name: str = None, file_extension: Optional[str] = None) -> P:
-        name = name or str(random.randint(0, HIGHEST_ID))
-        if file_extension is not None:
-            name = f"{name}.{file_extension}"
-
+    def temp(cls, name: str = str(random.randint(0, HIGHEST_ID))) -> P:
         return cls(main_settings["temp_directory"] / name)
 
     # This is automatically generated
@@ -118,11 +114,3 @@ class Target(OuterProxy):
 
     def read_bytes(self) -> bytes:
         return self.file_path.read_bytes()
-
-    @property
-    def raw_content(self) -> bytes:
-        return self.file_path.read_bytes()
-
-    @raw_content.setter
-    def raw_content(self, content: bytes):
-        self.file_path.write_bytes(content)

music_kraken/pages/__init__.py

@@ -3,6 +3,5 @@ from .musify import Musify
 from .youtube import YouTube
 from .youtube_music import YoutubeMusic
 from .bandcamp import Bandcamp
-from .genius import Genius
 
 from .abstract import Page, INDEPENDENT_DB_OBJECTS

music_kraken/pages/abstract.py

@@ -22,7 +22,7 @@ from ..objects import (
     Collection,
     Label,
 )
-from ..utils.enums import SourceType
+from ..utils.enums.source import SourcePages
 from ..utils.enums.album import AlbumType
 from ..audio import write_metadata_to_target, correct_codec
 from ..utils.config import main_settings
@@ -47,18 +47,74 @@ class DownloadOptions:
     process_audio_if_found: bool = False
     process_metadata_if_found: bool = True
 
+class NamingDict(dict):
+    CUSTOM_KEYS: Dict[str, str] = {
+        "label": "label.name",
+        "artist": "artist.name",
+        "song": "song.title",
+        "isrc": "song.isrc",
+        "album": "album.title",
+        "album_type": "album.album_type_string"
+    }
+
+    def __init__(self, values: dict, object_mappings: Dict[str, DatabaseObject] = None):
+        self.object_mappings: Dict[str, DatabaseObject] = object_mappings or dict()
+
+        super().__init__(values)
+        self["audio_format"] = main_settings["audio_format"]
+
+    def add_object(self, music_object: DatabaseObject):
+        self.object_mappings[type(music_object).__name__.lower()] = music_object
+
+    def copy(self) -> dict:
+        return type(self)(super().copy(), self.object_mappings.copy())
+
+    def __getitem__(self, key: str) -> str:
+        return fit_to_file_system(super().__getitem__(key))
+
+    def default_value_for_name(self, name: str) -> str:
+        return f'Various {name.replace("_", " ").title()}'
+
+    def __missing__(self, key: str) -> str:
+        if "." not in key:
+            if key not in self.CUSTOM_KEYS:
+                return self.default_value_for_name(key)
+
+            key = self.CUSTOM_KEYS[key]
+
+        frag_list = key.split(".")
+
+        object_name = frag_list[0].strip().lower()
+        attribute_name = frag_list[-1].strip().lower()
+
+        if object_name not in self.object_mappings:
+            return self.default_value_for_name(attribute_name)
+
+        music_object = self.object_mappings[object_name]
+        try:
+            value = getattr(music_object, attribute_name)
+            if value is None:
+                return self.default_value_for_name(attribute_name)
+
+            return str(value)
+
+        except AttributeError:
+            return self.default_value_for_name(attribute_name)
+
+
 class Page:
-    SOURCE_TYPE: SourceType
-    LOGGER: logging.Logger
+    """
+    This is an abstract class, laying out the 
+    functionality for every other class fetching something
+    """
 
-    def __new__(cls, *args, **kwargs):
-        cls.LOGGER = logging.getLogger(cls.__name__)
+    SOURCE_TYPE: SourcePages
+    LOGGER = logging.getLogger("this shouldn't be used")
 
-        return super().__new__(cls)
+    # set this to true, if all song details can also be fetched by fetching album details
+    NO_ADDITIONAL_DATA_FROM_SONG = False
 
     def __init__(self, download_options: DownloadOptions = None, fetch_options: FetchOptions = None):
-        self.SOURCE_TYPE.register_page(self)
-        
         self.download_options: DownloadOptions = download_options or DownloadOptions()
         self.fetch_options: FetchOptions = fetch_options or FetchOptions()
 
@@ -133,7 +189,103 @@ class Page:
     def song_search(self, song: Song) -> List[Song]:
         return []
 
-    # to fetch stuff
+    def fetch_details(
+        self, 
+        music_object: DatabaseObject, 
+        stop_at_level: int = 1,
+    ) -> DatabaseObject:
+        """
+        when a music object with lacking data is passed in, it returns
+        the SAME object **(no copy)** with more detailed data.
+        If you for example put in, an album, it fetches the tracklist
+
+        :param music_object:
+        :param stop_at_level: 
+        This says the depth of the level the scraper will recurse to.
+        If this is for example set to 2, then the levels could be:
+        1. Level: the album
+        2. Level: every song of the album + every artist of the album
+        If no additional requests are needed to get the data one level below the supposed stop level
+        this gets ignored
+        :return detailed_music_object: IT MODIFIES THE INPUT OBJ
+        """
+        # creating a new object, of the same type
+        new_music_object: Optional[DatabaseObject] = None
+        fetched_from_url: List[str] = []
+
+        # only certain database objects, have a source list
+        if isinstance(music_object, INDEPENDENT_DB_OBJECTS):
+            source: Source
+            for source in music_object.source_collection.get_sources(self.SOURCE_TYPE):
+                if music_object.already_fetched_from(source.hash_url):
+                    continue
+
+                tmp = self.fetch_object_from_source(
+                    source=source,
+                    enforce_type=type(music_object),
+                    stop_at_level=stop_at_level,
+                    type_string=type(music_object).__name__,
+                    entity_string=music_object.option_string,
+                )
+
+                if new_music_object is None:
+                    new_music_object = tmp
+                else:
+                    new_music_object.merge(tmp)
+                fetched_from_url.append(source.hash_url)
+
+        if new_music_object is not None:
+            music_object.merge(new_music_object)
+
+        music_object.mark_as_fetched(*fetched_from_url)
+        return music_object
+
+    def fetch_object_from_source(
+        self, 
+        source: Source, 
+        stop_at_level: int = 2,
+        enforce_type: Type[DatabaseObject] = None, 
+        type_string: str = "",
+        entity_string: str = "",
+    ) -> Optional[DatabaseObject]:
+
+        obj_type = self.get_source_type(source)
+
+        if obj_type is None:
+            return None
+
+        if enforce_type != obj_type and enforce_type is not None:
+            self.LOGGER.warning(f"Object type isn't type to enforce: {enforce_type}, {obj_type}")
+            return None
+
+        music_object: DatabaseObject = None
+
+        fetch_map = {
+            Song: self.fetch_song,
+            Album: self.fetch_album,
+            Artist: self.fetch_artist,
+            Label: self.fetch_label
+        }
+
+        if obj_type in fetch_map:
+            music_object = fetch_map[obj_type](source, stop_at_level=stop_at_level)
+        else:
+            self.LOGGER.warning(f"Can't fetch details of type: {obj_type}")
+            return None
+
+        if stop_at_level > 0:
+            trace(f"fetching {type_string} [{entity_string}] [stop_at_level={stop_at_level}]")
+
+            collection: Collection
+            for collection_str in music_object.DOWNWARDS_COLLECTION_STRING_ATTRIBUTES:
+                collection = music_object.__getattribute__(collection_str)
+
+                for sub_element in collection:
+                    sub_element.merge(
+                        self.fetch_details(sub_element, stop_at_level=stop_at_level - 1))
+
+        return music_object
+
     def fetch_song(self, source: Source, stop_at_level: int = 1) -> Song:
         return Song()
 
@@ -146,7 +298,152 @@ class Page:
     def fetch_label(self, source: Source, stop_at_level: int = 1) -> Label:
         return Label()
 
-    # to download stuff
+    def download(
+        self, 
+        music_object: DatabaseObject, 
+        genre: str, 
+    ) -> DownloadResult:
+        naming_dict: NamingDict = NamingDict({"genre": genre})
+
+        def fill_naming_objects(naming_music_object: DatabaseObject):
+            nonlocal naming_dict
+
+            for collection_name in naming_music_object.UPWARDS_COLLECTION_STRING_ATTRIBUTES:
+                collection: Collection = getattr(naming_music_object, collection_name)
+
+                if collection.empty:
+                    continue
+                
+                dom_ordered_music_object: DatabaseObject = collection[0]
+                naming_dict.add_object(dom_ordered_music_object)
+                return fill_naming_objects(dom_ordered_music_object)
+
+        fill_naming_objects(music_object)
+
+        return self._download(music_object, naming_dict)
+
+    def _download(
+        self, 
+        music_object: DatabaseObject, 
+        naming_dict: NamingDict, 
+        **kwargs
+    ) -> DownloadResult:
+        if isinstance(music_object, Song):
+            output(f"Downloading {music_object.option_string} to:", color=BColors.BOLD)
+        else:
+            output(f"Downloading {music_object.option_string}...", color=BColors.BOLD)
+
+        # Skips all releases, that are defined in shared.ALBUM_TYPE_BLACKLIST, if download_all is False
+        if isinstance(music_object, Album):
+            if not self.download_options.download_all and music_object.album_type in self.download_options.album_type_blacklist:
+                return DownloadResult()
+
+        if not (isinstance(music_object, Song) and self.NO_ADDITIONAL_DATA_FROM_SONG):
+            self.fetch_details(music_object=music_object, stop_at_level=1)
+
+        if isinstance(music_object, Album):
+            music_object.update_tracksort()
+            
+        naming_dict.add_object(music_object)
+
+        if isinstance(music_object, Song):
+            return self._download_song(music_object, naming_dict)
+
+        download_result: DownloadResult = DownloadResult()
+
+        for collection_name in music_object.DOWNWARDS_COLLECTION_STRING_ATTRIBUTES:
+            collection: Collection = getattr(music_object, collection_name)
+
+            sub_ordered_music_object: DatabaseObject
+            for sub_ordered_music_object in collection:
+                download_result.merge(self._download(sub_ordered_music_object, naming_dict.copy()))
+
+        return download_result
+
+    def _download_song(self, song: Song, naming_dict: NamingDict):
+        if "genre" not in naming_dict and song.genre is not None:
+            naming_dict["genre"] = song.genre
+
+        if song.genre is None:
+            song.genre = naming_dict["genre"]
+
+        path_parts = Formatter().parse(main_settings["download_path"])
+        file_parts = Formatter().parse(main_settings["download_file"])
+        new_target = Target(
+            relative_to_music_dir=True,
+            file_path=Path(
+                main_settings["download_path"].format(**{part[1]: naming_dict[part[1]] for part in path_parts}),
+                main_settings["download_file"].format(**{part[1]: naming_dict[part[1]] for part in file_parts})
+            )
+        )
+
+        if song.target_collection.empty:
+            song.target_collection.append(new_target)
+
+        r = DownloadResult(1)
+        temp_target: Target = Target.temp()
+
+        found_on_disc = False
+        target: Target
+        for target in song.target_collection:
+            current_exists = target.exists
+
+            if current_exists:
+                output(f'- {target.file_path} {BColors.OKGREEN.value}[already exists]', color=BColors.GREY)
+                target.copy_content(temp_target)
+                found_on_disc = True
+
+                r.found_on_disk += 1
+                r.add_target(target)
+            else:
+                output(f'- {target.file_path}', color=BColors.GREY)
+
+        if not song.source_collection.has_source_page(self.SOURCE_TYPE):
+            return DownloadResult(error_message=f"No {self.__class__.__name__} source found for {song.option_string}.")
+
+        sources = song.source_collection.get_sources(self.SOURCE_TYPE)
+
+        skip_intervals = []
+        if not found_on_disc:
+            for source in sources:
+                r = self.download_song_to_target(source=source, target=temp_target, desc="downloading")
+
+                if not r.is_fatal_error:
+                    skip_intervals = self.get_skip_intervals(song, source)
+                    break
+        
+        if temp_target.exists:
+            r.merge(self._post_process_targets(
+                song=song, 
+                temp_target=temp_target,
+                interval_list=skip_intervals,
+                found_on_disc=found_on_disc,
+            ))
+
+        return r
+
+    def _post_process_targets(self, song: Song, temp_target: Target, interval_list: List, found_on_disc: bool) -> DownloadResult:
+        if not found_on_disc or self.download_options.process_audio_if_found:
+            correct_codec(temp_target, interval_list=interval_list)
+
+        self.post_process_hook(song, temp_target)
+
+        if not found_on_disc or self.download_options.process_metadata_if_found:
+            write_metadata_to_target(song.metadata, temp_target, song)
+
+        r = DownloadResult()
+
+        target: Target
+        for target in song.target_collection:
+            if temp_target is not target:
+                temp_target.copy_content(target)
+            r.add_target(target)
+
+        temp_target.delete()
+        r.sponsor_segments += len(interval_list)
+
+        return r
+
     def get_skip_intervals(self, song: Song, source: Source) -> List[Tuple[float, float]]:
         return []
 

music_kraken/pages/bandcamp.py

@@ -1,22 +1,32 @@
-import json
-from enum import Enum
 from typing import List, Optional, Type
 from urllib.parse import urlparse, urlunparse
-
-import pycountry
+import json
+from enum import Enum
 from bs4 import BeautifulSoup
+import pycountry
 
-from ..connection import Connection
-from ..objects import (Album, Artist, ArtworkCollection, Contact,
-                       DatabaseObject, FormattedText, ID3Timestamp, Label,
-                       Lyrics, Song, Source, SourceType, Target)
-from ..utils import dump_to_file
-from ..utils.config import logging_settings, main_settings
-from ..utils.enums import ALL_SOURCE_TYPES, SourceType
-from ..utils.shared import DEBUG
-from ..utils.string_processing import clean_song_title
-from ..utils.support_classes.download_result import DownloadResult
+from ..objects import Source, DatabaseObject
 from .abstract import Page
+from ..objects import (
+    Artist,
+    Source,
+    SourcePages,
+    Song,
+    Album,
+    Label,
+    Target,
+    Contact,
+    ID3Timestamp,
+    Lyrics,
+    FormattedText,
+    Artwork,
+)
+from ..connection import Connection
+from ..utils import dump_to_file
+from ..utils.support_classes.download_result import DownloadResult
+from ..utils.string_processing import clean_song_title
+from ..utils.config import main_settings, logging_settings
+from ..utils.shared import DEBUG
 
 if DEBUG:
     from ..utils import dump_to_file
@@ -39,7 +49,9 @@ class BandcampTypes(Enum):
 
 
 class Bandcamp(Page):
-    SOURCE_TYPE = ALL_SOURCE_TYPES.BANDCAMP
+    # CHANGE
+    SOURCE_TYPE = SourcePages.BANDCAMP
+    LOGGER = logging_settings["bandcamp_logger"]
 
     def __init__(self, *args, **kwargs):
         self.connection: Connection = Connection(
@@ -51,7 +63,8 @@ class Bandcamp(Page):
         super().__init__(*args, **kwargs)
 
     def get_source_type(self, source: Source) -> Optional[Type[DatabaseObject]]:
-        path = source.parsed_url.path.replace("/", "")
+        parsed_url = urlparse(source.url)
+        path = parsed_url.path.replace("/", "")
 
         if path == "" or path.startswith("music"):
             return Artist
@@ -106,7 +119,7 @@ class Bandcamp(Page):
             return Song(
                 title=clean_song_title(name, artist_name=data["band_name"]),
                 source_list=source_list,
-                artist_list=[
+                main_artist_list=[
                     Artist(
                         name=data["band_name"],
                         source_list=[
@@ -226,13 +239,8 @@ class Bandcamp(Page):
         html_music_grid = soup.find("ol", {"id": "music-grid"})
         if html_music_grid is not None:
             for subsoup in html_music_grid.find_all("li"):
-                artist.album_collection.append(self._parse_album(soup=subsoup, initial_source=source))
+                artist.main_album_collection.append(self._parse_album(soup=subsoup, initial_source=source))
 
-        # artist artwork
-        artist_artwork: BeautifulSoup = soup.find("img", {"class":"band-photo"})
-        if artist_artwork is not None:
-            artist.artwork.add_data(artist_artwork.get("data-src", artist_artwork.get("src")))
-        
         for i, data_blob_soup in enumerate(soup.find_all("div", {"id": ["pagedata", "collectors-data"]})):
             data_blob = data_blob_soup["data-blob"]
 
@@ -240,14 +248,14 @@ class Bandcamp(Page):
                 dump_to_file(f"bandcamp_artist_data_blob_{i}.json", data_blob, is_json=True, exit_after_dump=False)
 
             if data_blob is not None:
-                artist.album_collection.extend(
+                artist.main_album_collection.extend(
                     self._parse_artist_data_blob(json.loads(data_blob), source.url)
                 )
 
         artist.source_collection.append(source)
         return artist
 
-    def _parse_track_element(self, track: dict, artwork: ArtworkCollection) -> Optional[Song]:
+    def _parse_track_element(self, track: dict, artwork: Artwork) -> Optional[Song]:
         lyrics_list: List[Lyrics] = []
 
         _lyrics: Optional[str] = track.get("item", {}).get("recordingOf", {}).get("lyrics", {}).get("text")
@@ -281,15 +289,9 @@ class Bandcamp(Page):
         artist_source_list = []
         if "@id" in artist_data:
             artist_source_list = [Source(self.SOURCE_TYPE, _parse_artist_url(artist_data["@id"]))]
-
-
-        source_list: List[Source] = [source]
-        if "mainEntityOfPage" in data or "@id" in data:
-            source_list.append(Source(self.SOURCE_TYPE, data.get("mainEntityOfPage", data["@id"])))
-
         album = Album(
             title=data["name"].strip(),
-            source_list=source_list,
+            source_list=[Source(self.SOURCE_TYPE, data.get("mainEntityOfPage", data["@id"]))],
             date=ID3Timestamp.strptime(data["datePublished"], "%d %b %Y %H:%M:%S %Z"),
             artist_list=[Artist(
                 name=artist_data["name"].strip(),
@@ -297,7 +299,7 @@ class Bandcamp(Page):
             )]
         )
 
-        artwork: ArtworkCollection = ArtworkCollection()
+        artwork: Artwork = Artwork()
 
         def _get_artwork_url(_data: dict) -> Optional[str]:
             if "image" in _data:
@@ -308,14 +310,15 @@ class Bandcamp(Page):
 
         _artwork_url = _get_artwork_url(data)
         if _artwork_url is not None:
-            artwork.add_data(url=_artwork_url, width=350, height=350)
+            artwork.append(url=_artwork_url, width=350, height=350)
         else:
             for album_release in data.get("albumRelease", []):
                 _artwork_url = _get_artwork_url(album_release)
                 if _artwork_url is not None:
-                    artwork.add_data(url=_artwork_url, width=350, height=350)
+                    artwork.append(url=_artwork_url, width=350, height=350)
                     break
 
+
         for i, track_json in enumerate(data.get("track", {}).get("itemListElement", [])):
             if DEBUG:
                 dump_to_file(f"album_track_{i}.json", json.dumps(track_json), is_json=True, exit_after_dump=False)
@@ -361,29 +364,17 @@ class Bandcamp(Page):
         for key, value in other_data.get("trackinfo", [{}])[0].get("file", {"": None}).items():
             mp3_url = value
 
-        source_list: List[Source] = [source]
-        if "mainEntityOfPage" in data or "@id" in data:
-            source_list.append(Source(self.SOURCE_TYPE, data.get("mainEntityOfPage", data["@id"]), audio_url=mp3_url))
-
-        source_list_album: List[Source] = [source]
-        if "@id" in album_data:
-            source_list_album.append(Source(self.SOURCE_TYPE, album_data["@id"]))
-
-        source_list_artist: List[Source] = [source]
-        if "@id" in artist_data:
-            source_list_artist.append(Source(self.SOURCE_TYPE, _parse_artist_url(artist_data["@id"])))
-
         song = Song(
             title=clean_song_title(data["name"], artist_name=artist_data["name"]),
-            source_list=source_list,
+            source_list=[source, Source(self.SOURCE_TYPE, data.get("mainEntityOfPage", data["@id"]), audio_url=mp3_url)],
             album_list=[Album(
                 title=album_data["name"].strip(),
                 date=ID3Timestamp.strptime(data["datePublished"], "%d %b %Y %H:%M:%S %Z"),
-                source_list=source_list_album
+                source_list=[Source(self.SOURCE_TYPE, album_data["@id"])]
             )],
-            artist_list=[Artist(
+            main_artist_list=[Artist(
                 name=artist_data["name"].strip(),
-                source_list=source_list_artist
+                source_list=[Source(self.SOURCE_TYPE, _parse_artist_url(artist_data["@id"]))]
             )],
             lyrics_list=self._fetch_lyrics(soup=soup)
         )

music_kraken/pages/encyclopaedia_metallum.py

@@ -7,7 +7,7 @@ from urllib.parse import urlparse, urlencode
 from ..connection import Connection
 from ..utils.config import logging_settings
 from .abstract import Page
-from ..utils.enums import SourceType, ALL_SOURCE_TYPES
+from ..utils.enums.source import SourcePages
 from ..utils.enums.album import AlbumType
 from ..utils.support_classes.query import Query
 from ..objects import (
@@ -52,14 +52,14 @@ def _song_from_json(artist_html=None, album_html=None, release_type=None, title=
 
     return Song(
         title=title,
-        artist_list=[
+        main_artist_list=[
             _artist_from_json(artist_html=artist_html)
         ],
         album_list=[
             _album_from_json(album_html=album_html, release_type=release_type, artist_html=artist_html)
         ],
         source_list=[
-            Source(ALL_SOURCE_TYPES.ENCYCLOPAEDIA_METALLUM, song_id)
+            Source(SourcePages.ENCYCLOPAEDIA_METALLUM, song_id)
         ]
     )
 
@@ -85,7 +85,7 @@ def _artist_from_json(artist_html=None, genre=None, country=None) -> Artist:
     return Artist(
         name=artist_name,
         source_list=[
-            Source(ALL_SOURCE_TYPES.ENCYCLOPAEDIA_METALLUM, artist_url)
+            Source(SourcePages.ENCYCLOPAEDIA_METALLUM, artist_url)
         ]
     )
 
@@ -105,7 +105,7 @@ def _album_from_json(album_html=None, release_type=None, artist_html=None) -> Al
         title=album_name,
         album_type=album_type,
         source_list=[
-            Source(ALL_SOURCE_TYPES.ENCYCLOPAEDIA_METALLUM, album_url)
+            Source(SourcePages.ENCYCLOPAEDIA_METALLUM, album_url)
         ],
         artist_list=[
             _artist_from_json(artist_html=artist_html)
@@ -207,7 +207,7 @@ def create_grid(
 
 
 class EncyclopaediaMetallum(Page):
-    SOURCE_TYPE = ALL_SOURCE_TYPES.ENCYCLOPAEDIA_METALLUM
+    SOURCE_TYPE = SourcePages.ENCYCLOPAEDIA_METALLUM
     LOGGER = logging_settings["metal_archives_logger"]
     
     def __init__(self, **kwargs):
@@ -266,7 +266,7 @@ class EncyclopaediaMetallum(Page):
 
         song_title = song.title.strip()
         album_titles = ["*"] if song.album_collection.empty else [album.title.strip() for album in song.album_collection]
-        artist_titles = ["*"] if song.artist_collection.empty else [artist.name.strip() for artist in song.artist_collection]
+        artist_titles = ["*"] if song.main_artist_collection.empty else [artist.name.strip() for artist in song.main_artist_collection]
 
 
         search_results = []
@@ -663,7 +663,7 @@ class EncyclopaediaMetallum(Page):
             artist.notes = band_notes
 
         discography: List[Album] = self._fetch_artist_discography(artist_id)
-        artist.album_collection.extend(discography)
+        artist.main_album_collection.extend(discography)
 
         return artist
 
@@ -832,7 +832,7 @@ class EncyclopaediaMetallum(Page):
         )
 
     def get_source_type(self, source: Source):
-        if self.SOURCE_TYPE != source.source_type:
+        if self.SOURCE_TYPE != source.page_enum:
             return None
         
         url = source.url

music_kraken/pages/genius.py

@@ -1,288 +0,0 @@
-import simplejson as json
-from json_unescape import escape_json, unescape_json
-from enum import Enum
-from typing import List, Optional, Type
-from urllib.parse import urlencode, urlparse, urlunparse
-
-import pycountry
-from bs4 import BeautifulSoup
-
-from ..connection import Connection
-from ..objects import (Album, Artist, ArtworkCollection, Contact,
-                       DatabaseObject, FormattedText, ID3Timestamp, Label,
-                       Lyrics, Song, Source, SourceType, Target)
-from ..utils import dump_to_file, traverse_json_path
-from ..utils.config import logging_settings, main_settings
-from ..utils.enums import ALL_SOURCE_TYPES, SourceType
-from ..utils.shared import DEBUG
-from ..utils.string_processing import clean_song_title
-from ..utils.support_classes.download_result import DownloadResult
-from .abstract import Page
-
-if DEBUG:
-    from ..utils import dump_to_file
-
-
-class Genius(Page):
-    SOURCE_TYPE = ALL_SOURCE_TYPES.GENIUS
-    HOST = "genius.com"
-
-    def __init__(self, *args, **kwargs):
-        self.connection: Connection = Connection(
-            host="https://genius.com/",
-            logger=self.LOGGER,
-            module="genius",
-        )
-
-        super().__init__(*args, **kwargs)
-
-    def get_source_type(self, source: Source) -> Optional[Type[DatabaseObject]]:
-        path = source.parsed_url.path.replace("/", "")
-        
-        if path.startswith("artists"):
-            return Artist
-        if path.startswith("albums"):
-            return Album
-
-        return Song
-
-    def add_to_artwork(self, artwork: ArtworkCollection, url: str):
-        if url is None:
-            return
-        
-        url_frags = url.split(".")
-        if len(url_frags) < 2:
-            artwork.add_data(url=url)
-            return
-
-        dimensions = url_frags[-2].split("x")
-        if len(dimensions) < 2:
-            artwork.add_data(url=url)
-            return
-
-        if len(dimensions) == 3:
-            dimensions = dimensions[:-1]
-        
-        try:
-            artwork.add_data(url=url, width=int(dimensions[0]), height=int(dimensions[1]))
-        except ValueError:
-            artwork.add_data(url=url)
-
-    def parse_api_object(self, data: dict) -> Optional[DatabaseObject]:
-        if data is None:
-            return None
-        object_type = data.get("_type")
-
-        artwork = ArtworkCollection()
-        self.add_to_artwork(artwork, data.get("header_image_url"))
-        self.add_to_artwork(artwork, data.get("image_url"))
-        
-        additional_sources: List[Source] = []
-        source: Source = Source(self.SOURCE_TYPE, data.get("url"), additional_data={
-            "id": data.get("id"),
-            "slug": data.get("slug"),
-            "api_path": data.get("api_path"),
-        })
-
-        notes = FormattedText()
-        description = data.get("description") or {}
-        if "html" in description:
-            notes.html = description["html"]
-        elif "markdown" in description:
-            notes.markdown = description["markdown"]
-        elif "description_preview" in data:
-            notes.plaintext = data["description_preview"]
-
-        if source.url is None:
-            return None
-
-        if object_type == "artist":
-            if data.get("instagram_name") is not None:
-                additional_sources.append(Source(ALL_SOURCE_TYPES.INSTAGRAM, f"https://www.instagram.com/{data['instagram_name']}/"))
-            if data.get("facebook_name") is not None:
-                additional_sources.append(Source(ALL_SOURCE_TYPES.FACEBOOK, f"https://www.facebook.com/{data['facebook_name']}/"))
-            if data.get("twitter_name") is not None:
-                additional_sources.append(Source(ALL_SOURCE_TYPES.TWITTER, f"https://x.com/{data['twitter_name']}/"))
-
-            return Artist(
-                name=data["name"].strip() if data.get("name") is not None else None,
-                source_list=[source],
-                artwork=artwork,
-                notes=notes,
-            )
-
-        if object_type == "album":
-            self.add_to_artwork(artwork, data.get("cover_art_thumbnail_url"))
-            self.add_to_artwork(artwork, data.get("cover_art_url"))
-
-            for cover_art in data.get("cover_arts", []):
-                self.add_to_artwork(artwork, cover_art.get("image_url"))
-                self.add_to_artwork(artwork, cover_art.get("thumbnail_image_url"))
-
-            return Album(
-                title=data.get("name").strip(),
-                source_list=[source],
-                artist_list=[self.parse_api_object(data.get("artist"))],
-                artwork=artwork,
-                date=ID3Timestamp(**(data.get("release_date_components") or {})),
-            )
-
-        if object_type == "song":
-            self.add_to_artwork(artwork, data.get("song_art_image_thumbnail_url"))
-            self.add_to_artwork(artwork, data.get("song_art_image_url"))
-
-            main_artist_list = []
-            featured_artist_list = []
-
-            _artist_name = None
-            primary_artist = self.parse_api_object(data.get("primary_artist"))
-            if primary_artist is not None:
-                _artist_name = primary_artist.name
-                main_artist_list.append(primary_artist)
-            for feature_artist in (*(data.get("featured_artists") or []), *(data.get("producer_artists") or []), *(data.get("writer_artists") or [])):
-                artist = self.parse_api_object(feature_artist)
-                if artist is not None:
-                    featured_artist_list.append(artist)
-
-            return Song(
-                title=clean_song_title(data.get("title"), artist_name=_artist_name),
-                source_list=[source],
-                artwork=artwork,
-                feature_artist_list=featured_artist_list,
-                artist_list=main_artist_list,
-            )
-
-        return None
-
-    def general_search(self, search_query: str, **kwargs) -> List[DatabaseObject]:
-        results = []
-
-        search_params = {
-            "q": search_query,
-        }
-
-        r = self.connection.get("https://genius.com/api/search/multi?" + urlencode(search_params), name=f"search_{search_query}")
-        if r is None:
-            return results
-
-        dump_to_file("search_genius.json", r.text, is_json=True, exit_after_dump=False)
-        data = r.json()
-
-        for elements in traverse_json_path(data, "response.sections", default=[]):
-            hits = elements.get("hits", [])
-            for hit in hits:
-                parsed = self.parse_api_object(hit.get("result"))
-                if parsed is not None:
-                    results.append(parsed)
-
-        return results
-
-    def fetch_artist(self, source: Source, stop_at_level: int = 1) -> Artist:
-        artist: Artist = Artist()
-        # https://genius.com/api/artists/24527/albums?page=1
-
-        r = self.connection.get(source.url, name=source.url)
-        if r is None:
-            return artist
-        soup = self.get_soup_from_response(r)
-
-        # find the content attribute in the meta tag which is contained in the head
-        data_container = soup.find("meta", {"itemprop": "page_data"})
-        if data_container is not None:
-            content = data_container["content"]
-            dump_to_file("genius_itemprop_artist.json", content, is_json=True, exit_after_dump=False)
-            data = json.loads(content)
-
-            artist = self.parse_api_object(data.get("artist"))
-            
-            for e in (data.get("artist_albums") or []):
-                r = self.parse_api_object(e)
-                if not isinstance(r, Album):
-                    continue
-
-                artist.album_collection.append(r)
-            
-            for e in (data.get("artist_songs") or []):
-                r = self.parse_api_object(e)
-                if not isinstance(r, Song):
-                    continue
-
-                """
-                TODO
-                fetch the album for these songs, because the api doesn't 
-                return them
-                """
-
-                artist.album_collection.extend(r.album_collection)
-
-        artist.source_collection.append(source)
-
-        return artist
-
-    def fetch_album(self, source: Source, stop_at_level: int = 1) -> Album:
-        album: Album = Album()
-        # https://genius.com/api/artists/24527/albums?page=1
-
-        r = self.connection.get(source.url, name=source.url)
-        if r is None:
-            return album
-        soup = self.get_soup_from_response(r)
-
-        # find the content attribute in the meta tag which is contained in the head
-        data_container = soup.find("meta", {"itemprop": "page_data"})
-        if data_container is not None:
-            content = data_container["content"]
-            dump_to_file("genius_itemprop_album.json", content, is_json=True, exit_after_dump=False)
-            data = json.loads(content)
-
-            album = self.parse_api_object(data.get("album"))
-
-            for e in data.get("album_appearances", []):
-                r = self.parse_api_object(e.get("song"))
-                if not isinstance(r, Song):
-                    continue
-
-                album.song_collection.append(r)
-
-        album.source_collection.append(source)
-        
-        return album
-
-    def get_json_content_from_response(self, response, start: str, end: str) -> Optional[str]:
-        content = response.text
-        start_index = content.find(start)
-        if start_index < 0:
-            return None
-        start_index += len(start)
-        end_index = content.find(end, start_index)
-        if end_index < 0:
-            return None
-        return content[start_index:end_index]
-
-    def fetch_song(self, source: Source, stop_at_level: int = 1) -> Song:
-        song: Song = Song()
-
-        r = self.connection.get(source.url, name=source.url)
-        if r is None:
-            return song
-
-        # get the contents that are between `JSON.parse('` and `');`
-        content = self.get_json_content_from_response(r, start="window.__PRELOADED_STATE__ = JSON.parse('", end="');\n      window.__APP_CONFIG__ = ")
-        if content is not None:
-            #IMPLEMENT FIX FROM HAZEL
-            content = escape_json(content)
-            data = json.loads(content) 
-
-            lyrics_html = traverse_json_path(data, "songPage.lyricsData.body.html", default=None)
-            if lyrics_html is not None:
-                song.lyrics_collection.append(Lyrics(FormattedText(html=lyrics_html)))
-
-            dump_to_file("genius_song_script_json.json", content, is_json=True, exit_after_dump=False)
-
-        soup = self.get_soup_from_response(r)
-        for lyrics in soup.find_all("div", {"data-lyrics-container": "true"}):
-            lyrics_object = Lyrics(FormattedText(html=lyrics.prettify()))
-            song.lyrics_collection.append(lyrics_object)
-
-        song.source_collection.append(source)
-        return song

music_kraken/pages/musify.py

@@ -1,25 +1,34 @@
 from collections import defaultdict
 from dataclasses import dataclass
 from enum import Enum
-from typing import Any, Dict, Generator, List, Optional, Type, Union
+from typing import List, Optional, Type, Union, Generator, Dict, Any
 from urllib.parse import urlparse
 
 import pycountry
 from bs4 import BeautifulSoup
 
 from ..connection import Connection
-from ..objects import (Album, Artist, DatabaseObject,
-                       FormattedText, ID3Timestamp, Label, Lyrics, Song,
-                       Source, Target)
-from ..objects.artwork import (Artwork, ArtworkVariant, ArtworkCollection)
-from ..utils import shared, string_processing
-from ..utils.config import logging_settings, main_settings
-from ..utils.enums import ALL_SOURCE_TYPES, SourceType
-from ..utils.enums.album import AlbumStatus, AlbumType
-from ..utils.string_processing import clean_song_title
-from ..utils.support_classes.download_result import DownloadResult
-from ..utils.support_classes.query import Query
 from .abstract import Page
+from ..utils.enums.source import SourcePages
+from ..utils.enums.album import AlbumType, AlbumStatus
+from ..objects import (
+    Artist,
+    Source,
+    Song,
+    Album,
+    ID3Timestamp,
+    FormattedText,
+    Label,
+    Target,
+    DatabaseObject,
+    Lyrics,
+    Artwork
+)
+from ..utils.config import logging_settings, main_settings
+from ..utils import string_processing, shared
+from ..utils.string_processing import clean_song_title
+from ..utils.support_classes.query import Query
+from ..utils.support_classes.download_result import DownloadResult
 
 """
 https://musify.club/artist/ghost-bath-280348?_pjax=#bodyContent
@@ -102,7 +111,9 @@ def parse_url(url: str) -> MusifyUrl:
 
 
 class Musify(Page):
-    SOURCE_TYPE = ALL_SOURCE_TYPES.MUSIFY
+    # CHANGE
+    SOURCE_TYPE = SourcePages.MUSIFY
+    LOGGER = logging_settings["musify_logger"]
     
     HOST = "https://musify.club"
     
@@ -448,17 +459,17 @@ class Musify(Page):
         for album_info in soup.find_all("ul", {"class": "album-info"}):
             list_element: BeautifulSoup = album_info.find("li")
             
-        if list_element is not None:
-            artist_soup: BeautifulSoup
-            for artist_soup in list_element.find_all("a"):
-                artist_source_list = []
-                href = artist_soup["href"]
-                if href is not None:
-                    artist_source_list = [Source(self.SOURCE_TYPE, self.HOST + href)]
-                artist_list.append(Artist(
-                    name=artist_soup.text.strip(),
-                    source_list=artist_source_list
-                ))
+            if list_element is not None:
+                artist_soup: BeautifulSoup
+                for artist_soup in list_element.find_all("a"):
+                    artist_source_list = []
+                    href = artist_soup["href"]
+                    if href is not None:
+                        artist_source_list = [Source(self.SOURCE_TYPE, self.HOST + href)]
+                    artist_list.append(Artist(
+                        name=artist_soup.text.strip(),
+                        source_list=artist_source_list
+                    ))
     
         # breadcrums
         breadcrumb_list_element_list: List[BeautifulSoup] = soup.find_all("ol", {"class": "breadcrumb"})
@@ -476,11 +487,11 @@ class Musify(Page):
             
             track_name = list_points[4].text.strip()
 
-        # album artwork
-        artwork: ArtworkCollection = ArtworkCollection()
+        # artwork
+        artwork: Artwork = Artwork()
         album_image_element_list: List[BeautifulSoup] = soup.find_all("img", {"class": "album-img"})
         for album_image_element in album_image_element_list:
-            artwork.add_data(url=album_image_element.get("data-src", album_image_element.get("src")))
+            artwork.append(url=album_image_element.get("data-src", album_image_element.get("src")))
         
         # lyrics
         lyrics_container: List[BeautifulSoup] = soup.find_all("div", {"id": "tabLyrics"})
@@ -493,18 +504,9 @@ class Musify(Page):
         for video_container in video_container_list:
             iframe_list: List[BeautifulSoup] = video_container.findAll("iframe")
             for iframe in iframe_list:
-                """
-                the url could look like this
-                https://www.youtube.com/embed/sNObCkhzOYA?si=dNVgnZMBNVlNb0P_
-                """
-                parsed_url = urlparse(iframe["src"])
-                path_parts = parsed_url.path.strip("/").split("/")
-                if path_parts[0] != "embed" or len(path_parts) < 2:
-                    continue
-                
                 source_list.append(Source(
-                    ALL_SOURCE_TYPES.YOUTUBE,
-                    f"https://music.youtube.com/watch?v={path_parts[1]}",
+                    SourcePages.YOUTUBE,
+                    iframe["src"],
                     referrer_page=self.SOURCE_TYPE
                 ))
         
@@ -745,18 +747,11 @@ class Musify(Page):
                     except ValueError:
                         self.LOGGER.debug(f"Raw datetime doesn't match time format %Y-%m-%d: {raw_datetime}")
 
-        # album artwork
-        album_artwork: ArtworkCollection = ArtworkCollection()
-        album_artwork_list: List[BeautifulSoup] = soup.find_all("img", {"class":"artist-img"})
-        for album_artwork in album_artwork_list:
-            album_artwork.add_data(url=album_artwork.get("data-src", album_artwork.get("src")))
-
         return Album(
             title=name,
             source_list=source_list,
             artist_list=artist_list,
-            date=date,
-            artwork=album_artwork
+            date=date
         )
 
     def fetch_album(self, source: Source, stop_at_level: int = 1) -> Album:
@@ -793,8 +788,6 @@ class Musify(Page):
                 new_song = self._parse_song_card(card_soup)
                 album.song_collection.append(new_song)
         
-
-
         album.update_tracksort()
 
         return album
@@ -914,18 +907,11 @@ class Musify(Page):
         if note_soup is not None:
             notes.html = note_soup.decode_contents()
 
-        # get artist profile artwork
-        main_artist_artwork: ArtworkCollection = ArtworkCollection()
-        artist_image_element_list: List[BeautifulSoup] = soup.find_all("img", {"class":"artist-img"})
-        for artist_image_element in artist_image_element_list:
-            main_artist_artwork.add_data(url=artist_image_element.get("data-src", artist_image_element.get("src")))
-
         return Artist(
             name=name,
             country=country,
             source_list=source_list,
-            notes=notes,
-            artwork=main_artist_artwork
+            notes=notes
         )
 
     def _parse_album_card(self, album_card: BeautifulSoup, artist_name: str = None, **kwargs) -> Album:
@@ -1061,31 +1047,21 @@ class Musify(Page):
             if not self.fetch_options.download_all and album.album_type in self.fetch_options.album_type_blacklist:
                 continue
 
-            artist.album_collection.append(album)
-
-    def _fetch_artist_artwork(self, source: str, artist: Artist, **kwargs):
-        # artist artwork
-        artwork_gallery = self.get_soup_from_response(self.connection.get(source.strip().strip("/") + "/photos"))
-        if artwork_gallery is not None:
-            gallery_body_content: BeautifulSoup = artwork_gallery.find(id="bodyContent")
-            gallery_image_element_list: List[BeautifulSoup] = gallery_body_content.find_all("img")
-            for gallery_image_element in gallery_image_element_list:
-                artist.artwork.append(ArtworkVariant(url=gallery_image_element.get("data-src", gallery_image_element.get("src")), width=247, heigth=247))
-
+            artist.main_album_collection.append(album)
 
     def fetch_artist(self, source: Source, **kwargs) -> Artist:
         """
         TODO
         [x] discography
         [x] attributes
-        [x] picture gallery
+        [] picture gallery
         """
 
         url = parse_url(source.url)
 
         artist = self._fetch_initial_artist(url, source=source, **kwargs)
         self._fetch_artist_discography(artist, url, artist.name, **kwargs)
-        self._fetch_artist_artwork(url.url, artist, **kwargs)
+        
         return artist
 
     def fetch_label(self, source: Source, stop_at_level: int = 1) -> Label:

music_kraken/pages/preset.py

@@ -0,0 +1,65 @@
+from typing import List, Optional, Type
+from urllib.parse import urlparse
+import logging
+
+
+from ..objects import Source, DatabaseObject
+from .abstract import Page
+from ..objects import (
+    Artist,
+    Source,
+    SourcePages,
+    Song,
+    Album,
+    Label,
+    Target
+)
+from ..connection import Connection
+from ..utils.support_classes.query import Query
+from ..utils.support_classes.download_result import DownloadResult
+
+class Preset(Page):
+    # CHANGE
+    SOURCE_TYPE = SourcePages.PRESET
+    LOGGER = logging.getLogger("preset")
+
+    def __init__(self, *args, **kwargs):
+        self.connection: Connection = Connection(
+            host="https://www.preset.cum/",
+            logger=self.LOGGER
+        )
+        
+        super().__init__(*args, **kwargs)
+
+    def get_source_type(self, source: Source) -> Optional[Type[DatabaseObject]]:
+        return super().get_source_type(source)
+    
+    def general_search(self, search_query: str) -> List[DatabaseObject]:
+        return []
+    
+    def label_search(self, label: Label) -> List[Label]:
+        return []
+    
+    def artist_search(self, artist: Artist) -> List[Artist]:
+        return []
+    
+    def album_search(self, album: Album) -> List[Album]:
+        return []
+    
+    def song_search(self, song: Song) -> List[Song]:
+        return []
+    
+    def fetch_song(self, source: Source, stop_at_level: int = 1) -> Song:
+        return Song()
+
+    def fetch_album(self, source: Source, stop_at_level: int = 1) -> Album:
+        return Album()
+
+    def fetch_artist(self, source: Source, stop_at_level: int = 1) -> Artist:
+        return Artist()
+
+    def fetch_label(self, source: Source, stop_at_level: int = 1) -> Label:
+        return Label()
+
+    def download_song_to_target(self, source: Source, target: Target, desc: str = None) -> DownloadResult:
+        return DownloadResult()

music_kraken/pages/youtube.py

@@ -9,6 +9,7 @@ from .abstract import Page
 from ..objects import (
     Artist,
     Source,
+    SourcePages,
     Song,
     Album,
     Label,
@@ -18,7 +19,6 @@ from ..objects import (
 )
 from ..connection import Connection
 from ..utils.string_processing import clean_song_title
-from ..utils.enums import SourceType, ALL_SOURCE_TYPES
 from ..utils.support_classes.download_result import DownloadResult
 from ..utils.config import youtube_settings, main_settings, logging_settings
 
@@ -39,7 +39,10 @@ def get_piped_url(path: str = "", params: str = "", query: str = "", fragment: s
 
 class YouTube(SuperYouTube):
     # CHANGE
-    SOURCE_TYPE = ALL_SOURCE_TYPES.YOUTUBE
+    SOURCE_TYPE = SourcePages.YOUTUBE
+    LOGGER = logging_settings["youtube_logger"]
+
+    NO_ADDITIONAL_DATA_FROM_SONG = False
 
     def __init__(self, *args, **kwargs):
         self.connection: Connection = Connection(
@@ -143,7 +146,7 @@ class YouTube(SuperYouTube):
                 self.SOURCE_TYPE, get_invidious_url(path="/watch", query=f"v={data['videoId']}")
             )],
             notes=FormattedText(html=data["descriptionHtml"] + f"\n<p>{license_str}</ p>" ),
-            artist_list=artist_list
+            main_artist_list=artist_list
         ), int(data["published"])
 
     def fetch_song(self, source: Source, stop_at_level: int = 1) -> Song:
@@ -284,7 +287,7 @@ class YouTube(SuperYouTube):
             self.LOGGER.warning(f"didn't found any playlists with piped, falling back to invidious. (it is unusual)")
             album_list, artist_name = self.fetch_invidious_album_list(parsed.id)
         
-        return Artist(name=artist_name, album_list=album_list, source_list=[source])
+        return Artist(name=artist_name, main_album_list=album_list, source_list=[source])
 
     def download_song_to_target(self, source: Source, target: Target, desc: str = None) -> DownloadResult:
         """

music_kraken/pages/youtube_music/_list_render.py

@@ -7,6 +7,7 @@ from ..abstract import Page
 from ...objects import (
     Artist,
     Source,
+    SourcePages,
     Song,
     Album,
     Label,
@@ -58,19 +59,6 @@ def music_responsive_list_item_renderer(renderer: dict) -> List[DatabaseObject]:
         song.album_collection.extend(album_list)
         return [song]
 
-    if len(album_list) == 1:
-        album = album_list[0]
-        album.artist_collection.extend(artist_list)
-        album.song_collection.extend(song_list)
-        return [album]
-
-    """
-    if len(artist_list) == 1:
-        artist = artist_list[0]
-        artist.main_album_collection.extend(album_list)
-        return [artist]
-    """
-
     return results
 
 

music_kraken/pages/youtube_music/_music_object_render.py

@@ -3,13 +3,12 @@ from enum import Enum
 
 from ...utils.config import youtube_settings, logging_settings
 from ...utils.string_processing import clean_song_title
-from ...utils.enums import SourceType, ALL_SOURCE_TYPES
-
 from ...objects import Source, DatabaseObject
 from ..abstract import Page
 from ...objects import (
     Artist,
     Source,
+    SourcePages,
     Song,
     Album,
     Label,
@@ -19,7 +18,7 @@ from ...objects import (
 LOGGER = logging_settings["youtube_music_logger"]
 
 
-SOURCE_PAGE = ALL_SOURCE_TYPES.YOUTUBE
+SOURCE_PAGE = SourcePages.YOUTUBE_MUSIC
 
 
 class PageType(Enum):

music_kraken/pages/youtube_music/super_youtube.py

@@ -10,6 +10,7 @@ from ..abstract import Page
 from ...objects import (
     Artist,
     Source,
+    SourcePages,
     Song,
     Album,
     Label,
@@ -20,7 +21,6 @@ from ...objects import (
 from ...connection import Connection
 from ...utils.support_classes.download_result import DownloadResult
 from ...utils.config import youtube_settings, logging_settings, main_settings
-from ...utils.enums import SourceType, ALL_SOURCE_TYPES
 
 
 def get_invidious_url(path: str = "", params: str = "", query: str = "", fragment: str = "") -> str:
@@ -50,7 +50,7 @@ class YouTubeUrl:
     """
     
     def __init__(self, url: str) -> None:
-        self.SOURCE_TYPE = ALL_SOURCE_TYPES.YOUTUBE
+        self.SOURCE_TYPE = SourcePages.YOUTUBE
 
         """
         Raises Index exception for wrong url, and value error for not found enum type
@@ -58,6 +58,9 @@ class YouTubeUrl:
         self.id = ""
         parsed = urlparse(url=url)
 
+        if parsed.netloc == "music.youtube.com":
+            self.SOURCE_TYPE = SourcePages.YOUTUBE_MUSIC
+        
         self.url_type: YouTubeUrlType
         
         type_frag_list = parsed.path.split("/")
@@ -121,7 +124,8 @@ class YouTubeUrl:
 
 class SuperYouTube(Page):
     # CHANGE
-    SOURCE_TYPE = ALL_SOURCE_TYPES.YOUTUBE
+    SOURCE_TYPE = SourcePages.YOUTUBE
+    LOGGER = logging_settings["youtube_logger"]
 
     NO_ADDITIONAL_DATA_FROM_SONG = False
 
@@ -141,8 +145,6 @@ class SuperYouTube(Page):
         _sponsorblock_connection: Connection = Connection()
         self.sponsorblock = python_sponsorblock.SponsorBlock(silent=True, session=_sponsorblock_connection.session)
 
-        super().__init__(*args, **kwargs)
-
     def get_source_type(self, source: Source) -> Optional[Type[DatabaseObject]]:
         _url_type = {
             YouTubeUrlType.CHANNEL: Artist,

music_kraken/pages/youtube_music/youtube_music.py

@@ -1,33 +1,44 @@
-from __future__ import annotations, unicode_literals
+from __future__ import unicode_literals, annotations
 
-import json
+from typing import Dict, List, Optional, Set, Type
+from urllib.parse import urlparse, urlunparse, quote, parse_qs, urlencode
 import logging
 import random
-import re
-from collections import defaultdict
+import json
 from dataclasses import dataclass
+import re
 from functools import lru_cache
-from typing import Dict, List, Optional, Set, Type
-from urllib.parse import parse_qs, quote, urlencode, urlparse, urlunparse
+from collections import defaultdict
 
 import youtube_dl
 from youtube_dl.extractor.youtube import YoutubeIE
 from youtube_dl.utils import DownloadError
 
-from ...connection import Connection
-from ...objects import Album, Artist, ArtworkCollection
-from ...objects import DatabaseObject as DataObject
-from ...objects import (FormattedText, ID3Timestamp, Label, Lyrics, Song,
-                        Source, Target)
-from ...utils import dump_to_file, get_current_millis, traverse_json_path
-from ...utils.config import logging_settings, main_settings, youtube_settings
-from ...utils.enums import ALL_SOURCE_TYPES, SourceType
-from ...utils.enums.album import AlbumType
 from ...utils.exception.config import SettingValueError
+from ...utils.config import main_settings, youtube_settings, logging_settings
 from ...utils.shared import DEBUG, DEBUG_YOUTUBE_INITIALIZING
 from ...utils.string_processing import clean_song_title
-from ...utils.support_classes.download_result import DownloadResult
+from ...utils import get_current_millis, traverse_json_path
+
+from ...utils import dump_to_file
+
+from ...objects import Source, DatabaseObject, ID3Timestamp, Artwork
 from ..abstract import Page
+from ...objects import (
+    Artist,
+    Source,
+    SourcePages,
+    Song,
+    Album,
+    Label,
+    Target,
+    Lyrics,
+    FormattedText
+)
+from ...connection import Connection
+from ...utils.enums.album import AlbumType
+from ...utils.support_classes.download_result import DownloadResult
+
 from ._list_render import parse_renderer
 from ._music_object_render import parse_run_element
 from .super_youtube import SuperYouTube
@@ -165,7 +176,8 @@ ALBUM_TYPE_MAP = {
 
 class YoutubeMusic(SuperYouTube):
     # CHANGE
-    SOURCE_TYPE = ALL_SOURCE_TYPES.YOUTUBE
+    SOURCE_TYPE = SourcePages.YOUTUBE_MUSIC
+    LOGGER = logging_settings["youtube_music_logger"]
 
     def __init__(self, *args, ydl_opts: dict = None, **kwargs):
         self.yt_music_connection: YoutubeMusicConnection = YoutubeMusicConnection(
@@ -181,7 +193,8 @@ class YoutubeMusic(SuperYouTube):
 
         self.start_millis = get_current_millis()
 
-        self._fetch_from_main_page()
+        if self.credentials.api_key == "" or DEBUG_YOUTUBE_INITIALIZING:
+            self._fetch_from_main_page()
 
         SuperYouTube.__init__(self, *args, **kwargs)
 
@@ -202,8 +215,6 @@ class YoutubeMusic(SuperYouTube):
         self.download_values_by_url: dict = {}
         self.not_download: Dict[str, DownloadError] = {}
 
-        super().__init__(*args, **kwargs)
-
     def _fetch_from_main_page(self):
         """
         ===API=KEY===
@@ -336,10 +347,10 @@ class YoutubeMusic(SuperYouTube):
             default='{}'
         )) or {}
 
-    def get_source_type(self, source: Source) -> Optional[Type[DataObject]]:
+    def get_source_type(self, source: Source) -> Optional[Type[DatabaseObject]]:
         return super().get_source_type(source)
 
-    def general_search(self, search_query: str) -> List[DataObject]:
+    def general_search(self, search_query: str) -> List[DatabaseObject]:
         search_query = search_query.strip()
 
         urlescaped_query: str = quote(search_query.strip().replace(" ", "+"))
@@ -425,7 +436,6 @@ class YoutubeMusic(SuperYouTube):
         data: dict = r.json()
         header = data.get("header", {})
         musicDetailHeaderRenderer = header.get("musicDetailHeaderRenderer", {})
-        musicImmersiveHeaderRenderer = header.get("musicImmersiveHeaderRenderer", {})
         
         title_runs: List[dict] = musicDetailHeaderRenderer.get("title", {}).get("runs", [])
         subtitle_runs: List[dict] = musicDetailHeaderRenderer.get("subtitle", {}).get("runs", [])
@@ -438,11 +448,6 @@ class YoutubeMusic(SuperYouTube):
         renderer_list = r.json().get("contents", {}).get("singleColumnBrowseResultsRenderer", {}).get("tabs", [{}])[
             0].get("tabRenderer", {}).get("content", {}).get("sectionListRenderer", {}).get("contents", [])
 
-        # fetch artist artwork
-        artist_thumbnails = musicImmersiveHeaderRenderer.get("thumbnail", {}).get("musicThumbnailRenderer", {}).get("thumbnail", {}).get("thumbnails", {})
-        for artist_thumbnail in artist_thumbnails:
-            artist.artwork.append(artist_thumbnail)
-
         if DEBUG:
             for i, content in enumerate(renderer_list):
                 dump_to_file(f"{i}-artists-renderer.json", json.dumps(content), is_json=True, exit_after_dump=False)
@@ -489,12 +494,7 @@ class YoutubeMusic(SuperYouTube):
         # album details
         header = data.get("header", {})
         musicDetailHeaderRenderer = header.get("musicDetailHeaderRenderer", {})
-
-        # album artwork
-        album_thumbnails = musicDetailHeaderRenderer.get("thumbnail", {}).get("croppedSquareThumbnailRenderer", {}).get("thumbnail", {}).get("thumbnails", {})
-        for album_thumbnail in album_thumbnails:
-            album.artwork.append(value=album_thumbnail)
-
+        
         title_runs: List[dict] = musicDetailHeaderRenderer.get("title", {}).get("runs", [])
         subtitle_runs: List[dict] = musicDetailHeaderRenderer.get("subtitle", {}).get("runs", [])
 
@@ -547,11 +547,6 @@ class YoutubeMusic(SuperYouTube):
         return album
 
     def fetch_lyrics(self, video_id: str, playlist_id: str = None) -> str:
-        """
-        1. fetches the tabs of a song, to get the browse id
-        2. finds the browse id of the lyrics
-        3. fetches the lyrics with the browse id
-        """
         request_data = {
             "context": {**self.credentials.context, "adSignalsInfo": {"params": []}},
             "videoId": video_id,
@@ -578,8 +573,7 @@ class YoutubeMusic(SuperYouTube):
             pageType = traverse_json_path(tab, "tabRenderer.endpoint.browseEndpoint.browseEndpointContextSupportedConfigs.browseEndpointContextMusicConfig.pageType", default="")
             if pageType in ("MUSIC_TAB_TYPE_LYRICS", "MUSIC_PAGE_TYPE_TRACK_LYRICS") or "lyrics" in pageType.lower():
                 browse_id = traverse_json_path(tab, "tabRenderer.endpoint.browseEndpoint.browseId", default=None)
-                if browse_id is not None:
-                    break
+                break
 
         if browse_id is None:
             return None
@@ -593,8 +587,6 @@ class YoutubeMusic(SuperYouTube):
             },
             name=f"fetch_song_lyrics_{video_id}.json"
         )
-        if r is None:
-            return None
 
         dump_to_file(f"fetch_song_lyrics_{video_id}.json", r.text, is_json=True, exit_after_dump=False)
 
@@ -626,7 +618,7 @@ class YoutubeMusic(SuperYouTube):
             Artist(
                 name=name,
                 source_list=[Source(
-                    self.SOURCE_TYPE, 
+                    SourcePages.YOUTUBE_MUSIC, 
                     f"https://music.youtube.com/channel/{ydl_res.get('channel_id', ydl_res.get('uploader_id', ''))}"
             )]
         ) for name in artist_names]
@@ -644,10 +636,10 @@ class YoutubeMusic(SuperYouTube):
             note=ydl_res.get("descriptions"),
             album_list=album_list,
             length=int(ydl_res.get("duration", 0)) * 1000,
-            artwork=ArtworkCollection(*ydl_res.get("thumbnails", [])),
-            artist_list=artist_list,
+            artwork=Artwork(*ydl_res.get("thumbnails", [])),
+            main_artist_list=artist_list,
             source_list=[Source(
-                self.SOURCE_TYPE,
+                SourcePages.YOUTUBE_MUSIC,
                 f"https://music.youtube.com/watch?v={ydl_res.get('id')}"
             ), source],
         )
@@ -683,7 +675,7 @@ class YoutubeMusic(SuperYouTube):
             for album in song.album_list:
                 album.album_type = AlbumType.LIVE_ALBUM
         for thumbnail in video_details.get("thumbnails", []):
-            song.artwork.add_data(**thumbnail)
+            song.artwork.append(**thumbnail)
 
         song.lyrics_collection.append(self.fetch_lyrics(browse_id, playlist_id=request_data.get("playlistId")))
 
@@ -725,6 +717,7 @@ class YoutubeMusic(SuperYouTube):
 
         self.download_values_by_url[source.url] = {
             "url": _best_format.get("url"),
+            "chunk_size": _best_format.get("downloader_options", {}).get("http_chunk_size", main_settings["chunk_size"]),
             "headers": _best_format.get("http_headers", {}),
         }
 
@@ -743,9 +736,8 @@ class YoutubeMusic(SuperYouTube):
                 raw_headers=True,
                 disable_cache=True,
                 headers=media.get("headers", {}),
-                chunk_size=main_settings["chunk_size"],
+                # chunk_size=media.get("chunk_size", main_settings["chunk_size"]),
                 method="GET",
-                timeout=5,
             )
         else:
             result = DownloadResult(error_message=str(media.get("error") or self.not_download[source.hash_url]))

music_kraken/utils/__init__.py

@@ -1,18 +1,15 @@
-import inspect
+from datetime import datetime
+from pathlib import Path
 import json
 import logging
-from datetime import datetime
-from functools import lru_cache
-from pathlib import Path
-from typing import Any, List, Union
+import inspect
+from typing import List, Union
 
+from .shared import DEBUG, DEBUG_LOGGING, DEBUG_DUMP, DEBUG_TRACE, DEBUG_OBJECT_TRACE, DEBUG_OBJECT_TRACE_CALLSTACK
 from .config import config, read_config, write_config
 from .enums.colors import BColors
-from .hacking import merge_args
 from .path_manager import LOCATIONS
-from .shared import (DEBUG, DEBUG_DUMP, DEBUG_LOGGING, DEBUG_OBJECT_TRACE,
-                     DEBUG_OBJECT_TRACE_CALLSTACK, DEBUG_TRACE, URL_PATTERN)
-from .string_processing import hash_url, is_url, unify
+from .hacking import merge_args
 
 """
 IO functions
@@ -128,35 +125,4 @@ def get_current_millis() -> int:
 
 
 def get_unix_time() -> int:
-    return int(datetime.now().timestamp())
-
-
-@lru_cache
-def custom_hash(value: Any) -> int:
-    if is_url(value):
-        value = hash_url(value)
-    elif isinstance(value, str):
-        try:
-            value = int(value)
-        except ValueError:
-            value = unify(value)
-    
-    return hash(value)
-
-
-def create_dataclass_instance(t, data: dict):
-    """Creates an instance of a dataclass with the given data.
-    It filters out all data key, which has no attribute in the dataclass.
-
-    Args:
-        t (Type): The dataclass type class
-        data (dict): the attribute to pass into the constructor
-    
-    Returns:
-        Tuple[Type, dict]: The created instance and a dict, containing the data, which was not used in the creation
-    """
-    
-    needed_data = {k: v for k, v in data.items() if k in t.__dataclass_fields__}
-    removed_data = {k: v for k, v in data.items() if k not in t.__dataclass_fields__}
-
-    return t(**needed_data), removed_data
+    return int(datetime.now().timestamp())

music_kraken/utils/config/__init__.py

@@ -1,8 +1,11 @@
 from typing import Tuple
 
 from .config import Config
-from .config_files import main_config, logging_config, youtube_config
-
+from .config_files import (
+    main_config,
+    logging_config,
+    youtube_config,
+)
 
 _sections: Tuple[Config, ...] = (
     main_config.config,

music_kraken/utils/config/config_files/main_config.py

@@ -18,9 +18,8 @@ config = Config((
     AudioFormatAttribute(name="audio_format", default_value="mp3", description="""Music Kraken will stream the audio into this format.
 You can use Audio formats which support ID3.2 and ID3.1,
 but you will have cleaner Metadata using ID3.2."""),
-    Attribute(name="image_format", default_value="jpeg", description="This Changes the format in which images are getting downloaded"),
 
-    Attribute(name="result_history", default_value=True, description="""If enabled, you can go back to the previous results.
+    Attribute(name="result_history", default_value=False, description="""If enabled, you can go back to the previous results.
 The consequence is a higher meory consumption, because every result is saved."""),
     Attribute(name="history_length", default_value=8, description="""You can choose how far back you can go in the result history.
 The further you choose to be able to go back, the higher the memory usage.
@@ -29,7 +28,6 @@ The further you choose to be able to go back, the higher the memory usage.
     EmptyLine(),
 
     Attribute(name="preferred_artwork_resolution", default_value=1000),
-    Attribute(name="download_artist_artworks", default_value=True, description="Enables the fetching of artist galleries."),
 
     EmptyLine(),
 
@@ -46,7 +44,6 @@ This means for example, the Studio Albums and EP's are always in front of Single
 - album_type
 The folder music kraken should put the songs into."""),
     Attribute(name="download_file", default_value="{song}.{audio_format}", description="The filename of the audio file."),
-    Attribute(name="artist_artwork_path", default_value="{genre}/{artist}/{artist}_{image_number}.{image_format}", description="The Path to download artist images to."),
     SelectAttribute(name="album_type_blacklist", default_value=[
         "Compilation Album",
         "Live Album",
@@ -155,13 +152,10 @@ class SettingsStructure(TypedDict):
 
     # artwork
     preferred_artwork_resolution: int
-    image_format: str
-    download_artist_artworks: bool
 
     # paths
     music_directory: Path
     temp_directory: Path
-    artist_artwork_path: Path
     log_file: Path
     not_a_genre_regex: List[str]
     ffmpeg_binary: Path

music_kraken/utils/enums/__init__.py

@@ -1,128 +1 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-from enum import Enum
-from typing import TYPE_CHECKING, Optional, Type
-
-from mutagen.id3 import PictureType
-
-if TYPE_CHECKING:
-    from ...pages.abstract import Page
-
-@dataclass
-class SourceType:
-    name: str
-    homepage: Optional[str] = None
-    download_priority: int = 0
-
-    page_type: Type[Page] = None
-    page: Page = None
-
-    def register_page(self, page: Page):
-        self.page = page
-
-    def __hash__(self):
-        return hash(self.name)
-
-    @property
-    def has_page(self) -> bool:
-        return self.page is not None
-
-    # for backwards compatibility
-    @property
-    def value(self) -> str:
-        return self.name
-
-
-class ALL_SOURCE_TYPES:
-    YOUTUBE = SourceType(name="youtube", homepage="https://music.youtube.com/")
-    BANDCAMP = SourceType(name="bandcamp", homepage="https://bandcamp.com/", download_priority=10)
-    MUSIFY = SourceType(name="musify", homepage="https://musify.club/", download_priority=7)
-    
-    GENIUS = SourceType(name="genius", homepage="https://genius.com/")
-    MUSICBRAINZ = SourceType(name="musicbrainz", homepage="https://musicbrainz.org/")
-    ENCYCLOPAEDIA_METALLUM = SourceType(name="encyclopaedia metallum")
-    DEEZER = SourceType(name="deezer", homepage="https://www.deezer.com/")
-    SPOTIFY = SourceType(name="spotify", homepage="https://open.spotify.com/")
-
-    # This has nothing to do with audio, but bands can be here
-    WIKIPEDIA = SourceType(name="wikipedia", homepage="https://en.wikipedia.org/wiki/Main_Page")
-    INSTAGRAM = SourceType(name="instagram", homepage="https://www.instagram.com/")
-    FACEBOOK = SourceType(name="facebook", homepage="https://www.facebook.com/")
-    TWITTER = SourceType(name="twitter", homepage="https://twitter.com/")
-    # Yes somehow this ancient site is linked EVERYWHERE
-    MYSPACE = SourceType(name="myspace", homepage="https://myspace.com/")     
-
-    MANUAL = SourceType(name="manual")
-    
-    PRESET = SourceType(name="preset")
-
-
-class PictureType(Enum):
-    """Enumeration of image types defined by the ID3 standard for the APIC
-    frame, but also reused in WMA/FLAC/VorbisComment.
-
-    This is copied from mutagen.id3.PictureType
-    """
-
-    OTHER = 0
-
-    FILE_ICON = 1
-    """32x32 pixels 'file icon' (PNG only)"""
-
-    OTHER_FILE_ICON = 2
-    """Other file icon"""
-
-    COVER_FRONT = 3
-    """Cover (front)"""
-
-    COVER_BACK = 4
-    """Cover (back)"""
-
-    LEAFLET_PAGE = 5
-    """Leaflet page"""
-
-    MEDIA = 6
-    """Media (e.g. label side of CD)"""
-
-    LEAD_ARTIST = 7
-    """Lead artist/lead performer/soloist"""
-
-    ARTIST = 8
-    """Artist/performer"""
-
-    CONDUCTOR = 9
-    """Conductor"""
-
-    BAND = 10
-    """Band/Orchestra"""
-
-    COMPOSER = 11
-    """Composer"""
-
-    LYRICIST = 12
-    """Lyricist/text writer"""
-
-    RECORDING_LOCATION = 13
-    """Recording Location"""
-
-    DURING_RECORDING = 14
-    """During recording"""
-
-    DURING_PERFORMANCE = 15
-    """During performance"""
-
-    SCREEN_CAPTURE = 16
-    """Movie/video screen capture"""
-
-    FISH = 17
-    """A bright colored fish"""
-
-    ILLUSTRATION = 18
-    """Illustration"""
-
-    BAND_LOGOTYPE = 19
-    """Band/artist logotype"""
-
-    PUBLISHER_LOGOTYPE = 20
-    """Publisher/Studio logotype"""
+from .source import SourcePages

music_kraken/utils/enums/source.py

@@ -0,0 +1,40 @@
+from enum import Enum
+
+
+class SourceTypes(Enum):
+    SONG = "song"
+    ALBUM = "album"
+    ARTIST = "artist"
+    LYRICS = "lyrics"
+
+
+class SourcePages(Enum):
+    YOUTUBE = "youtube", "https://www.youtube.com/"
+    MUSIFY = "musify", "https://musify.club/"
+    YOUTUBE_MUSIC = "youtube music", "https://music.youtube.com/"
+    GENIUS = "genius", "https://genius.com/"
+    MUSICBRAINZ = "musicbrainz", "https://musicbrainz.org/"
+    ENCYCLOPAEDIA_METALLUM = "encyclopaedia metallum"
+    BANDCAMP = "bandcamp", "https://bandcamp.com/"
+    DEEZER = "deezer", "https://www.deezer.com/"
+    SPOTIFY = "spotify", "https://open.spotify.com/"
+
+    # This has nothing to do with audio, but bands can be here
+    WIKIPEDIA = "wikipedia", "https://en.wikipedia.org/wiki/Main_Page"
+    INSTAGRAM = "instagram", "https://www.instagram.com/"
+    FACEBOOK = "facebook", "https://www.facebook.com/"
+    TWITTER = "twitter", "https://twitter.com/"
+    MYSPACE = "myspace", "https://myspace.com/"     # Yes somehow this ancient site is linked EVERYWHERE
+
+    MANUAL = "manual", ""
+    
+    PRESET = "preset", ""
+
+    def __new__(cls, value, homepage = None):
+        member = object.__new__(cls)
+    
+        member._value_ = value
+        member.homepage = homepage
+
+        return member
+        

music_kraken/utils/exception/__init__.py

@@ -4,20 +4,8 @@ class MKBaseException(Exception):
         super().__init__(message, **kwargs)
 
 
-# Downloading
-class MKDownloadException(MKBaseException):
-    pass
-
-
-class MKMissingNameException(MKDownloadException):
-    pass
-
-
-# Frontend
 class MKFrontendException(MKBaseException):
     pass
 
 class MKInvalidInputException(MKFrontendException):
     pass
-
-

music_kraken/utils/shared.py

@@ -12,14 +12,14 @@ if not load_dotenv(Path(__file__).parent.parent.parent / ".env"):
 
 __stage__ = os.getenv("STAGE", "prod")
 
-DEBUG = (__stage__ == "dev") and True
+DEBUG = (__stage__ == "dev") and False
 DEBUG_LOGGING = DEBUG and False
 DEBUG_TRACE = DEBUG and True
 DEBUG_OBJECT_TRACE = DEBUG and False
 DEBUG_OBJECT_TRACE_CALLSTACK = DEBUG_OBJECT_TRACE and False
 DEBUG_YOUTUBE_INITIALIZING = DEBUG and False
 DEBUG_PAGES = DEBUG and False
-DEBUG_DUMP = DEBUG and True
+DEBUG_DUMP = DEBUG and False
 DEBUG_PRINT_ID = DEBUG and True
 
 if DEBUG:

music_kraken/utils/string_processing.py

@@ -1,15 +1,13 @@
-import re
+from typing import Tuple, Union, Optional
+from pathlib import Path
 import string
 from functools import lru_cache
-from pathlib import Path
-from typing import Any, Optional, Tuple, Union
-from urllib.parse import ParseResult, parse_qs, urlparse
 
-from pathvalidate import sanitize_filename
-from transliterate import translit
 from transliterate.exceptions import LanguageDetectionError
+from transliterate import translit
+from pathvalidate import sanitize_filename
+from urllib.parse import urlparse, ParseResult, parse_qs
 
-from .shared import URL_PATTERN
 
 COMMON_TITLE_APPENDIX_LIST: Tuple[str, ...] = (
     "(official video)",
@@ -231,13 +229,3 @@ def shorten_display_url(url: str, max_length: int = 150, chars_at_end: int = 4,
         return url
     
     return url[:max_length] + shorten_string + url[-chars_at_end:]
-
-def is_url(value: Any) -> bool:
-    if isinstance(value, ParseResult):
-        return True
-    
-    if not isinstance(value, str):
-        return True
-        
-    # value has to be a string
-    return re.match(URL_PATTERN, value) is not None

music_kraken/utils/support_classes/download_result.py

@@ -1,13 +1,9 @@
-from __future__ import annotations
-
 from dataclasses import dataclass, field
-from typing import TYPE_CHECKING, List, Tuple
+from typing import List, Tuple
 
-if TYPE_CHECKING:
-    from ...objects import Target
-
-from ...utils.config import logging_settings, main_settings
+from ...utils.config import main_settings, logging_settings
 from ...utils.enums.colors import BColors
+from ...objects import Target
 
 UNIT_PREFIXES: List[str] = ["", "k", "m", "g", "t"]
 UNIT_DIVISOR = 1024

music_kraken/utils/support_classes/query.py

@@ -24,7 +24,7 @@ class Query:
             return [self.music_object.name]
         
         if isinstance(self.music_object, Song):
-            return [f"{artist.name} - {self.music_object}" for artist in self.music_object.artist_collection]
+            return [f"{artist.name} - {self.music_object}" for artist in self.music_object.main_artist_collection]
         
         if isinstance(self.music_object, Album):
             return [f"{artist.name} - {self.music_object}" for artist in self.music_object.artist_collection]

pyproject.toml

@@ -69,7 +69,7 @@ dependencies = [
     "toml~=0.10.2",
     "typing_extensions~=4.7.1",
 
-    "python-sponsorblock~=0.1",
+    "python-sponsorblock~=0.0.dev1",
     "youtube_dl",
 ]
 dynamic = [

tests/test_collection.py

@@ -3,98 +3,96 @@ import unittest
 from music_kraken.objects import Song, Album, Artist, Collection, Country
 
 class TestCollection(unittest.TestCase):
-    def test_song_contains_album(self):
-        """
-        Tests that every song contains the album it is added to in its album_collection
-        """
-
-        a_1 = Album(
-            title="album",
-            song_list= [
-                Song(title="song"),
-            ]
-        )
-        a_2 = a_1.song_collection[0].album_collection[0]
-        self.assertTrue(a_1.id == a_2.id)
-
-    def test_album_contains_song(self):
-        """
-        Tests that every album contains the song it is added to in its song_collection
-        """
-        s_1 = Song(
-            title="song",
-            album_list=[
-                Album(title="album"),
-            ]
-        )
-        s_2 = s_1.album_collection[0].song_collection[0]
-        self.assertTrue(s_1.id == s_2.id)
-
-
-    def test_auto_add_artist_to_album_feature_artist(self):
-        """
-        Tests that every artist is added to the album's feature_artist_collection per default
-        """
-
-        a_1 = Artist(
+    @staticmethod
+    def complicated_object() -> Artist:
+        return Artist(
             name="artist",
-            album_list=[
-                Album(title="album")
-            ]
-        )
-        a_2 = a_1.album_collection[0].feature_artist_collection[0]
-
-        self.assertTrue(a_1.id == a_2.id)
-    
-    def test_auto_add_artist_to_album_feature_artist_push(self):
-        """
-        Tests that every artist is added to the album's feature_artist_collection per default but pulled into the album's artist_collection if a merge exitst
-        """
-
-        a_1 = Artist(
-            name="artist",
-            album_list=[
+            country=Country.by_alpha_2("DE"),
+            main_album_list=[
                 Album(
                     title="album",
+                    song_list=[
+                        Song(
+                            title="song",
+                            album_list=[
+                                Album(title="album", albumsort=123),
+                            ],
+                        ),
+                        Song(
+                            title="other_song",
+                            album_list=[
+                                Album(title="album", albumsort=423),
+                            ],
+                        ),
+                    ]
+                ),
+                Album(title="album", barcode="1234567890123"),
+            ]
+        )
+
+    def test_song_album_relation(self):
+        """
+        Tests that
+        album = album.any_song.one_album
+        is the same object
+        """
+
+        a = self.complicated_object().main_album_collection[0]
+        b = a.song_collection[0].album_collection[0]
+        c = a.song_collection[1].album_collection[0]
+        d = b.song_collection[0].album_collection[0]
+        e = d.song_collection[0].album_collection[0]
+        f = e.song_collection[0].album_collection[0]
+        g = f.song_collection[0].album_collection[0]
+
+        self.assertTrue(a.id == b.id == c.id == d.id == e.id == f.id == g.id)
+        self.assertTrue(a.title == b.title == c.title == d.title == e.title == f.title == g.title == "album")
+        self.assertTrue(a.barcode == b.barcode == c.barcode == d.barcode == e.barcode == f.barcode == g.barcode == "1234567890123")
+        self.assertTrue(a.albumsort == b.albumsort == c.albumsort == d.albumsort == e.albumsort == f.albumsort == g.albumsort == 123)
+
+        d.title = "new_title"
+
+        self.assertTrue(a.title == b.title == c.title == d.title == e.title == f.title == g.title == "new_title")
+
+    def test_album_artist_relation(self):
+        """
+        Tests that
+        artist = artist.any_album.any_song.one_artist
+        is the same object
+        """
+
+        a = self.complicated_object()
+        b = a.main_album_collection[0].artist_collection[0]
+        c = b.main_album_collection[0].artist_collection[0]
+        d = c.main_album_collection[0].artist_collection[0]
+
+        self.assertTrue(a.id == b.id == c.id == d.id)
+        self.assertTrue(a.name == b.name == c.name == d.name == "artist")
+        self.assertTrue(a.country == b.country == c.country == d.country)
+
+    def test_artist_artist_relation(self):
+        artist = Artist(
+            name="artist",
+            main_album_list=[
+                Album(
+                    title="album",
+                    song_list=[
+                        Song(title="song"),
+                    ],
                     artist_list=[
                         Artist(name="artist"),
                     ]
                 )
             ]
         )
-        a_2 = a_1.album_collection[0].artist_collection[0]
 
-        self.assertTrue(a_1.id == a_2.id)
-
-
-    def test_artist_artist_relation(self):
-        """
-        Tests the proper syncing between album.artist_collection and song.artist_collection
-        """
-
-        album = Album(
-            title="album",
-            song_list=[
-                Song(title="song"),
-            ],
-            artist_list=[
-                Artist(name="artist"),
-            ]
-        )
-        a_1 = album.artist_collection[0]
-        a_2 = album.song_collection[0].artist_collection[0]
-
-        self.assertTrue(a_1.id == a_2.id)
+        self.assertTrue(artist.id == artist.main_album_collection[0].song_collection[0].main_artist_collection[0].id)
 
     def test_artist_collection_sync(self):
-        """
-        tests the actual implementation of the test above
-        """
-
         album_1 = Album(
             title="album",
             song_list=[
-                Song(title="song", artist_list=[Artist(name="artist")]),
+                Song(title="song", main_artist_list=[Artist(name="artist")]),
             ],
             artist_list=[
                 Artist(name="artist"),
@@ -104,7 +102,7 @@ class TestCollection(unittest.TestCase):
         album_2 = Album(
             title="album",
             song_list=[
-                Song(title="song", artist_list=[Artist(name="artist")]),
+                Song(title="song", main_artist_list=[Artist(name="artist")]),
             ],
             artist_list=[
                 Artist(name="artist"),
@@ -113,7 +111,17 @@ class TestCollection(unittest.TestCase):
 
         album_1.merge(album_2)
 
-        self.assertTrue(id(album_1.artist_collection) == id(album_1.artist_collection) == id(album_1.song_collection[0].artist_collection) == id(album_1.song_collection[0].artist_collection))
+        self.assertTrue(id(album_1.artist_collection) == id(album_1.artist_collection) == id(album_1.song_collection[0].main_artist_collection) == id(album_1.song_collection[0].main_artist_collection))
+
+    def test_song_artist_relations(self):
+        a = self.complicated_object()
+        b = a.main_album_collection[0].song_collection[0].main_artist_collection[0]
+        c = b.main_album_collection[0].song_collection[0].main_artist_collection[0]
+        d = c.main_album_collection[0].song_collection[0].main_artist_collection[0]
+
+        self.assertTrue(a.id == b.id == c.id == d.id)
+        self.assertTrue(a.name == b.name == c.name == d.name == "artist")
+        self.assertTrue(a.country == b.country == c.country == d.country)
 
 if __name__ == "__main__":
     unittest.main()