feat: musicbrainz overall search

Reviewed-on: #38

.vscode/settings.json

@@ -27,6 +27,7 @@
         "Gitea",
         "iframe",
         "isrc",
+        "itemprop",
         "levenshtein",
         "metallum",
         "MUSICBRAINZ",

development/actual_donwload.py

@@ -6,9 +6,10 @@ logging.getLogger().setLevel(logging.DEBUG)
 
 if __name__ == "__main__":
     commands = [
-        "s: #a I'm in a coffin",
-        "0",
-        "d: 0",
+        "s: #a Crystal F",
+        "10",
+        "1",
+        "3",
     ]
 
     

development/objects_collection.py

@@ -13,7 +13,7 @@ if __name__ == "__main__":
 
     song_2 = Song(
         title = "song",
-        main_artist_list=[other_artist]
+        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.main_artist_collection)
+    print("main", *song_1.artist_collection)
     print("feat", *song_1.feature_artist_collection)

music_kraken/audio/metadata.py

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

music_kraken/cli/main_downloader.py

@@ -226,7 +226,7 @@ class Downloader:
             if album is not None:
                 song.album_collection.append(album)
             if artist is not None:
-                song.main_artist_collection.append(artist)
+                song.artist_collection.append(artist)
             return Query(raw_query=query, music_object=song)
 
         if album is not None:
@@ -354,37 +354,41 @@ 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:
-                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 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:
                 self.search(":".join(input_str.split(":")[1:]))
                 return False
 
-            indices = []
-            for possible_index in query.split(","):
-                possible_index = possible_index.strip()
-                if possible_index == "":
-                    continue
+            def get_selected_objects(q: str):
+                if q.strip().lower() == "all":
+                    return list(self.current_results)
 
-                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
                     
-                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}.")
+                    i = 0
+                    try:
+                        i = int(possible_index)
+                    except ValueError:
+                        raise MKInvalidInputException(message=f"The index \"{possible_index}\" is not a number.")
 
-                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}.")
                     
-            selected_objects = [self.current_results[i] for i in indices]
+                    indices.append(i)
+
+                return [self.current_results[i] for i in indices]
+
+            selected_objects = get_selected_objects(query)
 
             if do_merge:
                 old_selected_objects = selected_objects
@@ -397,6 +401,13 @@ 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,6 +6,7 @@ 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
 
@@ -136,13 +137,13 @@ class Cache:
         )
         self._write_attribute(cache_attribute)
 
-        cache_path = fit_to_file_system(Path(module_path, name), hidden_ok=True)
+        cache_path = fit_to_file_system(Path(module_path, name.replace("/", "_")), 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), hidden_ok=True)
+        path = fit_to_file_system(Path(self._dir, self.module, name.replace("/", "_")), hidden_ok=True)
 
         if not path.is_file():
             return None
@@ -165,7 +166,7 @@ class Cache:
             if ca.name == "":
                 continue
 
-            file = fit_to_file_system(Path(self._dir, ca.module, ca.name), hidden_ok=True)
+            file = fit_to_file_system(Path(self._dir, ca.module, ca.name.replace("/", "_")), hidden_ok=True)
 
             if not ca.is_valid:
                 self.logger.debug(f"deleting cache {ca.id}")
@@ -204,9 +205,12 @@ 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/download/page_attributes.py

@@ -30,14 +30,16 @@ from ..utils.exception import MKMissingNameException
 from ..utils.exception.download import UrlNotFoundException
 from ..utils.shared import DEBUG_PAGES
 
-from ..pages import Page, EncyclopaediaMetallum, Musify, YouTube, YoutubeMusic, Bandcamp, INDEPENDENT_DB_OBJECTS
+from ..pages import Page, EncyclopaediaMetallum, Musify, YouTube, YoutubeMusic, Bandcamp, Musicbrainz, Genius, INDEPENDENT_DB_OBJECTS
 
 
 ALL_PAGES: Set[Type[Page]] = {
     # EncyclopaediaMetallum,
+    Genius,
     Musify,
     YoutubeMusic,
-    Bandcamp
+    Bandcamp,
+    Musicbrainz
 }
 
 if youtube_settings["use_youtube_alongside_youtube_music"]:
@@ -235,14 +237,14 @@ class Pages:
         
         # manage the naming
         naming: Dict[str, List[str]] = defaultdict(list, naming)
-        naming["song"].append(song.title_string)
+        naming["song"].append(song.title_value)
         naming["isrc"].append(song.isrc)
-        naming["album"].extend(a.title_string for a in song.album_collection)
+        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.main_artist_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_string for l in a.label_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

music_kraken/objects/artwork.py

@@ -59,4 +59,6 @@ class Artwork:
                 self._variant_mapping[key] = value
 
     def __eq__(self, other: Artwork) -> bool:
+        if not isinstance(other, Artwork):
+            return False
         return any(a == b for a, b in zip(self._variant_mapping.keys(), other._variant_mapping.keys()))

music_kraken/objects/collection.py

@@ -115,13 +115,6 @@ 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)
@@ -141,6 +134,13 @@ 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)
+
     def append(self, other: Optional[T], **kwargs):
         """
         If an object, that represents the same entity exists in a relevant collection,
@@ -160,6 +160,7 @@ 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

@@ -38,11 +38,19 @@ class FormattedText:
     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
 

music_kraken/objects/parents.py

@@ -339,6 +339,10 @@ class OuterProxy:
     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})"
 

music_kraken/objects/song.py

@@ -95,7 +95,7 @@ class Song(Base):
     target_collection: Collection[Target]
     lyrics_collection: Collection[Lyrics]
 
-    main_artist_collection: Collection[Artist]
+    artist_collection: Collection[Artist]
     feature_artist_collection: Collection[Artist]
     album_collection: Collection[Album]
 
@@ -107,8 +107,8 @@ class Song(Base):
         "lyrics_collection": Collection,
         "artwork": Artwork,
 
-        "main_artist_collection": Collection,
         "album_collection": Collection,
+        "artist_collection": Collection,
         "feature_artist_collection": Collection,
 
         "title": lambda: None,
@@ -129,7 +129,7 @@ class Song(Base):
         source_list: List[Source] = None,
         target_list: List[Target] = None, 
         lyrics_list: List[Lyrics] = None,
-        main_artist_list: List[Artist] = None, 
+        artist_list: List[Artist] = None, 
         feature_artist_list: List[Artist] = None,
         album_list: List[Album] = None, 
         tracksort: int = 0, 
@@ -141,23 +141,26 @@ class Song(Base):
 
         Base.__init__(**real_kwargs)
 
-    UPWARDS_COLLECTION_STRING_ATTRIBUTES = ("main_artist_collection", "feature_artist_collection", "album_collection")
+    UPWARDS_COLLECTION_STRING_ATTRIBUTES = ("artist_collection", "feature_artist_collection", "album_collection")
     TITEL = "title"
 
     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.main_artist_collection,
+            "artist_collection": self.artist_collection,
         }
 
         self.album_collection.append_object_to_attribute = {
             "song_collection": self,
         }
-        self.main_artist_collection.extend_object_to_attribute = {
-            "main_album_collection": self.album_collection
+        self.artist_collection.extend_object_to_attribute = {
+            "album_collection": self.album_collection
+        }
+        self.feature_artist_collection.extend_object_to_attribute = {
+            "album_collection": self.album_collection
         }
-
-        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:
@@ -200,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.main_artist_collection])
+        metadata.merge_many([a.metadata for a in self.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.main_artist_collection])
+        main_artists = ", ".join([artist.name for artist in self.artist_collection])
         feature_artists = ", ".join([artist.name for artist in self.feature_artist_collection])
 
         if len(feature_artists) == 0:
@@ -216,10 +219,11 @@ class Song(Base):
 
     @property
     def option_string(self) -> str:
-        r = OPTION_FOREGROUND.value + self.title_string + BColors.ENDC.value + OPTION_BACKGROUND.value
+        r = "song "
+        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.main_artist_collection, " by {}")
-        r += get_collection_string(self.feature_artist_collection, " feat. {}")
+        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 {}")
         return r
 
     @property
@@ -234,11 +238,6 @@ 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
@@ -252,8 +251,9 @@ class Album(Base):
 
     source_collection: SourceCollection
 
-    artist_collection: Collection[Artist]
     song_collection: Collection[Song]
+    artist_collection: Collection[Artist]
+    feature_artist_collection: Collection[Artist]
     label_collection: Collection[Label]
 
     _default_factories = {
@@ -269,8 +269,10 @@ class Album(Base):
         "notes": FormattedText,
 
         "source_collection": SourceCollection,
-        "artist_collection": Collection,
+
         "song_collection": Collection,
+        "artist_collection": Collection,
+        "feature_artist_collection": Collection,
         "label_collection": Collection,
     }
 
@@ -303,15 +305,18 @@ class Album(Base):
     UPWARDS_COLLECTION_STRING_ATTRIBUTES = ("label_collection", "artist_collection")
 
     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 = {
-            "main_artist_collection": self.artist_collection
+            "artist_collection": self.artist_collection
         }
 
         self.artist_collection.append_object_to_attribute = {
-            "main_album_collection": self
+            "album_collection": self
         }
         self.artist_collection.extend_object_to_attribute = {
             "label_collection": self.label_collection
@@ -365,8 +370,11 @@ class Album(Base):
 
     @property
     def option_string(self) -> str:
-        r = OPTION_FOREGROUND.value + self.title_string + BColors.ENDC.value + OPTION_BACKGROUND.value
+        r = "album "
+        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:
@@ -376,6 +384,7 @@ class Album(Base):
     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
@@ -417,6 +426,16 @@ 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:
@@ -461,7 +480,7 @@ class Artist(Base):
     source_collection: SourceCollection
     contact_collection: Collection[Contact]
 
-    main_album_collection: Collection[Album]
+    album_collection: Collection[Album]
     label_collection: Collection[Label]
 
     _default_factories = {
@@ -475,7 +494,7 @@ class Artist(Base):
         "general_genre": lambda: "",
 
         "source_collection": SourceCollection,
-        "main_album_collection": Collection,
+        "album_collection": Collection,
         "contact_collection": Collection,
         "label_collection": Collection,
     }
@@ -496,7 +515,7 @@ class Artist(Base):
         source_list: List[Source] = None,
         contact_list: List[Contact] = None, 
         feature_song_list: List[Song] = None,
-        main_album_list: List[Album] = None, 
+        album_list: List[Album] = None, 
         label_list: List[Label] = None, 
         **kwargs
     ) -> None:
@@ -506,12 +525,12 @@ class Artist(Base):
         Base.__init__(**real_kwargs)
 
 
-    DOWNWARDS_COLLECTION_STRING_ATTRIBUTES = ("main_album_collection",)
+    DOWNWARDS_COLLECTION_STRING_ATTRIBUTES = ("album_collection",)
     UPWARDS_COLLECTION_STRING_ATTRIBUTES = ("label_collection",)
 
     def __init_collections__(self):
-        self.main_album_collection.append_object_to_attribute = {
-            "artist_collection": self
+        self.album_collection.append_object_to_attribute = {
+            "feature_artist_collection": self
         }
 
         self.label_collection.append_object_to_attribute = {
@@ -527,7 +546,7 @@ class Artist(Base):
             return
 
         if object_type is Album:
-            self.main_album_collection.extend(object_list)
+            self.album_collection.extend(object_list)
             return
 
         if object_type is Label:
@@ -540,7 +559,7 @@ class Artist(Base):
     def update_albumsort(self):
         """
         This updates the albumsort attributes, of the albums in
-        `self.main_album_collection`, and sorts the albums, if possible.
+        `self.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.
@@ -558,7 +577,7 @@ class Artist(Base):
 
         # order albums in the previously defined section
         album: Album
-        for album in self.main_album_collection:
+        for album in self.album_collection:
             sections[type_section[album.album_type]].append(album)
 
         def sort_section(_section: List[Album], last_albumsort: int) -> int:
@@ -589,7 +608,7 @@ class Artist(Base):
             album_list.extend(sections[section_index])
 
         # replace the old collection with the new one
-        self.main_album_collection._data = album_list
+        self.album_collection._data = album_list
 
     INDEX_DEPENDS_ON = ("name", "source_collection", "contact_collection")
     @property
@@ -611,12 +630,13 @@ class Artist(Base):
 
     @property
     def option_string(self) -> str:
-        r = OPTION_FOREGROUND.value + self.title_string + BColors.ENDC.value + OPTION_BACKGROUND.value
+        r = "artist "
+        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.main_album_collection) > 0:
-            r += f" with {len(self.main_album_collection)} albums"
+        if len(self.album_collection) > 0:
+            r += f" with {len(self.album_collection)} albums"
         
         r += BColors.ENDC.value
 
@@ -704,4 +724,4 @@ class Label(Base):
 
     @property
     def option_string(self):
-        return OPTION_FOREGROUND.value + self.name + BColors.ENDC.value
+        return "label " + OPTION_FOREGROUND.value + self.name + BColors.ENDC.value

music_kraken/pages/__init__.py

@@ -1,7 +1,9 @@
 from .encyclopaedia_metallum import EncyclopaediaMetallum
 from .musify import Musify
+from .musicbrainz import Musicbrainz
 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/bandcamp.py

@@ -117,7 +117,7 @@ class Bandcamp(Page):
             return Song(
                 title=clean_song_title(name, artist_name=data["band_name"]),
                 source_list=source_list,
-                main_artist_list=[
+                artist_list=[
                     Artist(
                         name=data["band_name"],
                         source_list=[
@@ -237,7 +237,7 @@ 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.main_album_collection.append(self._parse_album(soup=subsoup, initial_source=source))
+                artist.album_collection.append(self._parse_album(soup=subsoup, initial_source=source))
 
         for i, data_blob_soup in enumerate(soup.find_all("div", {"id": ["pagedata", "collectors-data"]})):
             data_blob = data_blob_soup["data-blob"]
@@ -246,7 +246,7 @@ 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.main_album_collection.extend(
+                artist.album_collection.extend(
                     self._parse_artist_data_blob(json.loads(data_blob), source.url)
                 )
 
@@ -370,7 +370,7 @@ class Bandcamp(Page):
                 date=ID3Timestamp.strptime(data["datePublished"], "%d %b %Y %H:%M:%S %Z"),
                 source_list=[Source(self.SOURCE_TYPE, album_data["@id"])]
             )],
-            main_artist_list=[Artist(
+            artist_list=[Artist(
                 name=artist_data["name"].strip(),
                 source_list=[Source(self.SOURCE_TYPE, _parse_artist_url(artist_data["@id"]))]
             )],

music_kraken/pages/encyclopaedia_metallum.py

@@ -52,7 +52,7 @@ def _song_from_json(artist_html=None, album_html=None, release_type=None, title=
 
     return Song(
         title=title,
-        main_artist_list=[
+        artist_list=[
             _artist_from_json(artist_html=artist_html)
         ],
         album_list=[
@@ -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.main_artist_collection.empty else [artist.name.strip() for artist in song.main_artist_collection]
+        artist_titles = ["*"] if song.artist_collection.empty else [artist.name.strip() for artist in song.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.main_album_collection.extend(discography)
+        artist.album_collection.extend(discography)
 
         return artist
 

music_kraken/pages/genius.py

@@ -0,0 +1,297 @@
+from typing import List, Optional, Type
+from urllib.parse import urlparse, urlunparse, urlencode
+import json
+from enum import Enum
+from bs4 import BeautifulSoup
+import pycountry
+
+from ..objects import Source, DatabaseObject
+from .abstract import Page
+from ..objects import (
+    Artist,
+    Source,
+    SourceType,
+    Song,
+    Album,
+    Label,
+    Target,
+    Contact,
+    ID3Timestamp,
+    Lyrics,
+    FormattedText,
+    Artwork,
+)
+from ..connection import Connection
+from ..utils import dump_to_file, traverse_json_path
+from ..utils.enums import SourceType, ALL_SOURCE_TYPES
+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
+
+
+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: Artwork, url: str):
+        if url is None:
+            return
+        
+        url_frags = url.split(".")
+        if len(url_frags) < 2:
+            artwork.append(url=url)
+            return
+
+        dimensions = url_frags[-2].split("x")
+        if len(dimensions) < 2:
+            artwork.append(url=url)
+            return
+
+        if len(dimensions) == 3:
+            dimensions = dimensions[:-1]
+        
+        try:
+            artwork.append(url=url, width=int(dimensions[0]), height=int(dimensions[1]))
+        except ValueError:
+            artwork.append(url=url)
+
+    def parse_api_object(self, data: dict) -> Optional[DatabaseObject]:
+        if data is None:
+            return None
+        object_type = data.get("_type")
+
+        artwork = Artwork()
+        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:
+            content = content.replace("\\\\", "\\").replace('\\"', '"').replace("\\'", "'")
+            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/musicbrainz.py

@@ -0,0 +1,145 @@
+from collections import defaultdict
+from dataclasses import dataclass
+from enum import Enum
+from typing import List, Optional, Type, Union, Generator, Dict, Any
+from urllib.parse import urlparse
+
+import pycountry
+import musicbrainzngs
+from bs4 import BeautifulSoup
+
+from ..connection import Connection
+from .abstract import Page
+from ..utils.enums import SourceType, ALL_SOURCE_TYPES
+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
+
+
+
+class Musicbrainz(Page):
+    SOURCE_TYPE = ALL_SOURCE_TYPES.MUSICBRAINZ
+
+    HOST = "https://musicbrainz.org"
+
+    def __init__(self, *args, **kwargs):
+        musicbrainzngs.set_useragent("mk", "1")
+
+        super().__init__(*args, **kwargs)
+    
+    def general_search(self, search_query: str) -> List[DatabaseObject]:
+        search_results = []
+
+        #Artist
+        search_results += self.artist_search(search_query).copy()
+
+        #Album
+        search_results += self.album_search(search_query).copy()
+
+        #Song
+        search_results += self.song_search(search_query).copy()
+
+        return search_results
+
+    def artist_search(self, search_query: str) -> List[Artist]:
+        artist_list = []
+        
+        #Artist
+        artist_dict_list: list = musicbrainzngs.search_artists(search_query)['artist-list']
+        artist_source_list: List[Source] = []
+        for artist_dict in artist_dict_list:
+            artist_source_list.append(Source(self.SOURCE_TYPE, self.HOST + "/artist/" + artist_dict['id']))
+            artist_list.append(Artist(
+                name=artist_dict['name'],
+                source_list=artist_source_list
+            ))
+  
+        return artist_list
+
+    def song_search(self, search_query: str) -> List[Song]:
+        song_list = []
+
+        #Song
+        song_dict_list: list = musicbrainzngs.search_recordings(search_query)['recording-list']
+        song_source_list: List[Source] = [] 
+        for song_dict in song_dict_list:
+            song_source_list.append(Source(self.SOURCE_TYPE, self.HOST + "/recording/" + song_dict['id'])) 
+            song_list.append(Song(
+                title=song_dict['title'],
+                source_list=song_source_list
+            )) 
+
+        return song_list
+    
+    def album_search(self, search_query: str) -> List[Album]:
+        album_list = []
+
+        #Album
+        album_dict_list: list = musicbrainzngs.search_release_groups(search_query)['release-group-list']
+        album_source_list: List[Source] = []
+        for album_dict in album_dict_list:
+            album_source_list.append(Source(self.SOURCE_TYPE, self.HOST + "/release-group/" + album_dict['id']))
+            album_list.append(Album(
+                title=album_dict['title'],
+                source_list=album_source_list
+            ))
+
+        return album_list
+
+
+    def fetch_album(self, source: Source, stop_at_level: int = 1) -> Album:
+        album_list = []
+
+        #Album
+        album_dict_list: list = musicbrainzngs.search_release_groups(search_query)['release-group-list']
+        album_source_list: List[Source] = []
+        for album_dict in album_dict_list:
+            album_source_list.append(Source(self.SOURCE_TYPE, self.HOST + "/release-group/" + album_dict['id']))
+            album_list.append(Album(
+                title=album_dict['title'],
+                source_list=album_source_list
+            ))
+
+    def fetch_artist(self, source: Source, stop_at_level: int = 1) -> Artist:
+        artist_list = []
+        
+        #Artist
+        artist_dict_list: list = musicbrainzngs.search_artists(search_query)['artist-list']
+        artist_source_list: List[Source] = []
+        for artist_dict in artist_dict_list:
+            artist_source_list.append(Source(self.SOURCE_TYPE, self.HOST + "/artist/" + artist_dict['id']))
+            artist_list.append(Artist(
+                name=artist_dict['name'],
+                source_list=artist_source_list,
+            ))
+
+    def fetch_song(self, source: Source, stop_at_level: int = 1) -> Song:
+        song_list = []
+
+        #Song
+        song_dict_list: list = musicbrainzngs.search_recordings(search_query)['recording-list']
+        song_source_list: List[Source] = [] 
+        for song_dict in song_dict_list:
+            song_source_list.append(Source(self.SOURCE_TYPE, self.HOST + "/recording/" + song_dict['id'])) 
+            song_list.append(Song(
+                title=song_dict['title'],
+                source_list=song_source_list
+            )) 
+    
+        

music_kraken/pages/musify.py

@@ -1054,7 +1054,7 @@ class Musify(Page):
             if not self.fetch_options.download_all and album.album_type in self.fetch_options.album_type_blacklist:
                 continue
 
-            artist.main_album_collection.append(album)
+            artist.album_collection.append(album)
 
     def fetch_artist(self, source: Source, **kwargs) -> Artist:
         """

music_kraken/pages/youtube.py

@@ -143,7 +143,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>" ),
-            main_artist_list=artist_list
+            artist_list=artist_list
         ), int(data["published"])
 
     def fetch_song(self, source: Source, stop_at_level: int = 1) -> Song:
@@ -284,7 +284,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, main_album_list=album_list, source_list=[source])
+        return Artist(name=artist_name, 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

@@ -58,6 +58,19 @@ 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/youtube_music.py

@@ -549,6 +549,11 @@ 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,
@@ -575,7 +580,8 @@ 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)
-                break
+                if browse_id is not None:
+                    break
 
         if browse_id is None:
             return None
@@ -589,6 +595,8 @@ 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)
 
@@ -639,7 +647,7 @@ class YoutubeMusic(SuperYouTube):
             album_list=album_list,
             length=int(ydl_res.get("duration", 0)) * 1000,
             artwork=Artwork(*ydl_res.get("thumbnails", [])),
-            main_artist_list=artist_list,
+            artist_list=artist_list,
             source_list=[Source(
                 self.SOURCE_TYPE,
                 f"https://music.youtube.com/watch?v={ydl_res.get('id')}"
@@ -719,7 +727,6 @@ 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", {}),
         }
 

music_kraken/utils/config/config_files/logging_config.py

@@ -59,6 +59,11 @@ Reference for the logging formats: https://docs.python.org/3/library/logging.htm
         description="The logger for the musify scraper.",
         default_value="musify"
     ),
+    LoggerAttribute(
+        name="musicbrainz_logger",
+        description="The logger for the musicbrainz scraper.",
+        default_value="musicbrainz"
+    ),
     LoggerAttribute(
         name="youtube_logger",
         description="The logger for the youtube scraper.",

music_kraken/utils/config/config_files/main_config.py

@@ -19,7 +19,7 @@ config = Config((
 You can use Audio formats which support ID3.2 and ID3.1,
 but you will have cleaner Metadata using ID3.2."""),
 
-    Attribute(name="result_history", default_value=False, description="""If enabled, you can go back to the previous results.
+    Attribute(name="result_history", default_value=True, 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.

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 False
+DEBUG = (__stage__ == "dev") and True
 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 False
+DEBUG_DUMP = DEBUG and True
 DEBUG_PRINT_ID = DEBUG and True
 
 if DEBUG:

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.main_artist_collection]
+            return [f"{artist.name} - {self.music_object}" for artist in self.music_object.artist_collection]
         
         if isinstance(self.music_object, Album):
             return [f"{artist.name} - {self.music_object}" for artist in self.music_object.artist_collection]

tests/test_collection.py

@@ -3,96 +3,98 @@ import unittest
 from music_kraken.objects import Song, Album, Artist, Collection, Country
 
 class TestCollection(unittest.TestCase):
-    @staticmethod
-    def complicated_object() -> Artist:
-        return Artist(
-            name="artist",
-            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_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_song_album_relation(self):
+    def test_album_contains_song(self):
         """
-        Tests that
-        album = album.any_song.one_album
-        is the same object
+        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 = 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(
+        a_1 = Artist(
             name="artist",
-            main_album_list=[
+            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=[
                 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(artist.id == artist.main_album_collection[0].song_collection[0].main_artist_collection[0].id)
+        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)
 
     def test_artist_collection_sync(self):
+        """
+        tests the actual implementation of the test above
+        """
+
         album_1 = Album(
             title="album",
             song_list=[
-                Song(title="song", main_artist_list=[Artist(name="artist")]),
+                Song(title="song", artist_list=[Artist(name="artist")]),
             ],
             artist_list=[
                 Artist(name="artist"),
@@ -102,7 +104,7 @@ class TestCollection(unittest.TestCase):
         album_2 = Album(
             title="album",
             song_list=[
-                Song(title="song", main_artist_list=[Artist(name="artist")]),
+                Song(title="song", artist_list=[Artist(name="artist")]),
             ],
             artist_list=[
                 Artist(name="artist"),
@@ -111,17 +113,7 @@ 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].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)
+        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))
 
 if __name__ == "__main__":
     unittest.main()