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

472 lines
14 KiB
Python
Raw Normal View History

2022-12-06 13:45:18 +00:00
import os
from typing import List
2023-01-13 13:37:15 +00:00
import pycountry
import copy
2022-12-06 13:45:18 +00:00
2023-01-12 22:01:19 +00:00
from .metadata import (
Mapping as id3Mapping,
2023-01-30 13:41:02 +00:00
ID3Timestamp,
MetadataAttribute
2023-01-12 22:01:19 +00:00
)
2022-12-06 13:45:18 +00:00
from ...utils.shared import (
MUSIC_DIR,
DATABASE_LOGGER as logger
)
2023-01-12 15:25:50 +00:00
from .parents import (
2022-12-06 13:45:18 +00:00
DatabaseObject,
2023-01-12 15:25:50 +00:00
Reference,
SongAttribute
2022-12-06 13:45:18 +00:00
)
2023-01-20 22:05:15 +00:00
from .source import (
Source,
SourceTypes,
2023-01-27 11:56:59 +00:00
SourcePages,
SourceAttribute
2023-01-20 22:05:15 +00:00
)
2023-02-06 08:16:28 +00:00
from .formatted_text import FormattedText
2022-12-06 13:45:18 +00:00
2022-12-07 14:51:38 +00:00
"""
All Objects dependent
"""
2022-12-08 08:28:28 +00:00
2022-12-06 22:44:42 +00:00
class Target(DatabaseObject, SongAttribute):
2022-12-06 13:45:18 +00:00
"""
create somehow like that
```python
2022-12-06 22:44:42 +00:00
# I know path is pointless, and I will change that (don't worry about backwards compatibility there)
2022-12-06 13:45:18 +00:00
Target(file="~/Music/genre/artist/album/song.mp3", path="~/Music/genre/artist/album")
```
"""
2022-12-06 22:44:42 +00:00
def __init__(self, id_: str = None, file: str = None, path: str = None) -> None:
DatabaseObject.__init__(self, id_=id_)
SongAttribute.__init__(self)
2022-12-06 13:45:18 +00:00
self._file = file
self._path = path
def set_file(self, _file: str):
self._file = _file
def get_file(self) -> str | None:
if self._file is None:
return None
return os.path.join(MUSIC_DIR, self._file)
def set_path(self, _path: str):
self._path = _path
def get_path(self) -> str | None:
if self._path is None:
return None
return os.path.join(MUSIC_DIR, self._path)
def get_exists_on_disc(self) -> bool:
"""
returns True when file can be found on disc
returns False when file can't be found on disc or no filepath is set
"""
if not self.is_set():
return False
return os.path.exists(self.file)
2022-12-06 22:44:42 +00:00
2022-12-06 13:45:18 +00:00
def is_set(self) -> bool:
return not (self._file is None or self._path is None)
file = property(fget=get_file, fset=set_file)
path = property(fget=get_path, fset=set_path)
exists_on_disc = property(fget=get_exists_on_disc)
2023-01-30 13:41:02 +00:00
class Lyrics(DatabaseObject, SongAttribute, SourceAttribute, MetadataAttribute):
2023-01-27 11:56:59 +00:00
def __init__(
self,
text: str,
language: str,
2023-01-27 11:56:59 +00:00
id_: str = None,
source_list: List[Source] = None
) -> None:
2022-12-06 22:44:42 +00:00
DatabaseObject.__init__(self, id_=id_)
SongAttribute.__init__(self)
2022-12-06 13:45:18 +00:00
self.text = text
self.language = language
2023-01-27 11:56:59 +00:00
if source_list is not None:
self.source_list = source_list
2022-12-06 13:45:18 +00:00
2023-01-30 13:41:02 +00:00
def get_metadata(self) -> MetadataAttribute.Metadata:
return super().get_metadata()
2023-01-27 11:56:59 +00:00
2023-01-30 13:41:02 +00:00
class Song(DatabaseObject, SourceAttribute, MetadataAttribute):
2022-12-06 13:45:18 +00:00
def __init__(
2022-12-06 22:44:42 +00:00
self,
id_: str = None,
mb_id: str = None,
title: str = None,
2022-12-07 14:51:38 +00:00
album_name: 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,
2022-12-06 22:44:42 +00:00
target: Target = None,
lyrics: List[Lyrics] = None,
2022-12-16 15:59:21 +00:00
album=None,
2023-01-16 13:23:33 +00:00
main_artist_list: list = None,
feature_artist_list: list = None
2022-12-06 22:44:42 +00:00
) -> None:
2022-12-06 13:45:18 +00:00
"""
id: is not NECESARRILY the musicbrainz id, but is DISTINCT for every song
mb_id: is the musicbrainz_id
target: Each Song can have exactly one target which can be either full or empty
lyrics: There can be multiple lyrics. Each Lyrics object can me added to multiple lyrics
"""
super().__init__(id_=id_)
# attributes
2023-01-10 18:21:11 +00:00
# *private* attributes
2023-01-16 13:23:33 +00:00
self.title: str = title
self.isrc: str = isrc
self.length: int = length
2022-12-06 13:45:18 +00:00
self.mb_id: str | None = mb_id
2022-12-07 14:51:38 +00:00
self.album_name: str | None = album_name
2022-12-09 17:24:58 +00:00
self.tracksort: int | None = tracksort
2023-01-16 13:31:43 +00:00
self.genre: str = genre
2023-01-27 11:56:59 +00:00
if source_list:
self.source_list = source_list
2022-12-06 13:45:18 +00:00
2023-01-16 13:23:33 +00:00
self.target = Target()
if target is not None:
self.target = target
2022-12-13 10:16:19 +00:00
self.target.add_song(self)
2022-12-06 13:45:18 +00:00
2023-01-16 13:23:33 +00:00
self.lyrics = []
if lyrics is not None:
self.lyrics = lyrics
2022-12-06 13:45:18 +00:00
2023-01-30 16:07:26 +00:00
self._album = None
2023-01-12 23:32:35 +00:00
self.album = album
2022-12-06 13:45:18 +00:00
2023-01-16 13:23:33 +00:00
self.main_artist_list = []
if main_artist_list is not None:
self.main_artist_list = main_artist_list
self.feature_artist_list = []
if feature_artist_list is not None:
self.feature_artist_list = feature_artist_list
2022-12-09 14:50:44 +00:00
2022-12-08 08:28:28 +00:00
def __eq__(self, other):
if type(other) != type(self):
return False
return self.id == other.id
2022-12-13 10:16:19 +00:00
def get_artist_credits(self) -> str:
feature_str = ""
if len(self.feature_artist_list) > 0:
feature_str = " feat. " + ", ".join([artist.name for artist in self.feature_artist_list])
return ", ".join([artist.name for artist in self.main_artist_list]) + feature_str
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:
return self.__str__()
def has_isrc(self) -> bool:
2023-01-16 13:23:33 +00:00
return self.isrc is not None
2022-12-06 22:44:42 +00:00
2022-12-13 10:16:19 +00:00
def get_album_id(self):
if self.album is None:
2022-12-07 14:51:38 +00:00
return None
2022-12-13 10:16:19 +00:00
return self.album.id
2022-12-09 17:24:58 +00:00
2023-01-30 14:12:30 +00:00
def get_tracksort_str(self):
if self.tracksort is None:
return None
if self.album is None:
return str(self.tracksort)
return f"{self.tracksort}/{len(self.album.tracklist)}"
2023-01-30 13:41:02 +00:00
def get_metadata(self) -> MetadataAttribute.Metadata:
metadata = MetadataAttribute.Metadata({
id3Mapping.TITLE: [self.title],
id3Mapping.ISRC: [self.isrc],
2023-01-30 22:54:21 +00:00
id3Mapping.LENGTH: [self.length],
id3Mapping.GENRE: [self.genre],
id3Mapping.TRACKNUMBER: [self.tracksort_str]
2023-01-30 13:41:02 +00:00
})
2023-01-16 13:23:33 +00:00
2023-01-30 13:41:02 +00:00
metadata.merge_many([s.get_song_metadata() for s in self.source_list])
2023-01-16 13:23:33 +00:00
if self.album is not None:
2023-01-30 13:41:02 +00:00
metadata.merge(self.album.metadata)
metadata.merge_many([a.metadata for a in self.main_artist_list])
metadata.merge_many([a.metadata for a in self.feature_artist_list])
metadata.merge_many([l.metadata for l in self.lyrics])
2023-01-16 13:23:33 +00:00
return metadata
2023-01-30 14:12:30 +00:00
2023-01-30 16:07:26 +00:00
def set_album(self, album):
if album is None:
return
2023-01-30 16:07:26 +00:00
self._album = album
if self not in self._album.tracklist:
flat_copy = copy.copy(self)
flat_copy.dynamic = True
self._album.tracklist.append(flat_copy)
2023-01-30 16:07:26 +00:00
2023-01-30 14:12:30 +00:00
tracksort_str = property(fget=get_tracksort_str)
2023-01-30 16:07:26 +00:00
album = property(fget=lambda self: self._album, fset=set_album)
2023-01-11 01:25:17 +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-01-30 13:41:02 +00:00
class Album(DatabaseObject, SourceAttribute, MetadataAttribute):
2022-12-07 14:51:38 +00:00
"""
-------DB-FIELDS-------
title TEXT,
copyright TEXT,
album_status TEXT,
language TEXT,
year TEXT,
date TEXT,
country TEXT,
barcode TEXT,
song_id BIGINT,
2022-12-12 18:30:18 +00:00
is_split BOOLEAN NOT NULL DEFAULT 0
2022-12-07 14:51:38 +00:00
"""
2022-12-08 08:28:28 +00:00
2022-12-07 14:51:38 +00:00
def __init__(
2022-12-08 08:28:28 +00:00
self,
id_: str = None,
title: str = None,
2023-01-13 13:37:15 +00:00
label: str = None,
2022-12-08 08:28:28 +00:00
album_status: 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
country: str = None,
barcode: str = None,
2022-12-12 18:30:18 +00:00
is_split: bool = False,
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-01-24 13:29:23 +00:00
artists: list = None
2022-12-07 14:51:38 +00:00
) -> None:
2022-12-12 18:30:18 +00:00
DatabaseObject.__init__(self, id_=id_, dynamic=dynamic)
2022-12-07 14:51:38 +00:00
self.title: str = title
self.album_status: str = album_status
2023-01-13 13:37:15 +00:00
self.label = label
self.language: pycountry.Languages = language
2023-01-14 13:41:40 +00:00
self.date: ID3Timestamp = date
if date is None:
self.date = ID3Timestamp()
2022-12-07 14:51:38 +00:00
self.country: str = country
2023-01-13 11:05:44 +00:00
"""
TODO
find out the id3 tag for barcode and implement it
2023-01-14 13:41:40 +00:00
maybee 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
2022-12-12 18:30:18 +00:00
self.is_split: bool = is_split
self.albumsort: int | None = albumsort
2022-12-07 14:51:38 +00:00
2023-01-30 14:12:30 +00:00
self._tracklist: List[Song] = list()
2022-12-07 14:51:38 +00:00
2023-01-27 11:56:59 +00:00
if source_list is not None:
self.source_list = source_list
2023-01-23 12:49:07 +00:00
2023-01-24 13:29:23 +00:00
self.artists = []
if artists is not None:
self.artists = artists
2022-12-09 17:24:58 +00:00
def __str__(self) -> str:
return f"Album: \"{self.title}\""
2022-12-16 17:26:05 +00:00
def __repr__(self):
return self.__str__()
2022-12-09 17:24:58 +00:00
def __len__(self) -> int:
return len(self.tracklist)
2022-12-08 08:28:28 +00:00
def set_tracklist(self, tracklist: List[Song]):
2023-01-30 14:12:30 +00:00
self._tracklist = tracklist
2022-12-07 14:51:38 +00:00
2023-01-30 14:12:30 +00:00
for i, track in enumerate(self._tracklist):
2022-12-12 18:30:18 +00:00
track.tracksort = i + 1
2022-12-09 17:24:58 +00:00
2022-12-08 08:28:28 +00:00
def add_song(self, song: Song):
2023-01-30 14:12:30 +00:00
for existing_song in self._tracklist:
2022-12-08 08:28:28 +00:00
if existing_song == song:
return
2022-12-09 17:24:58 +00:00
song.tracksort = len(self.tracklist)
2022-12-08 08:28:28 +00:00
self.tracklist.append(song)
2022-12-12 18:30:18 +00:00
2023-01-30 13:41:02 +00:00
def get_metadata(self) -> MetadataAttribute.Metadata:
return MetadataAttribute.Metadata({
id3Mapping.ALBUM: [self.title],
id3Mapping.COPYRIGHT: [self.copyright],
id3Mapping.LANGUAGE: [self.iso_639_2_language],
id3Mapping.ALBUM_ARTIST: [a.name for a in self.artists],
id3Mapping.DATE: [self.date.timestamp]
2023-01-30 13:41:02 +00:00
})
2023-01-13 11:05:44 +00:00
2023-01-13 13:37:15 +00:00
def get_copyright(self) -> str:
2023-01-30 22:54:21 +00:00
if self.date is None:
return None
2023-01-13 13:37:15 +00:00
if self.date.year == 1 or self.label is None:
return None
return f"{self.date.year} {self.label}"
def get_iso_639_2_lang(self) -> str:
if self.language is None:
return None
return self.language.alpha_3
copyright = property(fget=get_copyright)
iso_639_2_language = property(fget=get_iso_639_2_lang)
2023-01-30 14:12:30 +00:00
tracklist = property(fget=lambda self: self._tracklist, fset=set_tracklist)
2023-01-13 13:37:15 +00:00
2023-01-13 11:05:44 +00:00
2022-12-12 18:30:18 +00:00
"""
All objects dependent on Artist
"""
2023-01-30 13:41:02 +00:00
class Artist(DatabaseObject, SourceAttribute, MetadataAttribute):
2022-12-16 15:59:21 +00:00
"""
main_songs
feature_song
albums
"""
2022-12-12 18:30:18 +00:00
def __init__(
self,
id_: str = None,
name: str = None,
2023-01-27 11:56:59 +00:00
source_list: List[Source] = None,
2022-12-16 15:59:21 +00:00
main_songs: List[Song] = None,
feature_songs: List[Song] = None,
2023-01-24 08:40:01 +00:00
main_albums: List[Album] = None,
album_type: str = 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 = "",
country=None,
2023-02-01 13:26:54 +00:00
formed_in: ID3Timestamp = None
2022-12-12 18:30:18 +00:00
):
DatabaseObject.__init__(self, id_=id_)
"""
TODO implement album type and notes
"""
self.album_type = album_type
2023-02-01 13:26:54 +00:00
self.country: pycountry.Country = country
self.formed_in: ID3Timestamp = formed_in
2023-02-01 13:26:54 +00:00
"""
notes, generall genre, lyrics themes are attributes
which are meant to only use in outputs to describe the object
i mean do as you want but there aint no strict rule about em so good luck
"""
2023-02-06 08:16:28 +00:00
self.notes: FormattedText = notes
if self.notes is None:
self.notes = FormattedText()
2023-02-01 13:26:54 +00:00
self.lyrical_themes: List[str] = lyrical_themes
if self.lyrical_themes is None:
self.lyrical_themes = []
self.general_genre = general_genre
2023-01-24 08:40:01 +00:00
2022-12-16 15:59:21 +00:00
if main_albums is None:
main_albums = []
if feature_songs is None:
feature_songs = []
if main_songs is None:
main_songs = []
2022-12-16 11:53:05 +00:00
2022-12-16 15:59:21 +00:00
self.name: str | None = name
2022-12-16 11:53:05 +00:00
2022-12-16 15:59:21 +00:00
self.main_songs = main_songs
self.feature_songs = feature_songs
2022-12-12 18:30:18 +00:00
2022-12-16 15:59:21 +00:00
self.main_albums = main_albums
2022-12-12 18:30:18 +00:00
2023-01-27 11:56:59 +00:00
if source_list is not None:
self.source_list = source_list
2023-01-20 10:43:35 +00:00
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):
return self.__str__()
2022-12-12 18:30:18 +00:00
def __eq__(self, __o: object) -> bool:
return self.id_ == __o.id_
2022-12-16 15:59:21 +00:00
def get_features(self) -> Album:
2022-12-12 18:30:18 +00:00
feature_release = Album(
title="features",
2022-12-16 15:59:21 +00:00
album_status="dynamic",
2022-12-12 18:30:18 +00:00
is_split=True,
albumsort=666,
dynamic=True
)
2022-12-16 15:59:21 +00:00
for feature in self.feature_songs:
feature_release.add_song(feature)
2022-12-12 18:30:18 +00:00
2022-12-16 15:59:21 +00:00
return feature_release
2022-12-12 18:30:18 +00:00
2022-12-16 15:59:21 +00:00
def get_songs(self) -> Album:
song_release = Album(
title="song collection",
album_status="dynamic",
is_split=False,
albumsort=666,
dynamic=True
)
for song in self.main_songs:
song_release.add_song(song)
for song in self.feature_songs:
song_release.add_song(song)
return song_release
2022-12-12 18:30:18 +00:00
2022-12-16 15:59:21 +00:00
def get_discography(self) -> List[Album]:
2022-12-16 17:26:05 +00:00
flat_copy_discography = self.main_albums.copy()
2022-12-16 15:59:21 +00:00
flat_copy_discography.append(self.get_features())
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-01-30 13:41:02 +00:00
def get_metadata(self) -> MetadataAttribute.Metadata:
2023-01-20 22:05:15 +00:00
"""
TODO refactor
:return:
"""
2023-01-30 13:41:02 +00:00
metadata = MetadataAttribute.Metadata({
id3Mapping.ARTIST: [self.name]
2023-01-30 13:41:02 +00:00
})
metadata.merge_many([s.get_artist_metadata() for s in self.source_list])
2023-01-20 10:43:35 +00:00
2023-01-30 13:41:02 +00:00
return metadata
2023-01-16 13:23:33 +00:00
2022-12-16 15:59:21 +00:00
discography: List[Album] = property(fget=get_discography)
features: Album = property(fget=get_features)
songs: Album = property(fget=get_songs)