185 lines
7.1 KiB
Python
185 lines
7.1 KiB
Python
from . import _
|
|
from .cache import IdRelativeCache
|
|
from .config import Config
|
|
from .db import PlaybackReportingDb, LibraryDb
|
|
from .utils import ask_choice
|
|
from re import compile
|
|
|
|
|
|
ITEMNAME_PATTERN = compile(r'(?P<album_artist>.*) - (?P<track>.*) \((?P<album>.*)\)') # noqa: E501
|
|
|
|
|
|
def print_item(item):
|
|
s = item['Name']
|
|
if item['Album']:
|
|
s += "\n" + _("Album: ") + item['Album']
|
|
if item['Artists']:
|
|
s += "\n" + _("Artists: ") + item['Artists']
|
|
if item['AlbumArtists']:
|
|
s += "\n" + _("Album artists: ") + item['AlbumArtists']
|
|
return s
|
|
|
|
|
|
class AudioSelector:
|
|
def __init__(self, cfg: Config, origin, ldb: LibraryDb, choices=None):
|
|
self.cfg = cfg
|
|
self.origin = origin
|
|
self.ldb = ldb
|
|
self.choices = choices if choices and len(choices) else None
|
|
self.re = None
|
|
self.fns = []
|
|
|
|
def print_original(self):
|
|
print(_("Original item: ") + self.origin['track'])
|
|
if self.origin['album']:
|
|
print(_("Album: ") + self.origin['album'])
|
|
if self.origin['album_artist']:
|
|
print(_("Album artists: ") + self.origin['album_artist'])
|
|
|
|
def choose_in_choices(self):
|
|
item = ask_choice(self.cfg, self.choices, _("Please choose audio item:"), print_item, (("x", _("No item"), "none"), ("o", _("Choose other items"), "other"),)) # noqa: E501
|
|
self.re = item
|
|
if item == "none":
|
|
self.re = None
|
|
elif item == "other":
|
|
self.fns.append(self.choose_others)
|
|
|
|
def choose_others(self):
|
|
act = [("i", _("Input item id"), "id"), ("t", _("Input track name"), "track"), ("a", _("Input album name"), "album"), ("x", _("No item"), "none")] # noqa: E501
|
|
if self.choices:
|
|
act.append(("o", _("Choose in given choices"), "choose"))
|
|
re = ask_choice(self.cfg, [], _("Please choose action: "), extra=act)
|
|
if re == "choose":
|
|
self.fns.append(self.choose_in_choices)
|
|
elif re == "id":
|
|
self.fns.append(self.input_id)
|
|
elif re == "track":
|
|
self.fns.append(self.input_track)
|
|
elif re == "album":
|
|
self.fns.append(self.input_album)
|
|
elif re == "none":
|
|
self.re = None
|
|
|
|
def input_id(self):
|
|
id = input(_("Please input item id:"))
|
|
item = self.ldb.get_item(id)
|
|
if item and item['type'] == 'MediaBrowser.Controller.Entities.Audio.Audio': # noqa: E501
|
|
self.re = item
|
|
else:
|
|
print(_("Item not found."))
|
|
self.fns.append(self.choose_others)
|
|
|
|
def handle_items(self, items):
|
|
if len(items):
|
|
act = [("b", _("Back"), "back"), ("x", _("No item"), "none")]
|
|
if self.choices:
|
|
act.append(("o", _("Choose in given choices"), "choose"))
|
|
self.re = ask_choice(self.cfg, items, _("Please choose audio item:"), print_item, act) # noqa: E501
|
|
if self.re == "back":
|
|
self.fns.append(self.choose_others)
|
|
elif self.re == "choose":
|
|
self.fns.append(self.choose_in_choices)
|
|
elif self.re == "none":
|
|
self.re = None
|
|
else:
|
|
print(_("Items not found."))
|
|
self.fns.append(self.choose_others)
|
|
|
|
def input_track(self):
|
|
track = input(_("Please input track name:"))
|
|
items = self.ldb.get_audios(track)
|
|
self.handle_items(items)
|
|
|
|
def input_album(self):
|
|
album = input(_("Please input album name:"))
|
|
items = self.ldb.get_audios(album=album)
|
|
self.handle_items(items)
|
|
|
|
def ask(self):
|
|
self.print_original()
|
|
if self.choices:
|
|
self.fns.append(self.choose_in_choices)
|
|
else:
|
|
self.fns.append(self.choose_others)
|
|
while True:
|
|
if len(self.fns) == 0:
|
|
break
|
|
self.fns.pop(0)()
|
|
return self.re
|
|
|
|
|
|
def generate_audio_report(pdb: PlaybackReportingDb, ldb: LibraryDb,
|
|
icache: IdRelativeCache, cfg: Config):
|
|
offset = 0
|
|
data = pdb.get_activitys(offset, itemType='Audio')
|
|
count = 0
|
|
re = None
|
|
itemMap = {}
|
|
itemList = {}
|
|
while len(data) > 0:
|
|
for d in data:
|
|
itemId = d['ItemId']
|
|
item = ldb.get_item(itemId)
|
|
if not item:
|
|
re = icache.get(itemId)
|
|
if re:
|
|
item = ldb.get_item(re['id'])
|
|
if item and isinstance(item, str):
|
|
if item == 'no_track':
|
|
if itemId in itemMap:
|
|
itemList[itemId].append(d)
|
|
else:
|
|
itemMap[itemId] = d
|
|
itemList[itemId] = [d]
|
|
continue
|
|
elif item and item['PresentationUniqueKey'] in itemMap:
|
|
itemList[item['PresentationUniqueKey']].append(d)
|
|
continue
|
|
else:
|
|
if itemId in itemMap:
|
|
itemList[itemId].append(d)
|
|
continue
|
|
else:
|
|
if itemId in itemMap:
|
|
itemList[itemId].append(d)
|
|
continue
|
|
if not item:
|
|
itemName = d['ItemName']
|
|
if re is None:
|
|
re = ITEMNAME_PATTERN.match(itemName)
|
|
if re is None:
|
|
raise ValueError(f"Failed to parse ItemName: {itemName}")
|
|
re = re.groupdict()
|
|
if re['album_artist'] == 'Not Known':
|
|
re['album_artist'] = None
|
|
if re['album'] == 'Not Known':
|
|
re['album'] = None
|
|
items = ldb.get_audios(re['track'], re['album'])
|
|
if len(items) == 1:
|
|
newId = items[0]['PresentationUniqueKey']
|
|
icache.set(itemId, newId, {'album': items[0]['Album'], 'track': items[0]['Name'], 'album_artist': items[0]['AlbumArtists'], 'original': re}) # noqa: E501
|
|
item = items[0]
|
|
else:
|
|
if not len(items):
|
|
items = ldb.get_audios(re['track'])
|
|
if not len(items) and re['album']:
|
|
items = ldb.get_audios(album=re['album'])
|
|
item = AudioSelector(cfg, re, ldb, items).ask()
|
|
if item:
|
|
newId = item['PresentationUniqueKey']
|
|
icache.set(itemId, newId, {'album': item['Album'], 'track': item['Name'], 'album_artist': item['AlbumArtists'], 'original': re}) # noqa: E501
|
|
else:
|
|
icache.set_value(itemId, 'no_track')
|
|
if item:
|
|
itemId = item['PresentationUniqueKey']
|
|
itemMap[itemId] = item
|
|
itemList[itemId] = [d]
|
|
else:
|
|
print(d)
|
|
itemMap[itemId] = d
|
|
itemList[itemId] = [d]
|
|
count += 1
|
|
offset += len(data)
|
|
data = pdb.get_activitys(offset, itemType='Audio')
|
|
print('Count', count)
|