storm/bragi
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

REFACTOR: MUSIC LIBRARYgit status #91

Browse Source
This commit is contained in:
Terry Geng
2020-03-06 15:45:13 +08:00
parent 1cfe61291e
commit 665edec684
12 changed files with 448 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
media/file.py
View File

@ -10,7 +10,7 @@ import json
import util
import variables as var
from media.item import BaseItem
from media.item import BaseItem, item_builders, item_loaders, item_id_generators
import constants
'''
@ -24,6 +24,20 @@ type : file
user
'''
def file_item_builder(bot, **kwargs):
return FileItem(bot, kwargs['path'])
def file_item_loader(bot, _dict):
return FileItem(bot, "", _dict)
def file_item_id_generator(**kwargs):
return hashlib.md5(kwargs['path'].encode()).hexdigest()
item_builders['file'] = file_item_builder
item_loaders['file'] = file_item_loader
item_id_generators['file'] = file_item_id_generator
class FileItem(BaseItem):
def __init__(self, bot, path, from_dict=None):
if not from_dict:
@ -49,7 +63,7 @@ class FileItem(BaseItem):
self.type = "file"
def uri(self):
return var.music_folder + self.path
return var.music_folder + self.path if self.path[0] != "/" else self.path
def is_ready(self):
return True
@ -61,6 +75,7 @@ class FileItem(BaseItem):
self.send_client_message(constants.strings('file_missed', file=self.path))
return False
self.version = 1 # 0 -> 1, notify the wrapper to save me when validate() is visited the first time
self.ready = "yes"
return True

54
media/item.py
View File

@ -11,30 +11,22 @@ from PIL import Image
import util
import variables as var
"""
FORMAT OF A MUSIC INTO THE PLAYLIST
type : url
id
url
title
path
duration
artist
thumbnail
user
ready (validation, no, downloading, yes, failed)
from_playlist (yes,no)
playlist_title
playlist_url
item_builders = {}
item_loaders = {}
item_id_generators = {}
type : radio
id
url
name
current_title
user
def example_builder(bot, **kwargs):
return BaseItem(bot)
"""
def example_loader(bot, _dict):
return BaseItem(bot, from_dict=_dict)
def example_id_generator(**kwargs):
return ""
item_builders['base'] = example_builder
item_loaders['base'] = example_loader
item_id_generators['base'] = example_id_generator
class BaseItem:
def __init__(self, bot, from_dict=None):
@ -42,6 +34,9 @@ class BaseItem:
self.log = logging.getLogger("bot")
self.type = "base"
self.title = ""
self.path = ""
self.tags = []
self.version = 0 # if version increase, wrapper will re-save this item
if from_dict is None:
self.id = ""
@ -62,22 +57,9 @@ class BaseItem:
def uri(self):
raise
def async_prepare(self):
th = threading.Thread(
target=self.prepare, name="Prepare-" + self.id[:7])
self.log.info(
"%s: start preparing item in thread: " % self.type + self.format_debug_string())
th.daemon = True
th.start()
#self.download_threads.append(th)
return th
def prepare(self):
return True
def play(self):
pass
def format_song_string(self, user):
return self.id
@ -97,6 +79,6 @@ class BaseItem:
self.bot.send_msg(msg)
def to_dict(self):
return {"type" : "base", "id": self.id, "ready": self.ready}
return {"type" : "base", "id": self.id, "ready": self.ready, "path": self.path, "tags": self.tags}

70
media/library.py Normal file
View File

@ -0,0 +1,70 @@
import logging
from database import MusicDatabase
from media.item import item_builders, item_loaders, item_id_generators
from media.file import FileItem
from media.url import URLItem
from media.url_from_playlist import PlaylistURLItem
from media.radio import RadioItem
from database import MusicDatabase
import variables as var
class MusicLibrary(dict):
def __init__(self, db: MusicDatabase):
super().__init__()
self.db = db
self.log = logging.getLogger("bot")
def get_item_by_id(self, bot, id):
if id in self:
return self[id]
# if not cached, query the database
item = self.fetch(bot, id)
if item is not None:
self[id] = item
self.log.debug("library: music found in database: %s" % item.format_debug_string())
return item
def get_item(self, bot, **kwargs):
# kwargs should provide type and id, and parameters to build the item if not existed in the library.
# if cached
id = item_id_generators[kwargs['type']](**kwargs)
if id in self:
return self[id]
# if not cached, query the database
item = self.fetch(bot, id)
if item is not None:
self[id] = item
self.log.debug("library: music found in database: %s" % item.format_debug_string())
return item
# if not in the database, build one
self[id] = item_builders[kwargs['type']](bot, **kwargs) # newly built item will not be saved immediately
return self[id]
def fetch(self, bot, id):
music_dicts = self.db.query_music(id=id)
if music_dicts:
music_dict = music_dicts[0]
type = music_dict['type']
self[id] = item_loaders[type](bot, music_dict)
return self[id]
else:
return None
def save(self, id):
self.log.debug("library: music save into database: %s" % self[id].format_debug_string())
self.db.insert_music(self[id].to_dict())
def delete(self, id):
self.db.delete_music(id=id)
def free(self, id):
if id in self:
del self[id]
def free_all(self):
self.clear()

104
media/playlist.py
View File

@ -8,40 +8,81 @@ from media.file import FileItem
from media.url import URLItem
from media.url_from_playlist import PlaylistURLItem
from media.radio import RadioItem
from database import MusicDatabase
from media.library import MusicLibrary
class PlaylistItemWrapper:
def __init__(self, item, user):
self.item = item
def __init__(self, lib, id, type, user):
self.lib = lib
self.id = id
self.user = user
self.type = type
self.log = logging.getLogger("bot")
self.version = 1
def item(self):
return self.lib[self.id]
def to_dict(self):
dict = self.item.to_dict()
dict = self.item().to_dict()
dict['user'] = self.user
return dict
def validate(self):
ret = self.item().validate()
if ret and self.item().version > self.version:
self.version = self.item().version
self.lib.save(self.id)
return ret
def prepare(self):
ret = self.item().prepare()
if ret and self.item().version > self.version:
self.version = self.item().version
self.lib.save(self.id)
return ret
def async_prepare(self):
th = threading.Thread(
target=self.item().prepare, name="Prepare-" + self.id[:7])
self.log.info(
"%s: start preparing item in thread: " % self.item().type + self.format_debug_string())
th.daemon = True
th.start()
return th
def uri(self):
return self.item().uri()
def is_ready(self):
return self.item().is_ready()
def is_failed(self):
return self.item().is_failed()
def format_current_playing(self):
return self.item.format_current_playing(self.user)
return self.item().format_current_playing(self.user)
def format_song_string(self):
return self.item.format_song_string(self.user)
return self.item().format_song_string(self.user)
def format_short_string(self):
return self.item.format_short_string()
return self.item().format_short_string()
def format_debug_string(self):
return self.item.format_debug_string()
return self.item().format_debug_string()
def display_type(self):
return self.item().display_type()
def dict_to_item(dict):
if dict['type'] == 'file':
return PlaylistItemWrapper(FileItem(var.bot, "", dict), dict['user'])
elif dict['type'] == 'url':
return PlaylistItemWrapper(URLItem(var.bot, "", dict), dict['user'])
elif dict['type'] == 'url_from_playlist':
return PlaylistItemWrapper(PlaylistURLItem(var.bot, "", "", "", "", dict), dict['user'])
elif dict['type'] == 'radio':
return PlaylistItemWrapper(RadioItem(var.bot, "", "", dict), dict['user'])
def get_item_wrapper(bot, **kwargs):
item = var.library.get_item(bot, **kwargs)
return PlaylistItemWrapper(var.library, item.id, kwargs['type'], kwargs['user'])
def get_item_wrapper_by_id(bot, id, user):
item = var.library.get_item_by_id(bot, id)
return PlaylistItemWrapper(var.library, item.id, item.type, user)
def get_playlist(mode, _list=None, index=None):
if _list and index is None:
@ -61,10 +102,8 @@ def get_playlist(mode, _list=None, index=None):
return RepeatPlaylist().from_list(_list, index)
elif mode == "random":
return RandomPlaylist().from_list(_list, index)
raise
class BasePlayList(list):
def __init__(self):
super().__init__()
@ -154,18 +193,21 @@ class BasePlayList(list):
if self.current_index > index:
self.current_index -= 1
var.music_db.free(removed.id)
return removed
def remove_by_id(self, id):
self.version += 1
to_be_removed = []
for index, wrapper in enumerate(self):
if wrapper.item.id == id:
if wrapper.id == id:
to_be_removed.append(index)
for index in to_be_removed:
self.remove(index)
var.music_db.free(id)
def current_item(self):
if len(self) == 0:
return False
@ -198,6 +240,7 @@ class BasePlayList(list):
def clear(self):
self.version += 1
self.current_index = -1
var.library.free_all()
super().clear()
def save(self):
@ -205,16 +248,23 @@ class BasePlayList(list):
var.db.set("playlist", "current_index", self.current_index)
for index, music in enumerate(self):
var.db.set("playlist_item", str(index), json.dumps(music.to_dict()))
var.db.set("playlist_item", str(index), json.dumps({'id': music.id, 'user': music.user }))
def load(self):
current_index = var.db.getint("playlist", "current_index", fallback=-1)
if current_index == -1:
return
items = list(var.db.items("playlist_item"))
items.sort(key=lambda v: int(v[0]))
self.from_list(list(map(lambda v: dict_to_item(json.loads(v[1])), items)), current_index)
items = var.db.items("playlist_item")
if items:
music_wrappers = []
items.sort(key=lambda v: int(v[0]))
for item in items:
item = json.loads(item[1])
music_wrapper = get_item_wrapper_by_id(var.bot, item['id'], item['user'])
if music_wrapper:
music_wrappers.append(music_wrapper)
self.from_list(music_wrappers, current_index)
def _debug_print(self):
print("===== Playlist(%d)=====" % self.current_index)
@ -235,10 +285,10 @@ class BasePlayList(list):
self.log.debug("playlist: start validating...")
self.validating_thread_lock.acquire()
while len(self.pending_items) > 0:
item = self.pending_items.pop().item
item = self.pending_items.pop()
self.log.debug("playlist: validating %s" % item.format_debug_string())
if not item.validate() or item.ready == 'failed':
# TODO: logging
if not item.validate() or item.is_failed():
self.log.debug("playlist: validating failed.")
self.remove_by_id(item.id)
self.log.debug("playlist: validating finished.")

20
media/radio.py
View File

@ -6,6 +6,7 @@ import traceback
import hashlib
from media.item import BaseItem
from media.item import item_builders, item_loaders, item_id_generators
import constants
log = logging.getLogger("bot")
@ -74,6 +75,24 @@ def get_radio_title(url):
pass
return url
def radio_item_builder(bot, **kwargs):
if 'name' in kwargs:
return RadioItem(bot, kwargs['url'], kwargs['name'])
else:
return RadioItem(bot, kwargs['url'], '')
def radio_item_loader(bot, _dict):
return RadioItem(bot, "", "", _dict)
def radio_item_id_generator(**kwargs):
return hashlib.md5(kwargs['url'].encode()).hexdigest()
item_builders['radio'] = radio_item_builder
item_loaders['radio'] = radio_item_loader
item_id_generators['radio'] = radio_item_id_generator
class RadioItem(BaseItem):
def __init__(self, bot, url, name="", from_dict=None):
if from_dict is None:
@ -92,6 +111,7 @@ class RadioItem(BaseItem):
self.type = "radio"
def validate(self):
self.version = 1 # 0 -> 1, notify the wrapper to save me when validate() is visited the first time
return True
def is_ready(self):

20
media/url.py
View File

@ -10,17 +10,31 @@ import glob
import constants
import media
import variables as var
from media.item import item_builders, item_loaders, item_id_generators
from media.file import FileItem
import media.system
log = logging.getLogger("bot")
def url_item_builder(bot, **kwargs):
return URLItem(bot, kwargs['url'])
def url_item_loader(bot, _dict):
return URLItem(bot, "", _dict)
def url_item_id_generator(**kwargs):
return hashlib.md5(kwargs['url'].encode()).hexdigest()
item_builders['url'] = url_item_builder
item_loaders['url'] = url_item_loader
item_id_generators['url'] = url_item_id_generator
class URLItem(FileItem):
def __init__(self, bot, url, from_dict=None):
self.validating_lock = threading.Lock()
if from_dict is None:
self.url = url
self.url = url if url[-1] != "/" else url[:-1]
self.title = ''
self.duration = 0
self.ready = 'pending'
@ -45,7 +59,7 @@ class URLItem(FileItem):
self.type = "url"
def uri(self):
return self.path
return var.music_folder + self.path if self.path[0] != "/" else self.path
def is_ready(self):
if self.downloading or self.ready != 'yes':
@ -82,6 +96,7 @@ class URLItem(FileItem):
return False
else:
self.ready = "validated"
self.version += 1 # notify wrapper to save me
return True
# Run in a other thread
@ -165,6 +180,7 @@ class URLItem(FileItem):
"bot: finished downloading url (%s) %s, saved to %s." % (self.title, self.url, self.path))
self.downloading = False
self._read_thumbnail_from_file(base_path + ".jpg")
self.version += 1 # notify wrapper to save me
return True
else:
for f in glob.glob(base_path + "*"):

21
media/url_from_playlist.py
View File

@ -2,7 +2,9 @@ import youtube_dl
import constants
import media
import variables as var
from media.url import URLItem
import hashlib
from media.item import item_builders, item_loaders, item_id_generators
from media.url import URLItem, url_item_id_generator
def get_playlist_info(bot, url, start_index=0, user=""):
items = []
@ -48,6 +50,23 @@ def get_playlist_info(bot, url, start_index=0, user=""):
return items
def playlist_url_item_builder(bot, **kwargs):
return PlaylistURLItem(bot,
kwargs['url'],
kwargs['title'],
kwargs['playlist_url'],
kwargs['playlist_title'])
def playlist_url_item_loader(bot, _dict):
return PlaylistURLItem(bot, "", "", "", "", _dict)
item_builders['url_from_playlist'] = playlist_url_item_builder
item_loaders['url_from_playlist'] = playlist_url_item_loader
item_id_generators['url_from_playlist'] = url_item_id_generator
class PlaylistURLItem(URLItem):
def __init__(self, bot, url, title, playlist_url, playlist_title, from_dict=None):
if from_dict is None: