media/playlist.py

   1 import json
   2 import random
   3 import threading
   4 import logging
   5 import random
   6
   7 import variables as var
   8 from media.file import FileItem
   9 from media.url import URLItem
  10 from media.url_from_playlist import PlaylistURLItem
  11 from media.radio import RadioItem
  12 from database import MusicDatabase
  13 from media.library import MusicLibrary
  14
  15 class PlaylistItemWrapper:
  16     def __init__(self, lib, id, type, user):
  17         self.lib = lib
  18         self.id = id
  19         self.user = user
  20         self.type = type
  21         self.log = logging.getLogger("bot")
  22         self.version = 0
  23
  24     def item(self):
  25         return self.lib[self.id]
  26
  27     def to_dict(self):
  28         dict = self.item().to_dict()
  29         dict['user'] = self.user
  30         return dict
  31
  32     def validate(self):
  33         ret = self.item().validate()
  34         if ret and self.item().version > self.version:
  35             self.version = self.item().version
  36             self.lib.save(self.id)
  37         return ret
  38
  39     def prepare(self):
  40         ret = self.item().prepare()
  41         if ret and self.item().version > self.version:
  42             self.version = self.item().version
  43             self.lib.save(self.id)
  44         return ret
  45
  46     def async_prepare(self):
  47         th = threading.Thread(
  48             target=self.item().prepare, name="Prepare-" + self.id[:7])
  49         self.log.info(
  50             "%s: start preparing item in thread: " % self.item().type + self.format_debug_string())
  51         th.daemon = True
  52         th.start()
  53         return th
  54
  55     def uri(self):
  56         return self.item().uri()
  57
  58     def add_tag(self, tag):
  59         self.item().add_tag(tag)
  60         if self.item().version > self.version:
  61             self.version = self.item().version
  62             self.lib.save(self.id)
  63
  64     def remove_tag(self, tag):
  65         self.item().remove_tag(tag)
  66         if self.item().version > self.version:
  67             self.version = self.item().version
  68             self.lib.save(self.id)
  69
  70     def is_ready(self):
  71         return self.item().is_ready()
  72
  73     def is_failed(self):
  74         return self.item().is_failed()
  75
  76     def format_current_playing(self):
  77         return self.item().format_current_playing(self.user)
  78
  79     def format_song_string(self):
  80         return self.item().format_song_string(self.user)
  81
  82     def format_short_string(self):
  83         return self.item().format_short_string()
  84
  85     def format_debug_string(self):
  86         return self.item().format_debug_string()
  87
  88     def display_type(self):
  89         return self.item().display_type()
  90
  91
  92 def get_item_wrapper(bot, **kwargs):
  93     item = var.library.get_item(bot, **kwargs)
  94     return PlaylistItemWrapper(var.library, item.id, kwargs['type'], kwargs['user'])
  95
  96 def get_item_wrapper_by_id(bot, id, user):
  97     item = var.library.get_item_by_id(bot, id)
  98     if item:
  99         return PlaylistItemWrapper(var.library, item.id, item.type, user)
 100     else:
 101         return None
 102
 103 def get_item_wrappers_by_tags(bot, tags, user):
 104     items = var.library.get_items_by_tags(bot, tags)
 105     ret = []
 106     for item in items:
 107         ret.append(PlaylistItemWrapper(var.library, item.id, item.type, user))
 108     return ret
 109
 110 def get_playlist(mode, _list=None, index=None):
 111     if _list and index is None:
 112         index = _list.current_index
 113
 114     if _list is None:
 115         if mode == "one-shot":
 116             return OneshotPlaylist()
 117         elif mode == "repeat":
 118             return RepeatPlaylist()
 119         elif mode == "random":
 120             return RandomPlaylist()
 121         elif mode == "autoplay":
 122             return AutoPlaylist()
 123     else:
 124         if mode == "one-shot":
 125             return OneshotPlaylist().from_list(_list, index)
 126         elif mode == "repeat":
 127             return RepeatPlaylist().from_list(_list, index)
 128         elif mode == "random":
 129             return RandomPlaylist().from_list(_list, index)
 130         elif mode == "autoplay":
 131             return AutoPlaylist().from_list(_list, index)
 132     raise
 133
 134 class BasePlaylist(list):
 135     def __init__(self):
 136         super().__init__()
 137         self.current_index = -1
 138         self.version = 0  # increase by one after each change
 139         self.mode = "base"  # "repeat", "random"
 140         self.pending_items = []
 141         self.log = logging.getLogger("bot")
 142         self.validating_thread_lock = threading.Lock()
 143
 144     def is_empty(self):
 145         return True if len(self) == 0 else False
 146
 147     def from_list(self, _list, current_index):
 148         self.version += 1
 149         super().clear()
 150         self.extend(_list)
 151         self.current_index = current_index
 152
 153         return self
 154
 155     def append(self, item: PlaylistItemWrapper):
 156         self.version += 1
 157         super().append(item)
 158         self.pending_items.append(item)
 159         self.start_async_validating()
 160
 161         return item
 162
 163     def insert(self, index, item):
 164         self.version += 1
 165
 166         if index == -1:
 167             index = self.current_index
 168
 169         super().insert(index, item)
 170
 171         if index <= self.current_index:
 172             self.current_index += 1
 173
 174         self.pending_items.append(item)
 175         self.start_async_validating()
 176
 177         return item
 178
 179     def extend(self, items):
 180         self.version += 1
 181         super().extend(items)
 182         self.pending_items.extend(items)
 183         self.start_async_validating()
 184         return items
 185
 186     def next(self):
 187         if len(self) == 0:
 188             return False
 189
 190         self.version += 1
 191
 192         if self.current_index < len(self) - 1:
 193             self.current_index += 1
 194             return self[self.current_index]
 195         else:
 196             return False
 197
 198     def point_to(self, index):
 199         self.version += 1
 200         if -1 <= index < len(self):
 201             self.current_index = index
 202
 203     def find(self, id):
 204         for index, wrapper in enumerate(self):
 205             if wrapper.item.id == id:
 206                 return index
 207         return None
 208
 209     def __delitem__(self, key):
 210         return self.remove(key)
 211
 212     def remove(self, index):
 213         self.version += 1
 214         if index > len(self) - 1:
 215             return False
 216
 217         removed = self[index]
 218         super().__delitem__(index)
 219
 220         if self.current_index > index:
 221             self.current_index -= 1
 222
 223         var.library.free(removed.id)
 224         return removed
 225
 226     def remove_by_id(self, id):
 227         self.version += 1
 228         to_be_removed = []
 229         for index, wrapper in enumerate(self):
 230             if wrapper.id == id:
 231                 to_be_removed.append(index)
 232
 233         for index in to_be_removed:
 234             self.remove(index)
 235
 236         var.library.free(id)
 237
 238     def current_item(self):
 239         if len(self) == 0:
 240             return False
 241
 242         return self[self.current_index]
 243
 244     def next_index(self):
 245         if self.current_index < len(self) - 1:
 246             return self.current_index + 1
 247         else:
 248             return False
 249
 250     def next_item(self):
 251         if self.current_index < len(self) - 1:
 252             return self[self.current_index + 1]
 253         else:
 254             return False
 255
 256     def randomize(self):
 257         # current_index will lose track after shuffling, thus we take current music out before shuffling
 258         #current = self.current_item()
 259         #del self[self.current_index]
 260
 261         random.shuffle(self)
 262
 263         #self.insert(0, current)
 264         self.current_index = -1
 265         self.version += 1
 266
 267     def clear(self):
 268         self.version += 1
 269         self.current_index = -1
 270         var.library.free_all()
 271         super().clear()
 272
 273     def save(self):
 274         var.db.remove_section("playlist_item")
 275         var.db.set("playlist", "current_index", self.current_index)
 276
 277         for index, music in enumerate(self):
 278             var.db.set("playlist_item", str(index), json.dumps({'id': music.id, 'user': music.user }))
 279
 280     def load(self):
 281         current_index = var.db.getint("playlist", "current_index", fallback=-1)
 282         if current_index == -1:
 283             return
 284
 285         items = var.db.items("playlist_item")
 286         if items:
 287             music_wrappers = []
 288             items.sort(key=lambda v: int(v[0]))
 289             for item in items:
 290                 item = json.loads(item[1])
 291                 music_wrapper = get_item_wrapper_by_id(var.bot, item['id'], item['user'])
 292                 if music_wrapper:
 293                     music_wrappers.append(music_wrapper)
 294             self.from_list(music_wrappers, current_index)
 295
 296     def _debug_print(self):
 297         print("===== Playlist(%d)=====" % self.current_index)
 298         for index, item_wrapper in enumerate(self):
 299             if index == self.current_index:
 300                 print("-> %d %s" % (index, item_wrapper.format_debug_string()))
 301             else:
 302                 print("%d %s" % (index, item_wrapper.format_debug_string()))
 303         print("=====     End     =====")
 304
 305     def start_async_validating(self):
 306         if not self.validating_thread_lock.locked():
 307             th = threading.Thread(target=self._check_valid, name="Validating")
 308             th.daemon = True
 309             th.start()
 310
 311     def _check_valid(self):
 312         self.log.debug("playlist: start validating...")
 313         self.validating_thread_lock.acquire()
 314         while len(self.pending_items) > 0:
 315             item = self.pending_items.pop()
 316             self.log.debug("playlist: validating %s" % item.format_debug_string())
 317             if not item.validate() or item.is_failed():
 318                 self.log.debug("playlist: validating failed.")
 319                 self.remove_by_id(item.id)
 320                 var.library.delete(item.item())
 321
 322         self.log.debug("playlist: validating finished.")
 323         self.validating_thread_lock.release()
 324
 325
 326 class OneshotPlaylist(BasePlaylist):
 327     def __init__(self):
 328         super().__init__()
 329         self.mode = "one-shot"
 330         self.current_index = -1
 331
 332     def from_list(self, _list, current_index):
 333         for i in range(current_index):
 334             _list.pop()
 335         return super().from_list(_list, -1)
 336
 337     def next(self):
 338         if len(self) == 0:
 339             return False
 340
 341         self.version += 1
 342
 343         if len(self) > 0:
 344             if self.current_index != -1:
 345                 super().__delitem__(self.current_index)
 346                 if len(self) == 0:
 347                     return False
 348             else:
 349                 self.current_index = 0
 350             return self[0]
 351
 352         else:
 353             self.clear()
 354             return False
 355
 356     def next_index(self):
 357         if len(self) > 1:
 358             return 1
 359         else:
 360             return False
 361
 362     def next_item(self):
 363         if len(self) > 1:
 364             return self[1]
 365         else:
 366             return False
 367
 368     def point_to(self, index):
 369         self.version += 1
 370         self.current_index = -1
 371         for i in range(index + 1):
 372             super().__delitem__(0)
 373
 374
 375 class RepeatPlaylist(BasePlaylist):
 376     def __init__(self):
 377         super().__init__()
 378         self.mode = "repeat"
 379
 380     def next(self):
 381         if len(self) == 0:
 382             return False
 383
 384         self.version += 1
 385
 386         if self.current_index < len(self) - 1:
 387             self.current_index += 1
 388             return self[self.current_index]
 389         else:
 390             self.current_index = 0
 391             return self[0]
 392
 393     def next_index(self):
 394         if self.current_index < len(self) - 1:
 395             return self.current_index + 1
 396         else:
 397             return 0
 398
 399     def next_item(self):
 400         return self[self.next_index()]
 401
 402
 403 class RandomPlaylist(BasePlaylist):
 404     def __init__(self):
 405         super().__init__()
 406         self.mode = "random"
 407
 408     def from_list(self, _list, current_index):
 409         self.version += 1
 410         random.shuffle(_list)
 411         return super().from_list(_list, -1)
 412
 413     def next(self):
 414         if len(self) == 0:
 415             return False
 416
 417         self.version += 1
 418
 419         if self.current_index < len(self) - 1:
 420             self.current_index += 1
 421             return self[self.current_index]
 422         else:
 423             self.randomize()
 424             self.current_index = 0
 425             return self[0]
 426
 427
 428 class AutoPlaylist(BasePlaylist):
 429     def __init__(self):
 430         super().__init__()
 431         self.mode = "autoplay"
 432
 433     def refresh(self):
 434         _list = []
 435         ids = var.music_db.query_all_ids()
 436         for _ in range(20):
 437             _list.append(get_item_wrapper_by_id(var.bot, ids[random.randint(0, len(ids)-1)], 'AutoPlay'))
 438         self.from_list(_list, -1)
 439
 440     # def from_list(self, _list, current_index):
 441     #     self.version += 1
 442     #     self.refresh()
 443     #     return self
 444
 445     def clear(self):
 446         super().clear()
 447         self.refresh()
 448
 449     def next(self):
 450         if len(self) == 0:
 451             return False
 452
 453         self.version += 1
 454
 455         if self.current_index < len(self) - 1:
 456             self.current_index += 1
 457             return self[self.current_index]
 458         else:
 459             self.refresh()
 460             self.current_index = 0
 461             return self[0]