music-kraken-core/src/music_kraken/objects/song.py

701 lines
24 KiB
Python
Raw Normal View History

2023-04-16 12:36:33 +00:00
import random
2023-04-16 15:39:53 +00:00
from collections import defaultdict
2023-03-10 20:33:26 +00:00
from typing import List, Optional, Dict, Tuple
2023-04-04 20:10:35 +00:00
2023-01-13 13:37:15 +00:00
import pycountry
2022-12-06 13:45:18 +00:00
2023-04-04 20:10:35 +00:00
from .album import AlbumType, AlbumStatus
from .collection import Collection
from .formatted_text import FormattedText
from .lyrics import Lyrics
2023-01-12 22:01:19 +00:00
from .metadata import (
Mapping as id3Mapping,
2023-01-30 13:41:02 +00:00
ID3Timestamp,
2023-03-10 08:09:35 +00:00
Metadata
2023-01-12 22:01:19 +00:00
)
2023-03-10 20:28:13 +00:00
from .option import Options
2023-04-04 20:10:35 +00:00
from .parents import MainObject
from .source import Source, SourceCollection
from .target import Target
from ..utils.string_processing import unify
2023-04-16 15:39:53 +00:00
from ..utils.shared import SORT_BY_ALBUM_TYPE, SORT_BY_DATE
2022-12-06 13:45:18 +00:00
2022-12-07 14:51:38 +00:00
"""
All Objects dependent
"""
2023-02-22 16:56:52 +00:00
CountryTyping = type(list(pycountry.countries)[0])
2023-03-10 09:54:15 +00:00
OPTION_STRING_DELIMITER = " | "
2023-02-22 16:56:52 +00:00
2022-12-08 08:28:28 +00:00
2023-03-10 08:09:35 +00:00
class Song(MainObject):
2023-02-13 22:05:16 +00:00
"""
Class representing a song object, with attributes id, mb_id, title, album_name, isrc, length,
tracksort, genre, source_list, target, lyrics_list, album, main_artist_list, and feature_artist_list.
"""
2023-03-10 09:54:15 +00:00
COLLECTION_ATTRIBUTES = (
"lyrics_collection", "album_collection", "main_artist_collection", "feature_artist_collection",
"source_collection")
SIMPLE_ATTRIBUTES = {
"title": None,
"unified_title": None,
"isrc": None,
2023-03-20 22:11:55 +00:00
"length": None,
"tracksort": 0,
"genre": None,
"notes": FormattedText()
}
2022-12-06 13:45:18 +00:00
def __init__(
2022-12-06 22:44:42 +00:00
self,
2023-04-12 10:15:12 +00:00
_id: int = None,
2023-02-25 21:16:32 +00:00
dynamic: bool = False,
2022-12-06 22:44:42 +00:00
title: str = None,
unified_title: str = None,
2022-12-06 22:44:42 +00:00
isrc: str = None,
length: int = None,
2022-12-09 17:24:58 +00:00
tracksort: int = None,
2023-01-16 13:31:43 +00:00
genre: str = None,
2023-01-27 11:56:59 +00:00
source_list: List[Source] = None,
2023-02-25 21:16:32 +00:00
target_list: List[Target] = None,
2023-02-10 12:52:18 +00:00
lyrics_list: List[Lyrics] = None,
2023-03-10 20:33:26 +00:00
album_list: List['Album'] = None,
main_artist_list: List['Artist'] = None,
feature_artist_list: List['Artist'] = None,
notes: FormattedText = None,
2023-02-10 12:52:18 +00:00
**kwargs
2022-12-06 22:44:42 +00:00
) -> None:
2023-02-25 21:16:32 +00:00
MainObject.__init__(self, _id=_id, dynamic=dynamic, **kwargs)
2022-12-06 13:45:18 +00:00
# attributes
2023-01-16 13:23:33 +00:00
self.title: str = title
self.unified_title: str = unified_title
if unified_title is None and title is not None:
self.unified_title = unify(title)
2023-01-16 13:23:33 +00:00
self.isrc: str = isrc
self.length: int = length
2023-02-10 12:52:18 +00:00
self.tracksort: int = tracksort or 0
2023-01-16 13:31:43 +00:00
self.genre: str = genre
self.notes: FormattedText = notes or FormattedText()
2023-03-09 21:14:39 +00:00
self.source_collection: SourceCollection = SourceCollection(source_list)
self.target_collection: Collection = Collection(data=target_list, element_type=Target)
self.lyrics_collection: Collection = Collection(data=lyrics_list, element_type=Lyrics)
self.album_collection: Collection = Collection(data=album_list, element_type=Album)
self.main_artist_collection = Collection(data=main_artist_list, element_type=Artist)
self.feature_artist_collection = Collection(data=feature_artist_list, element_type=Artist)
2022-12-09 14:50:44 +00:00
def _build_recursive_structures(self, build_version: int, merge: bool):
if build_version == self.build_version:
return
self.build_version = build_version
2023-04-12 10:00:29 +00:00
2023-03-14 10:03:54 +00:00
album: Album
for album in self.album_collection:
album.song_collection.append(self, merge_on_conflict=merge, merge_into_existing=False)
album._build_recursive_structures(build_version=build_version, merge=merge)
2023-03-20 22:11:55 +00:00
2023-03-14 10:03:54 +00:00
artist: Artist
for artist in self.feature_artist_collection:
artist.feature_song_collection.append(self, merge_on_conflict=merge, merge_into_existing=False)
artist._build_recursive_structures(build_version=build_version, merge=merge)
2023-03-20 22:11:55 +00:00
2023-03-14 10:03:54 +00:00
for artist in self.main_artist_collection:
2023-03-22 11:58:11 +00:00
for album in self.album_collection:
2023-03-28 09:34:45 +00:00
artist.main_album_collection.append(album, merge_on_conflict=merge, merge_into_existing=False)
artist._build_recursive_structures(build_version=build_version, merge=merge)
2023-03-14 10:03:54 +00:00
2023-03-10 08:09:35 +00:00
@property
def indexing_values(self) -> List[Tuple[str, object]]:
return [
('id', self.id),
('title', self.unified_title),
2023-03-10 17:38:32 +00:00
('isrc', self.isrc),
2023-03-10 09:21:57 +00:00
*[('url', source.url) for source in self.source_collection]
2023-03-10 08:09:35 +00:00
]
2023-03-10 09:54:15 +00:00
2023-03-10 08:09:35 +00:00
@property
def metadata(self) -> Metadata:
metadata = Metadata({
id3Mapping.TITLE: [self.title],
id3Mapping.ISRC: [self.isrc],
id3Mapping.LENGTH: [self.length],
id3Mapping.GENRE: [self.genre],
id3Mapping.TRACKNUMBER: [self.tracksort_str]
})
2023-03-24 09:30:40 +00:00
metadata.merge_many([s.metadata for s in self.source_collection])
2023-03-10 08:09:35 +00:00
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.feature_artist_collection])
metadata.merge_many([lyrics.metadata for lyrics in self.lyrics_collection])
return metadata
2022-12-13 10:16:19 +00:00
def get_artist_credits(self) -> str:
2023-02-10 12:52:18 +00:00
main_artists = ", ".join([artist.name for artist in self.main_artist_collection])
feature_artists = ", ".join([artist.name for artist in self.feature_artist_collection])
2023-02-22 16:56:52 +00:00
2023-02-10 12:52:18 +00:00
if len(feature_artists) == 0:
return main_artists
return f"{main_artists} feat. {feature_artists}"
2022-12-13 10:16:19 +00:00
2022-12-06 13:45:18 +00:00
def __str__(self) -> str:
2022-12-13 10:16:19 +00:00
artist_credit_str = ""
artist_credits = self.get_artist_credits()
if artist_credits != "":
artist_credit_str = f" by {artist_credits}"
return f"\"{self.title}\"{artist_credit_str}"
2022-12-06 13:45:18 +00:00
def __repr__(self) -> str:
2023-02-10 12:52:18 +00:00
return f"Song(\"{self.title}\")"
2022-12-09 17:24:58 +00:00
2023-03-10 09:54:15 +00:00
@property
def option_string(self) -> str:
return f"{self.__repr__()} " \
f"from Album({OPTION_STRING_DELIMITER.join(album.title for album in self.album_collection)}) " \
f"by Artist({OPTION_STRING_DELIMITER.join(artist.name for artist in self.main_artist_collection)}) " \
f"feat. Artist({OPTION_STRING_DELIMITER.join(artist.name for artist in self.feature_artist_collection)})"
2023-03-10 08:09:35 +00:00
@property
2023-03-10 20:28:13 +00:00
def options(self) -> Options:
2023-02-13 22:05:16 +00:00
"""
2023-03-10 20:33:26 +00:00
Return a list of related objects including the song object, album object, main artist objects, and
feature artist objects.
2023-02-13 22:05:16 +00:00
:return: a list of objects that are related to the Song object
"""
2023-03-10 09:54:15 +00:00
options = self.main_artist_collection.shallow_list
2023-02-23 22:52:41 +00:00
options.extend(self.feature_artist_collection)
options.extend(self.album_collection)
2023-02-09 08:40:57 +00:00
options.append(self)
2023-03-10 20:28:13 +00:00
return Options(options)
@property
def tracksort_str(self) -> str:
"""
2023-03-10 20:33:26 +00:00
if the album tracklist is empty, it sets it length to 1, this song has to be on the Album
2023-03-10 20:28:13 +00:00
:returns id3_tracksort: {song_position}/{album.length_of_tracklist}
"""
2023-03-24 09:30:40 +00:00
if len(self.album_collection) == 0:
return f"{self.tracksort}"
2023-04-12 10:00:29 +00:00
2023-03-31 08:46:56 +00:00
return f"{self.tracksort}/{len(self.album_collection[0].song_collection) or 1}"
2023-02-09 08:40:57 +00:00
2022-12-06 13:45:18 +00:00
2022-12-07 14:51:38 +00:00
"""
2022-12-09 17:24:58 +00:00
All objects dependent on Album
2022-12-07 14:51:38 +00:00
"""
2022-12-08 08:28:28 +00:00
2023-03-10 08:09:35 +00:00
class Album(MainObject):
2023-03-09 21:14:39 +00:00
COLLECTION_ATTRIBUTES = ("label_collection", "artist_collection", "song_collection")
SIMPLE_ATTRIBUTES = {
"title": None,
"unified_title": None,
"album_status": None,
"album_type": AlbumType.OTHER,
"language": None,
"date": ID3Timestamp(),
"barcode": None,
"albumsort": None,
"notes": FormattedText()
}
2023-03-09 21:14:39 +00:00
2022-12-07 14:51:38 +00:00
def __init__(
2022-12-08 08:28:28 +00:00
self,
2023-04-12 10:15:12 +00:00
_id: int = None,
2022-12-08 08:28:28 +00:00
title: str = None,
unified_title: str = None,
2023-01-13 13:37:15 +00:00
language: pycountry.Languages = None,
2023-01-14 13:41:40 +00:00
date: ID3Timestamp = None,
2022-12-08 08:28:28 +00:00
barcode: str = None,
2022-12-12 18:30:18 +00:00
albumsort: int = None,
2023-01-23 12:49:07 +00:00
dynamic: bool = False,
2023-01-27 11:56:59 +00:00
source_list: List[Source] = None,
2023-03-10 20:33:26 +00:00
artist_list: List['Artist'] = None,
2023-02-23 22:52:41 +00:00
song_list: List[Song] = None,
2023-02-22 16:56:52 +00:00
album_status: AlbumStatus = None,
album_type: AlbumType = None,
2023-03-10 20:33:26 +00:00
label_list: List['Label'] = None,
notes: FormattedText = None,
2023-02-10 12:52:18 +00:00
**kwargs
2022-12-07 14:51:38 +00:00
) -> None:
2023-02-25 21:16:32 +00:00
MainObject.__init__(self, _id=_id, dynamic=dynamic, **kwargs)
2023-02-08 16:14:51 +00:00
2022-12-07 14:51:38 +00:00
self.title: str = title
self.unified_title: str = unified_title
if unified_title is None and title is not None:
self.unified_title = unify(title)
2023-02-22 16:56:52 +00:00
self.album_status: AlbumStatus = album_status
self.album_type: AlbumType = album_type or AlbumType.OTHER
2023-01-13 13:37:15 +00:00
self.language: pycountry.Languages = language
2023-02-10 12:52:18 +00:00
self.date: ID3Timestamp = date or ID3Timestamp()
2023-02-23 22:52:41 +00:00
2023-01-13 11:05:44 +00:00
"""
TODO
find out the id3 tag for barcode and implement it
2023-02-22 16:56:52 +00:00
maybe look at how mutagen does it with easy_id3
2023-01-13 11:05:44 +00:00
"""
2022-12-07 14:51:38 +00:00
self.barcode: str = barcode
2023-02-10 12:52:18 +00:00
"""
TODO
implement a function in the Artist class,
to set albumsort with help of the release year
"""
2023-02-22 16:56:52 +00:00
self.albumsort: Optional[int] = albumsort
self.notes = notes or FormattedText()
2022-12-07 14:51:38 +00:00
2023-03-09 21:14:39 +00:00
self.source_collection: SourceCollection = SourceCollection(source_list)
self.song_collection: Collection = Collection(data=song_list, element_type=Song)
2023-03-10 07:27:01 +00:00
self.artist_collection: Collection = Collection(data=artist_list, element_type=Artist)
self.label_collection: Collection = Collection(data=label_list, element_type=Label)
2023-02-23 22:52:41 +00:00
def _build_recursive_structures(self, build_version: int, merge: bool):
if build_version == self.build_version:
return
self.build_version = build_version
2023-04-12 10:00:29 +00:00
song: Song
2023-03-14 10:03:54 +00:00
for song in self.song_collection:
song.album_collection.append(self, merge_on_conflict=merge, merge_into_existing=False)
song._build_recursive_structures(build_version=build_version, merge=merge)
2023-04-12 10:00:29 +00:00
2023-03-14 10:03:54 +00:00
artist: Artist
for artist in self.artist_collection:
artist.main_album_collection.append(self, merge_on_conflict=merge, merge_into_existing=False)
artist._build_recursive_structures(build_version=build_version, merge=merge)
2023-04-12 10:00:29 +00:00
2023-03-14 10:03:54 +00:00
label: Label
for label in self.label_collection:
label.album_collection.append(self, merge_on_conflict=merge, merge_into_existing=False)
label._build_recursive_structures(build_version=build_version, merge=merge)
2023-03-14 10:03:54 +00:00
@property
def indexing_values(self) -> List[Tuple[str, object]]:
return [
('id', self.id),
('title', self.unified_title),
('barcode', self.barcode),
2023-03-10 09:21:57 +00:00
*[('url', source.url) for source in self.source_collection]
]
2023-03-10 09:54:15 +00:00
2023-03-10 08:09:35 +00:00
@property
def metadata(self) -> Metadata:
return Metadata({
id3Mapping.ALBUM: [self.title],
id3Mapping.COPYRIGHT: [self.copyright],
2023-03-31 08:46:56 +00:00
id3Mapping.LANGUAGE: [self.iso_639_2_lang],
2023-03-10 08:09:35 +00:00
id3Mapping.ALBUM_ARTIST: [a.name for a in self.artist_collection],
2023-04-16 12:36:33 +00:00
id3Mapping.DATE: [self.date.timestamp],
id3Mapping.ALBUMSORTORDER: [str(self.albumsort)] if self.albumsort is not None else []
2023-03-10 08:09:35 +00:00
})
2022-12-16 17:26:05 +00:00
def __repr__(self):
2023-02-08 12:29:01 +00:00
return f"Album(\"{self.title}\")"
2022-12-16 17:26:05 +00:00
2023-03-10 09:54:15 +00:00
@property
def option_string(self) -> str:
return f"{self.__repr__()} " \
f"by Artist({OPTION_STRING_DELIMITER.join([artist.name for artist in self.artist_collection])}) " \
f"under Label({OPTION_STRING_DELIMITER.join([label.name for label in self.label_collection])})"
2023-03-10 20:28:13 +00:00
@property
def options(self) -> Options:
options = self.artist_collection.shallow_list
options.append(self)
options.extend(self.song_collection)
return Options(options)
2023-02-23 22:52:41 +00:00
def update_tracksort(self):
"""
This updates the tracksort attributes, of the songs in
`self.song_collection`, and sorts the songs, if possible.
2022-12-09 17:24:58 +00:00
2023-02-23 22:52:41 +00:00
It is advised to only call this function, once all the tracks are
added to the songs.
2022-12-07 14:51:38 +00:00
2023-02-23 22:52:41 +00:00
:return:
"""
2023-04-03 16:09:05 +00:00
if self.song_collection.empty:
return
tracksort_map: Dict[int, Song] = {
song.tracksort: song for song in self.song_collection if song.tracksort is not None
}
2023-02-23 22:52:41 +00:00
# place the songs, with set tracksort attribute according to it
for tracksort, song in tracksort_map.items():
index = tracksort - 1
"""
I ONLY modify the `Collection._data` attribute directly,
to bypass the mapping of the attributes, because I will add the item in the next step
"""
2023-04-03 16:09:05 +00:00
"""
but for some reason, neither
`self.song_collection._data.index(song)`
`self.song_collection._data.remove(song)`
get the right object.
I have NO FUCKING CLUE why xD
But I just implemented it myself.
"""
for old_index, temp_song in enumerate(self.song_collection._data):
if song is temp_song:
break
# the list can't be empty
del self.song_collection._data[old_index]
2023-02-23 22:52:41 +00:00
self.song_collection._data.insert(index, song)
# fill in the empty tracksort attributes
for i, song in enumerate(self.song_collection):
if song.tracksort is not None:
continue
song.tracksort = i + 1
2022-12-12 18:30:18 +00:00
2023-04-16 12:36:33 +00:00
def compile(self, merge_into: bool = False):
"""
compiles the recursive structures,
and does depending on the object some other stuff.
no need to override if only the recursive structure should be built.
override self.build_recursive_structures() instead
"""
self.update_tracksort()
self._build_recursive_structures(build_version=random.randint(0, 99999), merge=merge_into)
2023-03-10 08:09:35 +00:00
@property
def copyright(self) -> str:
2023-01-30 22:54:21 +00:00
if self.date is None:
2023-02-22 16:56:52 +00:00
return ""
2023-02-23 22:52:41 +00:00
if self.date.has_year or len(self.label_collection) == 0:
2023-02-22 16:56:52 +00:00
return ""
2023-01-13 13:37:15 +00:00
2023-02-23 22:52:41 +00:00
return f"{self.date.year} {self.label_collection[0].name}"
2023-01-13 13:37:15 +00:00
2023-02-27 15:51:55 +00:00
@property
def iso_639_2_lang(self) -> Optional[str]:
2023-01-13 13:37:15 +00:00
if self.language is None:
return None
return self.language.alpha_3
2023-02-28 00:13:53 +00:00
@property
def is_split(self) -> bool:
"""
A split Album is an Album from more than one Artists
usually half the songs are made by one Artist, the other half by the other one.
In this case split means either that or one artist featured by all songs.
:return:
"""
return len(self.artist_collection) > 1
2023-03-10 09:54:15 +00:00
2022-12-12 18:30:18 +00:00
"""
All objects dependent on Artist
"""
2023-03-10 08:09:35 +00:00
class Artist(MainObject):
2023-03-20 22:11:55 +00:00
COLLECTION_ATTRIBUTES = (
2023-04-12 10:00:29 +00:00
"feature_song_collection",
"main_album_collection",
"label_collection",
"source_collection"
)
SIMPLE_ATTRIBUTES = {
"name": None,
"unified_name": None,
"country": None,
"formed_in": ID3Timestamp(),
"notes": FormattedText(),
"lyrical_themes": [],
"general_genre": ""
}
2023-03-10 09:54:15 +00:00
2022-12-12 18:30:18 +00:00
def __init__(
self,
2023-04-12 10:15:12 +00:00
_id: int = None,
2023-02-25 21:16:32 +00:00
dynamic: bool = False,
2022-12-12 18:30:18 +00:00
name: str = None,
unified_name: str = None,
2023-01-27 11:56:59 +00:00
source_list: List[Source] = None,
2023-02-23 22:52:41 +00:00
feature_song_list: List[Song] = None,
main_album_list: List[Album] = None,
2023-02-06 08:16:28 +00:00
notes: FormattedText = None,
2023-02-01 13:26:54 +00:00
lyrical_themes: List[str] = None,
general_genre: str = "",
2023-02-22 16:56:52 +00:00
country: CountryTyping = None,
2023-02-23 22:52:41 +00:00
formed_in: ID3Timestamp = None,
2023-03-10 20:33:26 +00:00
label_list: List['Label'] = None,
2023-02-25 21:16:32 +00:00
**kwargs
2022-12-12 18:30:18 +00:00
):
2023-02-25 21:16:32 +00:00
MainObject.__init__(self, _id=_id, dynamic=dynamic, **kwargs)
self.name: str = name
self.unified_name: str = unified_name
if unified_name is None and name is not None:
self.unified_name = unify(name)
2022-12-12 18:30:18 +00:00
"""
TODO implement album type and notes
"""
2023-02-22 16:56:52 +00:00
self.country: CountryTyping = country
self.formed_in: ID3Timestamp = formed_in
2023-02-01 13:26:54 +00:00
"""
2023-03-10 20:33:49 +00:00
notes, general genre, lyrics themes are attributes
2023-02-01 13:26:54 +00:00
which are meant to only use in outputs to describe the object
i mean do as you want but there is no strict rule about em so good luck
2023-02-01 13:26:54 +00:00
"""
2023-02-09 14:49:22 +00:00
self.notes: FormattedText = notes or FormattedText()
2023-02-25 21:16:32 +00:00
"""
TODO
implement in db
"""
2023-02-09 14:49:22 +00:00
self.lyrical_themes: List[str] = lyrical_themes or []
2023-02-01 13:26:54 +00:00
self.general_genre = general_genre
2023-01-24 08:40:01 +00:00
2023-03-10 09:54:15 +00:00
self.source_collection: SourceCollection = SourceCollection(source_list)
2023-03-10 07:27:01 +00:00
self.feature_song_collection: Collection = Collection(data=feature_song_list, element_type=Song)
self.main_album_collection: Collection = Collection(data=main_album_list, element_type=Album)
self.label_collection: Collection = Collection(data=label_list, element_type=Label)
2023-01-20 10:43:35 +00:00
2023-04-16 12:36:33 +00:00
def compile(self, merge_into: bool = False):
"""
compiles the recursive structures,
and does depending on the object some other stuff.
no need to override if only the recursive structure should be built.
override self.build_recursive_structures() instead
"""
self.update_albumsort()
self._build_recursive_structures(build_version=random.randint(0, 99999), merge=merge_into)
def update_albumsort(self):
"""
This updates the albumsort attributes, of the albums in
`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
2023-04-16 15:39:53 +00:00
type_section: Dict[AlbumType] = defaultdict(lambda: 2, {
AlbumType.OTHER: 0, # if I don't know it, I add it to the first section
AlbumType.STUDIO_ALBUM: 0,
AlbumType.EP: 0,
AlbumType.SINGLE: 1
}) if SORT_BY_ALBUM_TYPE else defaultdict(lambda: 0)
sections = defaultdict(list)
# order albums in the previously defined section
album: Album
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:
# album is just a value used in loops
nonlocal album
if SORT_BY_DATE:
_section.sort(key=lambda _album: _album.date, reverse=True)
new_last_albumsort = last_albumsort
for album_index, album in enumerate(_section):
if album.albumsort is None:
album.albumsort = new_last_albumsort = album_index + 1 + last_albumsort
_section.sort(key=lambda _album: _album.albumsort)
return new_last_albumsort
# sort the sections individually
_last_albumsort = 1
for section_index in sorted(sections):
_last_albumsort = sort_section(sections[section_index], _last_albumsort)
# merge all sections again
album_list = []
for section_index in sorted(sections):
album_list.extend(sections[section_index])
# replace the old collection with the new one
self.main_album_collection: Collection = Collection(data=album_list, element_type=Album)
2023-04-16 12:36:33 +00:00
def _build_recursive_structures(self, build_version: int, merge: False):
if build_version == self.build_version:
return
self.build_version = build_version
2023-04-12 10:00:29 +00:00
song: Song
2023-03-14 10:03:54 +00:00
for song in self.feature_song_collection:
song.feature_artist_collection.append(self, merge_on_conflict=merge, merge_into_existing=False)
song._build_recursive_structures(build_version=build_version, merge=merge)
2023-04-12 10:00:29 +00:00
album: Album
2023-03-14 10:03:54 +00:00
for album in self.main_album_collection:
album.artist_collection.append(self, merge_on_conflict=merge, merge_into_existing=False)
album._build_recursive_structures(build_version=build_version, merge=merge)
2023-04-12 10:00:29 +00:00
2023-03-14 10:03:54 +00:00
label: Label
for label in self.label_collection:
label.current_artist_collection.append(self, merge_on_conflict=merge, merge_into_existing=False)
label._build_recursive_structures(build_version=build_version, merge=merge)
2023-03-14 10:03:54 +00:00
@property
def indexing_values(self) -> List[Tuple[str, object]]:
return [
('id', self.id),
('name', self.unified_name),
2023-03-10 09:21:57 +00:00
*[('url', source.url) for source in self.source_collection]
]
2023-03-10 09:54:15 +00:00
2023-03-10 08:09:35 +00:00
@property
def metadata(self) -> Metadata:
metadata = Metadata({
id3Mapping.ARTIST: [self.name]
})
2023-03-10 09:21:57 +00:00
metadata.merge_many([s.get_artist_metadata() for s in self.source_collection])
2023-03-10 08:09:35 +00:00
return metadata
2022-12-12 18:30:18 +00:00
def __str__(self):
2023-02-06 08:16:28 +00:00
string = self.name or ""
plaintext_notes = self.notes.get_plaintext()
if plaintext_notes is not None:
string += "\n" + plaintext_notes
return string
2022-12-12 18:30:18 +00:00
2022-12-16 15:59:21 +00:00
def __repr__(self):
2023-02-23 22:52:41 +00:00
return f"Artist(\"{self.name}\")"
2023-03-10 09:54:15 +00:00
@property
def option_string(self) -> str:
return f"{self.__repr__()} " \
f"under Label({OPTION_STRING_DELIMITER.join([label.name for label in self.label_collection])})"
2023-03-10 20:28:13 +00:00
@property
def options(self) -> Options:
options = [self]
options.extend(self.main_album_collection)
options.extend(self.feature_song_collection)
return Options(options)
2023-02-27 15:51:55 +00:00
@property
def country_string(self):
return self.country.alpha_3
2023-03-10 07:27:01 +00:00
@property
def feature_album(self) -> Album:
return Album(
2022-12-12 18:30:18 +00:00
title="features",
2023-02-22 16:56:52 +00:00
album_status=AlbumStatus.UNRELEASED,
album_type=AlbumType.COMPILATION_ALBUM,
2022-12-12 18:30:18 +00:00
is_split=True,
albumsort=666,
2023-02-23 22:52:41 +00:00
dynamic=True,
2023-03-31 08:34:29 +00:00
song_list=self.feature_song_collection.shallow_list
2022-12-12 18:30:18 +00:00
)
2023-02-09 14:49:22 +00:00
def get_all_songs(self) -> List[Song]:
"""
returns a list of all Songs.
2023-02-22 16:56:52 +00:00
probably not that useful, because it is unsorted
2023-02-09 14:49:22 +00:00
"""
2023-02-23 22:52:41 +00:00
collection = self.feature_song_collection.copy()
2023-02-09 14:49:22 +00:00
for album in self.discography:
2023-02-23 22:52:41 +00:00
collection.extend(album.song_collection)
2023-02-09 14:49:22 +00:00
return collection
2022-12-12 18:30:18 +00:00
2023-03-10 07:27:01 +00:00
@property
def discography(self) -> List[Album]:
2023-02-23 22:52:41 +00:00
flat_copy_discography = self.main_album_collection.copy()
2023-03-10 09:21:57 +00:00
flat_copy_discography.append(self.feature_album)
2022-12-12 18:30:18 +00:00
2022-12-16 15:59:21 +00:00
return flat_copy_discography
2022-12-12 18:30:18 +00:00
2023-02-09 08:40:57 +00:00
2023-02-23 22:52:41 +00:00
"""
Label
"""
2023-03-10 09:13:35 +00:00
class Label(MainObject):
2023-03-10 07:27:01 +00:00
COLLECTION_ATTRIBUTES = ("album_collection", "current_artist_collection")
SIMPLE_ATTRIBUTES = {
"name": None,
"unified_name": None,
"notes": FormattedText()
}
2023-03-10 09:54:15 +00:00
2023-02-23 22:52:41 +00:00
def __init__(
self,
2023-04-12 10:15:12 +00:00
_id: int = None,
2023-02-25 21:16:32 +00:00
dynamic: bool = False,
2023-02-23 22:52:41 +00:00
name: str = None,
unified_name: str = None,
notes: FormattedText = None,
2023-02-23 22:52:41 +00:00
album_list: List[Album] = None,
current_artist_list: List[Artist] = None,
source_list: List[Source] = None,
**kwargs
):
2023-02-25 21:16:32 +00:00
MainObject.__init__(self, _id=_id, dynamic=dynamic, **kwargs)
2023-02-23 22:52:41 +00:00
self.name: str = name
self.unified_name: str = unified_name
if unified_name is None and name is not None:
self.unified_name = unify(name)
self.notes = notes or FormattedText()
2023-03-10 09:54:15 +00:00
2023-03-10 07:27:01 +00:00
self.source_collection: SourceCollection = SourceCollection(source_list)
self.album_collection: Collection = Collection(data=album_list, element_type=Album)
self.current_artist_collection: Collection = Collection(data=current_artist_list, element_type=Artist)
2023-02-23 22:52:41 +00:00
def _build_recursive_structures(self, build_version: int, merge: False):
if build_version == self.build_version:
return
self.build_version = build_version
2023-04-12 10:00:29 +00:00
2023-03-14 10:03:54 +00:00
album: Album
for album in self.album_collection:
album.label_collection.append(self, merge_on_conflict=merge, merge_into_existing=False)
album._build_recursive_structures(build_version=build_version, merge=merge)
2023-03-20 22:11:55 +00:00
2023-03-14 10:03:54 +00:00
artist: Artist
2023-04-12 10:00:29 +00:00
for artist in self.current_artist_collection:
artist.label_collection.append(self, merge_on_conflict=merge, merge_into_existing=False)
artist._build_recursive_structures(build_version=build_version, merge=merge)
2023-03-14 10:03:54 +00:00
@property
def indexing_values(self) -> List[Tuple[str, object]]:
return [
('id', self.id),
('name', self.unified_name),
2023-03-10 09:21:57 +00:00
*[('url', source.url) for source in self.source_collection]
]
2023-03-10 20:28:13 +00:00
@property
def options(self) -> Options:
options = [self]
options.extend(self.current_artist_collection.shallow_list)
2023-03-20 22:11:55 +00:00
options.extend(self.album_collection.shallow_list)