TDvorak/swingmusic-extended
1
0
Fork 0
mirror of https://github.com/Dvorinka/swingmusic-extended.git synced 2026-06-04 20:43:04 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

start: rewrite the database layer using a freaking ORM

Browse Source 
+ start ditching in-mem stores
+ move main db table to a new name
+ experiments!
This commit is contained in:
cwilvx
2024-06-24 00:26:47 +03:00
parent c3472a865a
commit c42ec4dcde
27 changed files with 1399 additions and 397 deletions
Download Patch File Download Diff File Expand all files Collapse all files
app/models/album.py
+113 -95
View File
@@ -2,6 +2,7 @@ import dataclasses
import datetime
from dataclasses import dataclass
from app.config import UserConfig
from app.settings import SessionVarKeys, get_flag
from ..utils.hashing import create_hash
@@ -16,94 +17,111 @@ class Album:
Creates an album object
"""
id: int
albumartists: list[dict[str, str]]
albumhash: str
base_title: str
color: str
created_date: int
date: int
duration: int
genres: list[dict[str, str]]
og_title: str
title: str
albumartists: list[Artist]
trackcount: int
albumartists_hashes: str = ""
image: str = ""
count: int = 0
duration: int = 0
colors: list[str] = dataclasses.field(default_factory=list)
date: str = ""
created_date: int = 0
og_title: str = ""
base_title: str = ""
is_soundtrack: bool = False
is_compilation: bool = False
is_single: bool = False
is_EP: bool = False
is_favorite: bool = False
is_live: bool = False
genres: list[str] = dataclasses.field(default_factory=list)
type: str = "album"
versions: list[str] = dataclasses.field(default_factory=list)
def __post_init__(self):
self.title = self.title.strip()
self.og_title = self.title
self.image = self.albumhash + ".webp"
self.date = datetime.datetime.fromtimestamp(self.date).year
# Fetch album artists from title
if get_flag(SessionVarKeys.EXTRACT_FEAT):
featured, self.title = parse_feat_from_title(self.title)
# albumhash: str
# title: str
# albumartists: list[Artist]
if len(featured) > 0:
original_lower = "-".join([a.name.lower() for a in self.albumartists])
self.albumartists.extend(
[Artist(a) for a in featured if a.lower() not in original_lower]
)
# albumartists_hashes: str = ""
# image: str = ""
# count: int = 0
# duration: int = 0
# colors: list[str] = dataclasses.field(default_factory=list)
# date: str = ""
from ..store.tracks import TrackStore
# created_date: int = 0
# og_title: str = ""
# base_title: str = ""
# is_soundtrack: bool = False
# is_compilation: bool = False
# is_single: bool = False
# is_EP: bool = False
# is_favorite: bool = False
# is_live: bool = False
TrackStore.append_track_artists(self.albumhash, featured, self.title)
# genres: list[str] = dataclasses.field(default_factory=list)
# Handle album version data
if get_flag(SessionVarKeys.CLEAN_ALBUM_TITLE):
get_versions = not get_flag(SessionVarKeys.MERGE_ALBUM_VERSIONS)
# def __post_init__(self):
# self.title = self.title.strip()
# self.og_title = self.title
# self.image = self.albumhash + ".webp"
self.title, self.versions = get_base_title_and_versions(
self.title, get_versions=get_versions
)
self.base_title = self.title
# # Fetch album artists from title
# if get_flag(SessionVarKeys.EXTRACT_FEAT):
# featured, self.title = parse_feat_from_title(self.title)
if "super_deluxe" in self.versions:
self.versions.remove("deluxe")
# if len(featured) > 0:
# original_lower = "-".join([a.name.lower() for a in self.albumartists])
# self.albumartists.extend(
# [Artist(a) for a in featured if a.lower() not in original_lower]
# )
if "original" in self.versions and self.check_is_soundtrack():
self.versions.remove("original")
# from ..store.tracks import TrackStore
self.versions = [v.replace("_", " ") for v in self.versions]
else:
self.base_title = get_base_title_and_versions(
self.title, get_versions=False
)[0]
# TrackStore.append_track_artists(self.albumhash, featured, self.title)
self.albumartists_hashes = "-".join(a.artisthash for a in self.albumartists)
# # Handle album version data
# else:
# self.base_title = get_base_title_and_versions(
# self.title, get_versions=False
# )[0]
def set_colors(self, colors: list[str]):
self.colors = colors
# self.albumartists_hashes = "-".join(a.artisthash for a in self.albumartists)
def check_type(self):
# # def set_colors(self, colors: list[str]):
# # self.colors = colors
def populate_versions(self):
_, self.versions = get_base_title_and_versions(self.og_title, get_versions=True)
if "super_deluxe" in self.versions:
self.versions.remove("deluxe")
# at this point, we should know the type of album
if "original" in self.versions and self.type == "soundtrack":
self.versions.remove("original")
self.versions = [v.replace("_", " ") for v in self.versions]
def check_type(self, tracks: list[Track], singleTrackAsSingle: bool):
"""
Runs all the checks to determine the type of album.
"""
self.is_soundtrack = self.check_is_soundtrack()
if self.is_soundtrack:
return
if self.is_single(tracks, singleTrackAsSingle):
return "single"
self.is_live = self.check_is_live_album()
if self.is_live:
return
if self.is_soundtrack():
return "soundtrack"
self.is_compilation = self.check_is_compilation()
if self.is_compilation:
return
if self.is_live_album():
return "live album"
self.is_EP = self.check_is_ep()
if self.is_compilation():
return "compilation"
def check_is_soundtrack(self) -> bool:
if self.is_ep():
return "ep"
return "album"
def is_soundtrack(self) -> bool:
"""
Checks if the album is a soundtrack.
"""
@@ -114,11 +132,11 @@ class Album:
return False
def check_is_compilation(self) -> bool:
def is_compilation(self) -> bool:
"""
Checks if the album is a compilation.
"""
artists = [a.name for a in self.albumartists]
artists = [a["name"] for a in self.albumartists]
artists = "".join(artists).lower()
if "various artists" in artists:
@@ -137,7 +155,7 @@ class Album:
"biggest hits",
"the hits",
"the ultimate",
"compilation"
"compilation",
}
for substring in substrings:
@@ -146,7 +164,7 @@ class Album:
return False
def check_is_live_album(self):
def is_live_album(self):
"""
Checks if the album is a live album.
"""
@@ -157,7 +175,7 @@ class Album:
return False
def check_is_ep(self) -> bool:
def is_ep(self) -> bool:
"""
Checks if the album is an EP.
"""
@@ -165,22 +183,22 @@ class Album:
# TODO: check against number of tracks
def check_is_single(self, tracks: list[Track]):
def is_single(self, tracks: list[Track], singleTrackAsSingle: bool):
"""
Checks if the album is a single.
"""
keywords = ["single version", "- single"]
show_albums_as_singles = get_flag(SessionVarKeys.SHOW_ALBUMS_AS_SINGLES)
# show_albums_as_singles = get_flag(SessionVarKeys.SHOW_ALBUMS_AS_SINGLES)
for keyword in keywords:
if keyword in self.og_title.lower():
self.is_single = True
return
return True
if show_albums_as_singles and len(tracks) == 1:
self.is_single = True
return
# REVIEW: Reading from the config file in a for loop will be slow
# TODO: Find a
if singleTrackAsSingle and len(tracks) == 1:
return True
if (
len(tracks) == 1
@@ -192,29 +210,29 @@ class Album:
# and tracks[0].disc == 1
# TODO: Review -> Are the above commented checks necessary?
):
self.is_single = True
return True
def get_date_from_tracks(self, tracks: list[Track]):
"""
Gets the date of the album its tracks.
# def get_date_from_tracks(self, tracks: list[Track]):
# """
# Gets the date of the album its tracks.
Args:
tracks (list[Track]): The tracks of the album.
"""
if self.date:
return
# Args:
# tracks (list[Track]): The tracks of the album.
# """
# if self.date:
# return
dates = (int(t.date) for t in tracks if t.date)
try:
self.date = datetime.datetime.fromtimestamp(min(dates)).year
except:
self.date = datetime.datetime.now().year
# dates = (int(t.date) for t in tracks if t.date)
# try:
# self.date = datetime.datetime.fromtimestamp(min(dates)).year
# except:
# self.date = datetime.datetime.now().year
def set_count(self, count: int):
self.count = count
# def set_count(self, count: int):
# self.count = count
def set_duration(self, duration: int):
self.duration = duration
# def set_duration(self, duration: int):
# self.duration = duration
def set_created_date(self, created_date: int):
self.created_date = created_date
# def set_created_date(self, created_date: int):
# self.created_date = created_date
app/models/artist.py
+6
View File
@@ -23,6 +23,12 @@ class ArtistMinimal:
if self.artisthash == "5a37d5315e":
self.name = "Juice WRLD"
def to_json(self):
return {
"name": self.name,
"artisthash": self.artisthash,
}
@dataclass(slots=True)
class Artist(ArtistMinimal):
app/models/track.py
+137 -115
View File
@@ -4,7 +4,6 @@ from pathlib import Path
from flask_jwt_extended import current_user
from app.settings import SessionVarKeys, get_flag
from app.utils.hashing import create_hash
from app.utils.parsers import (
@@ -24,10 +23,11 @@ class Track:
Track class
"""
id: int
album: str
albumartists: str | list[ArtistMinimal]
albumartists: list[dict[str, str]]
albumhash: str
artists: str | list[ArtistMinimal]
artists: str
bitrate: int
copyright: str
date: int
@@ -35,152 +35,174 @@ class Track:
duration: int
filepath: str
folder: str
genre: str | list[str]
genre: list[dict[str, str]]
last_mod: int
og_album: str
og_title: str
title: str
track: int
trackhash: str
last_mod: str | int
image: str = ""
artist_hashes: str = ""
_pos: int = 0
_ati: str = ""
fav_userids: list = field(default_factory=list)
"""
A string of user ids separated by commas.
"""
# is_favorite: bool = False
# album: str
# albumartists: str | list[ArtistMinimal]
# albumhash: str
# artists: str | list[ArtistMinimal]
# bitrate: int
# copyright: str
# date: int
# disc: int
# duration: int
# filepath: str
# folder: str
# genre: str | list[str]
# title: str
# track: int
# trackhash: str
# last_mod: str | int
@property
def is_favorite(self):
return current_user['id'] in self.fav_userids
# image: str = ""
# artist_hashes: str = ""
# temporary attributes
_pos: int = 0 # for sorting tracks by disc and track number
_ati: str = (
"" # (album track identifier) for removing duplicates when merging album versions
)
# fav_userids: list = field(default_factory=list)
# """
# A string of user ids separated by commas.
# """
# # is_favorite: bool = False
og_title: str = ""
og_album: str = ""
created_date: float = 0.0
# @property
# def is_favorite(self):
# return current_user["id"] in self.fav_userids
def set_created_date(self):
try:
self.created_date = Path(self.filepath).stat().st_ctime
except FileNotFoundError:
pass
# # temporary attributes
# _pos: int = 0 # for sorting tracks by disc and track number
# _ati: str = (
# "" # (album track identifier) for removing duplicates when merging album versions
# )
def __post_init__(self):
self.og_title = self.title
self.og_album = self.album
self.last_mod = int(self.last_mod)
self.date = int(self.date)
# og_title: str = ""
# og_album: str = ""
# created_date: float = 0.0
# add a trailing slash to the folder path
# to avoid matching a folder starting with the same name as the root path
# eg. .../Music and .../Music Videos
self.folder = os.path.join(self.folder, "")
# def set_created_date(self):
# try:
# self.created_date = Path(self.filepath).stat().st_ctime
# except FileNotFoundError:
# pass
if self.artists is not None:
artists = split_artists(self.artists)
new_title = self.title
# def __post_init__(self):
# self.og_title = self.title
# self.og_album = self.album
# self.last_mod = int(self.last_mod)
# self.date = int(self.date)
if get_flag(SessionVarKeys.EXTRACT_FEAT):
featured, new_title = parse_feat_from_title(self.title)
original_lower = "-".join([create_hash(a) for a in artists])
artists.extend(
a for a in featured if create_hash(a) not in original_lower
)
# # add a trailing slash to the folder path
# # to avoid matching a folder starting with the same name as the root path
# # eg. .../Music and .../Music Videos
# self.folder = os.path.join(self.folder, "")
self.artist_hashes = "-".join(create_hash(a, decode=True) for a in artists)
self.artists = [ArtistMinimal(a) for a in artists]
# if self.artists is not None:
# artists = split_artists(self.artists)
# new_title = self.title
albumartists = split_artists(self.albumartists)
# if get_flag(SessionVarKeys.EXTRACT_FEAT):
# featured, new_title = parse_feat_from_title(self.title)
# original_lower = "-".join([create_hash(a) for a in artists])
# artists.extend(
# a for a in featured if create_hash(a) not in original_lower
# )
if not albumartists:
self.albumartists = self.artists[:1]
else:
self.albumartists = [ArtistMinimal(a) for a in albumartists]
# self.artist_hashes = "-".join(create_hash(a, decode=True) for a in artists)
# self.artists = [ArtistMinimal(a) for a in artists]
if get_flag(SessionVarKeys.REMOVE_PROD):
new_title = remove_prod(new_title)
# albumartists = split_artists(self.albumartists)
# if track is a single
if self.og_title == self.album:
self.rename_album(new_title)
# if not albumartists:
# self.albumartists = self.artists[:1]
# else:
# self.albumartists = [ArtistMinimal(a) for a in albumartists]
if get_flag(SessionVarKeys.REMOVE_REMASTER_FROM_TRACK):
new_title = clean_title(new_title)
# if get_flag(SessionVarKeys.REMOVE_PROD):
# new_title = remove_prod(new_title)
self.title = new_title
# if track is a single
# if self.og_title == self.album:
# self.rename_album(new_title)
if get_flag(SessionVarKeys.CLEAN_ALBUM_TITLE):
self.album, _ = get_base_title_and_versions(
self.album, get_versions=False
)
# if get_flag(SessionVarKeys.REMOVE_REMASTER_FROM_TRACK):
# new_title = clean_title(new_title)
if get_flag(SessionVarKeys.MERGE_ALBUM_VERSIONS):
self.recreate_albumhash()
# self.title = new_title
self.image = self.albumhash + ".webp"
# if get_flag(SessionVarKeys.CLEAN_ALBUM_TITLE):
# self.album, _ = get_base_title_and_versions(
# self.album, get_versions=False
# )
if self.genre is not None and self.genre != "":
self.genre = self.genre.lower()
separators = {"/", ";", "&"}
# if get_flag(SessionVarKeys.MERGE_ALBUM_VERSIONS):
# self.recreate_albumhash()
contains_rnb = "r&b" in self.genre
contains_rock = "rock & roll" in self.genre
# self.image = self.albumhash + ".webp"
if contains_rnb:
self.genre = self.genre.replace("r&b", "RnB")
# if self.genre is not None and self.genre != "":
# self.genre = self.genre.lower()
# separators = {"/", ";", "&"}
if contains_rock:
self.genre = self.genre.replace("rock & roll", "rock")
# contains_rnb = "r&b" in self.genre
# contains_rock = "rock & roll" in self.genre
for s in separators:
self.genre: str = self.genre.replace(s, ",")
# if contains_rnb:
# self.genre = self.genre.replace("r&b", "RnB")
self.genre = self.genre.split(",")
self.genre = [g.strip() for g in self.genre]
# if contains_rock:
# self.genre = self.genre.replace("rock & roll", "rock")
self.recreate_hash()
self.set_created_date()
# for s in separators:
# self.genre: str = self.genre.replace(s, ",")
def recreate_hash(self):
"""
Recreates a track hash if the track title was altered
to prevent duplicate tracks having different hashes.
"""
if self.og_title == self.title and self.og_album == self.album:
return
# self.genre = self.genre.split(",")
# self.genre = [g.strip() for g in self.genre]
self.trackhash = create_hash(
", ".join(a.name for a in self.artists), self.og_album, self.title
)
# self.recreate_hash()
# self.set_created_date()
def recreate_artists_hash(self):
"""
Recreates a track's artist hashes if the artist list was altered
"""
self.artist_hashes = "-".join(a.artisthash for a in self.artists)
# def recreate_hash(self):
# """
# Recreates a track hash if the track title was altered
# to prevent duplicate tracks having different hashes.
# """
# if self.og_title == self.title and self.og_album == self.album:
# return
def recreate_albumhash(self):
"""
Recreates an albumhash of a track to merge all versions of an album.
"""
albumartists = (a.name for a in self.albumartists)
self.albumhash = create_hash(self.album, *albumartists)
# self.trackhash = create_hash(
# ", ".join(a.name for a in self.artists), self.og_album, self.title
# )
def rename_album(self, new_album: str):
"""
Renames an album
"""
self.album = new_album
# def recreate_artists_hash(self):
# """
# Recreates a track's artist hashes if the artist list was altered
# """
# self.artist_hashes = "-".join(a.artisthash for a in self.artists)
def add_artists(self, artists: list[str], new_album_title: str):
for artist in artists:
if create_hash(artist, decode=True) not in self.artist_hashes:
self.artists.append(ArtistMinimal(artist))
# def recreate_albumhash(self):
# """
# Recreates an albumhash of a track to merge all versions of an album.
# """
# albumartists = (a.name for a in self.albumartists)
# self.albumhash = create_hash(self.album, *albumartists)
self.recreate_artists_hash()
self.rename_album(new_album_title)
# def rename_album(self, new_album: str):
# """
# Renames an album
# """
# self.album = new_album
# def add_artists(self, artists: list[str], new_album_title: str):
# for artist in artists:
# if create_hash(artist, decode=True) not in self.artist_hashes:
# self.artists.append(ArtistMinimal(artist))
# self.recreate_artists_hash()
# self.rename_album(new_album_title)