def search(self, album, artists=u'', limit=40):
if time.time() - self.__lasttime < 1000:
time.sleep(1)
ret = []
check_matches = False
if isempty(artists):
artist = None
if len(artists) > 1:
artist = u'Various Artists'
elif artists:
if hasattr(artists, 'items'):
artist = artists.keys()[0]
else:
artist = artists[0]
if not album and not artist:
raise RetrievalError('Album or Artist required.')
write_log(u'Searching for %s' % album)
if hasattr(artists, "items"):
album_id = find_id(chain(*artists.values()), "mbrainz_album_id")
if album_id:
try:
write_log(translate("MusicBrainz",
"Found album id %s in tracks. Retrieving") % album_id)
return [retrieve_album(album_id)]
except RetrievalError, e:
msg = translate("MusicBrainz",
"<b>Error:</b> While retrieving Album ID %1 (%2)")
write_log(msg.arg(album_id).arg(escape(e)))
def update_status(enable = True):
files = status['selectedfiles']
pattern = status['patterntext']
tf = lambda *args, **kwargs: encode_fn(findfunc.tagtofilename(*args, **kwargs))
if not files:
return
tag = files[0]
state = {'__counter': u'1', '__total_files': unicode(len(files))}
x = findfunc.filenametotag(pattern, tag[PATH], True)
emit('ftstatus', display_tag(x))
bold_error = translate("Status Bar", "<b>%s</b>")
try:
newfilename = functions.move(tag, pattern, tag, state=state.copy())
if newfilename:
newfilename = newfilename['__path']
emit('tfstatus', translate("Status Bar",
"New Filename: <b>%1</b>").arg(
decode_fn(newfilename)))
else:
emit('tfstatus', u'<b>No change</b>')
except findfunc.ParseError, e:
emit('tfstatus', bold_error % e.message)
def urlopen(url, mask=True, code=False):
try:
request = urllib2.Request(url)
if useragent:
request.add_header('User-Agent', useragent)
page = urllib2.build_opener().open(request)
if page.code == 403:
raise RetrievalError(
translate("Tag Sources", 'HTTPError 403: Forbidden'))
elif page.code == 404:
raise RetrievalError(
translate("Tag Sources", "Page doesn't exist"))
if code:
return page.read(), page.code
else:
return page.read()
except urllib2.URLError as e:
try:
msg = u'%s (%s)' % (e.reason.strerror, e.reason.errno)
except AttributeError:
msg = unicode(e)
try:
raise RetrievalError(msg, e.code)
except AttributeError:
raise RetrievalError(
translate("Defaults", "Connection Error: %s ") % e.args[1])
except socket.error as e:
msg = u'%s (%s)' % (e.strerror, e.code)
raise RetrievalError(msg)
except EnvironmentError as e:
msg = u'%s (%s)' % (e.strerror, e.code)
raise RetrievalError(msg)
def search(self):
if not self.searchButton.isEnabled():
return
files = self._status['selectedfiles']
if self.curSource.group_by:
group = split_by_field(files, *self.curSource.group_by)
self.label.setText(translate("WebDB", 'Searching...'))
text = None
if self.searchEdit.text() and self.searchEdit.isEnabled():
text = unicode(self.searchEdit.text())
elif not files:
self.label.setText(translate("WebDB",
'<b>Select some files or enter search paramaters.</b>'))
return
def search():
try:
ret = []
if text:
return self.curSource.keyword_search(text), None
else:
return tag_source_search(self.curSource, group, files)
except RetrievalError, e:
return translate('WebDB',
'An error occured: %1').arg(unicode(e))
except Exception, e:
traceback.print_exc()
return translate('WebDB',
'An unhandled error occurred: %1').arg(unicode(e))
def search(self, album, artists=u'', limit=40):
if time.time() - self.__lasttime < 1000:
time.sleep(1)
ret = []
check_matches = False
if isempty(artists):
artist = None
if len(artists) > 1:
artist = u'Various Artists'
elif artists:
if hasattr(artists, 'items'):
artist = artists.keys()[0]
else:
artist = artists[0]
if not album and not artist:
raise RetrievalError('Album or Artist required.')
write_log(u'Searching for %s' % album)
if hasattr(artists, "items"):
album_id = find_id(chain(*artists.values()), "mbrainz_album_id")
if album_id:
try:
write_log(
translate("MusicBrainz",
"Found album id %s in tracks. Retrieving") %
album_id)
return [retrieve_album(album_id)]
except RetrievalError, e:
msg = translate(
"MusicBrainz",
"<b>Error:</b> While retrieving Album ID %1 (%2)")
write_log(msg.arg(album_id).arg(escape(e)))
def parse_album_xml(text, album=None):
"""Parses the retrieved xml for an album and get's the track listing."""
doc = minidom.parseString(text)
album_item = doc.getElementsByTagName('Item')[0]
try:
tracklist = album_item.getElementsByTagName('Tracks')[0]
except IndexError:
write_log(translate('Amazon',
'Invalid XML returned. No tracks listed.'))
write_log(text)
raise RetrievalError(translate('Amazon',
'Invalid XML returned. No tracks listed.'))
tracks = []
discs = [disc for disc in tracklist.childNodes if
not disc.nodeType == disc.TEXT_NODE]
if not (len(discs) > 1 and album):
album = None
for discnum, disc in enumerate(discs):
for track_node in disc.childNodes:
if track_node.nodeType == track_node.TEXT_NODE:
continue
title = get_text(track_node)
tracknumber = track_node.attributes['Number'].value
if album:
tracks.append({'track': tracknumber, 'title': title,
'album': u'%s (Disc %s)' % (album, discnum + 1)})
else:
tracks.append({'track': tracknumber, 'title': title})
return tracks
def keyword_search(self, s):
if s.startswith(':a'):
artist_id = s[len(':a'):].strip()
try:
url = search_album('arid:' + solr_escape(artist_id),
limit=100,
own=True)
return parse_album_search(urlopen(url))
except RetrievalError as e:
msg = translate("MusicBrainz",
'<b>Error:</b> While retrieving %1: %2')
write_log(msg.arg(artist_id).arg(escape(e)))
raise
elif s.startswith(':b'):
r_id = s[len(':b'):].strip()
try:
return [self.retrieve(r_id)]
except RetrievalError as e:
msg = translate(
"MusicBrainz",
"<b>Error:</b> While retrieving Album ID %1 (%2)")
write_log(msg.arg(r_id).arg(escape(e)))
raise
else:
try:
params = parse_searchstring(s)
except RetrievalError as e:
return parse_album_search(urlopen(search_album(s, limit=100)))
if not params:
return
artist = params[0][0]
album = params[0][1]
return self.search(album, [artist], 100)
def number_tracks(tags, offset, numtracks, restartdirs, padlength, split_field='__dirpath', output_field='track', by_group=False):
"""Numbers the selected tracks sequentially in the range
between the indexes.
The first item of indices is the starting track.
The second item of indices is the number of tracks."""
if not split_field:
QMessageBox.critical(parent, translate("Autonumbering Wizard", 'Field empty...'),
translate("Autonumbering Wizard",
"The field specified to use as a directory splitter was invalid. "
"Please check your values."))
return
if not output_field:
QMessageBox.critical(parent, translate("Autonumbering Wizard", 'Field empty...'),
translate("Autonumbering Wizard",
"The output field specified was invalid. "
"Please check your values."))
return
if restartdirs: #Restart dir numbering
folders = OrderedDict()
for tag_index, tag in enumerate(tags):
key = findfunc.parsefunc(split_field, tag)
if not isinstance(key, basestring):
key = tag.stringtags().get(split_field)
if key in folders:
folders[key].append(tag_index)
else:
folders[key] = [tag_index]
else:
folders = {'fol': [i for i, t in enumerate(tags)]}
taglist = {}
for group_num, tags in enumerate(folders.itervalues()):
if numtracks == -2:
total = len(tags)
elif numtracks is -1:
total = None
elif numtracks >= 0:
total = numtracks
for trknum, index in enumerate(tags):
if by_group:
trknum = group_num + offset
else:
trknum += offset
text = _pad(trknum, total, padlength)
taglist[index] = {output_field: text}
taglist = [v for k,v in sorted(taglist.items(), key=lambda x: x[0])]
emit('writeselected', taglist)
def retrieve_cover_links(album_id, extra=None):
if extra is None:
url = "http://coverartarchive.org/release/" + album_id
else:
url = "http://coverartarchive.org/release/%s/%s" % (album_id, extra)
write_log(translate("MusicBrainz", "Retrieving cover: %s") % url)
try:
data, code = urlopen(url, code=True)
except RetrievalError, e:
if e.code == 404:
raise RetrievalError(translate("MusicBrainz",
"No images exist for this album."), 404)
raise e
def load_musiclib(parent=None):
try:
m = puddlestuff.musiclib.LibChooseDialog(parent)
except puddlestuff.musiclib.MusicLibError:
QMessageBox.critical(parent, translate("MusicLib", 'No libraries found'),
translate("MusicLib", "No supported music libraries were found. Most likely "
"the required dependencies aren't installed. Visit the "
"puddletag website, <a href='http://puddletag.sourceforge.net'>"
"puddletag.sourceforge.net</a> for more details."))
return
m.setModal(True)
obj.connect(m, SIGNAL('adddock'), emit_received('adddock'))
m.show()
def load_mp3tag_sources(dirpath=MTAG_SOURCE_DIR):
"Loads Mp3tag tag sources from dirpath and return the tag source classes."
files = glob.glob(os.path.join(dirpath, '*.src'))
classes = []
for f in files:
try:
idents, search, album = mp3tag.open_script(f)
classes.append(mp3tag.Mp3TagSource(idents, search, album))
except:
print translate("WebDB", "Couldn't load Mp3tag Tag Source %s") % f
traceback.print_exc()
continue
return classes
def retrieve_cover_links(album_id, extra=None):
if extra is None:
url = "http://coverartarchive.org/release/" + album_id
else:
url = "http://coverartarchive.org/release/%s/%s" % (album_id, extra)
write_log(translate("MusicBrainz", "Retrieving cover: %s") % url)
try:
data, code = urlopen(url, code=True)
except RetrievalError, e:
if e.code == 404:
raise RetrievalError(
translate("MusicBrainz", "No images exist for this album."),
404)
raise e
def editItem(self, row=None):
if row is None:
row = self.listbox.currentRow()
l = self.listbox.item
patterns = [unicode(l(z).text()) for z in range(self.listbox.count())]
(text, ok) = QInputDialog().getItem(self,
translate("WebDB", 'Edit sort option'),
translate("WebDB",
'Enter a sorting option (a comma-separated list of fields. '
'Eg. "artist, title")'), patterns, row)
if ok:
item = l(row)
item.setText(text)
self.listbox.setItemSelected(item, True)
def __init__(self):
super(MusicBrainz, self).__init__()
self.__lasttime = time.time()
self.__image_size = LARGE
self.__num_images = 0
self.__get_images = True
self.preferences = [
[translate('MusicBrainz', 'Retrieve Cover'), CHECKBOX, True],
[
translate('MusicBrainz', 'Cover size to retrieve:'), COMBO,
[[
translate('Amazon', 'Small'),
translate('Amazon', 'Large'),
translate('Amazon', 'Original Size')
], 1]
],
[
translate('MusicBrainz', 'Amount of images to retrieve:'),
COMBO,
[[
translate('MusicBrainz', 'Just the front cover'),
translate('MusicBrainz', 'All (can take a while)')
], 0]
],
]
def editItem(self, row=None):
if row is None:
row = self.listbox.currentRow()
l = self.listbox.item
patterns = [unicode(l(z).text()) for z in range(self.listbox.count())]
(text, ok) = QInputDialog().getItem(
self, translate("WebDB", 'Edit sort option'),
translate(
"WebDB",
'Enter a sorting option (a comma-separated list of fields. '
'Eg. "artist, title")'), patterns, row)
if ok:
item = l(row)
item.setText(text)
self.listbox.setItemSelected(item, True)
def addPattern(self):
l = self.listbox.item
patterns = [unicode(l(z).text()) for z in range(self.listbox.count())]
row = self.listbox.currentRow()
if row < 0:
row = 0
(text, ok) = QInputDialog().getItem(self, translate("WebDB",
'Add sort option'),
translate("WebDB",
'Enter a sorting option (a comma-separated list of fields. '
'Eg. "artist, title")'), patterns, row)
if ok:
self.listbox.clearSelection()
self.listbox.addItem(text)
self.listbox.setCurrentRow(self.listbox.count() - 1)
def retrieve_covers(cover_links, size=LARGE):
ret = []
for cover in cover_links['images']:
desc = cover.get('comment', u"")
cover_type = cover['types'][0]
if cover_type in mb_imagetypes:
cover_type = imagetypes[mb_imagetypes[cover_type]]
else:
cover_type = imagetypes[u"Other"]
if cover == SMALL:
image_url = cover['thumbnails']['small']
elif cover == LARGE:
image_url = cover['thumbnails']['large']
else:
image_url = cover['image']
write_log(translate("MusicBrainz", "Retrieving image %s") % image_url)
image_data = urlopen(image_url)
ret.append({
'desc': desc,
'mime': get_mime(image_data),
"imagetype": cover_type,
"data": image_data
})
return ret
def addPattern(self):
l = self.listbox.item
patterns = [unicode(l(z).text()) for z in range(self.listbox.count())]
row = self.listbox.currentRow()
if row < 0:
row = 0
(text, ok) = QInputDialog().getItem(
self, translate("WebDB", 'Add sort option'),
translate(
"WebDB",
'Enter a sorting option (a comma-separated list of fields. '
'Eg. "artist, title")'), patterns, row)
if ok:
self.listbox.clearSelection()
self.listbox.addItem(text)
self.listbox.setCurrentRow(self.listbox.count() - 1)
def keyword_search(keywords):
write_log(translate("Discogs",
'Retrieving search results for keywords: %s') % keywords)
keywords = re.sub('(\s+)', u'+', keywords)
url = search_url % keywords
text = urlopen(url)
return parse_search_json(json.loads(text))
def parse_search_json(data):
"""Parses the xml retrieved after entering a search query. Returns a
list of the albums found.
"""
results = data.get('results', []) + data.get('exactresults', [])
if not results:
return []
albums = []
for result in results:
info = result.copy()
try:
artist, album = result['title'].split(u' - ')
except ValueError:
album = result['title']
artist = u''
info = convert_dict(info, ALBUM_KEYS)
info['artist'] = artist
info['album'] = album
info['discogs_id'] = info['#r_id']
info['#extrainfo'] = (
translate('Discogs', '%s at Discogs.com') % info['album'],
SITE_URL + info['discogs_uri'])
albums.append(check_values(info))
return albums
def parse_album_xml(text, album=None):
"""Parses the retrieved xml for an album and get's the track listing."""
doc = minidom.parseString(text)
album_item = doc.getElementsByTagName('Item')[0]
try:
tracklist = album_item.getElementsByTagName('Tracks')[0]
except IndexError:
write_log(translate('Amazon',
'No tracks found in listing.'))
write_log(text)
return None
tracks = []
discs = [disc for disc in tracklist.childNodes if
not disc.nodeType == disc.TEXT_NODE]
if not (len(discs) > 1 and album):
album = None
for discnum, disc in enumerate(discs):
for track_node in disc.childNodes:
if track_node.nodeType == track_node.TEXT_NODE:
continue
title = get_text(track_node)
tracknumber = track_node.attributes['Number'].value
if album:
tracks.append({'track': tracknumber, 'title': title,
'album': '%s (Disc %s)' % (album, discnum + 1)})
else:
tracks.append({'track': tracknumber, 'title': title})
return tracks
def parse_search_xml(text):
"""Parses the xml retrieved after entering a search query. Returns a
list of the albums found.
"""
doc = minidom.parseString(text)
items = doc.getElementsByTagName('Item')
ret = []
for item in items:
info = {}
for attrib in item.getElementsByTagName('ItemAttributes'):
if not check_binding(attrib):
continue
for child in attrib.childNodes:
if child.nodeType == child.TEXT_NODE:
continue
if child.tagName in XMLKEYS:
text_node = child.firstChild
if text_node.nodeType == text_node.TEXT_NODE:
info[XMLKEYS[child.tagName]] = text_node.data
if not info:
continue
for key in IMAGEKEYS:
image_items = item.getElementsByTagName(key)
if image_items:
info[IMAGEKEYS[key]] = get_image_url(image_items[0])
info['#extrainfo'] = (translate('Amazon', '%s at Amazon.com') %
info.get('album', ''), get_site_url(item))
info['#asin'] = get_asin(item)
info['asin'] = info['#asin']
ret.append(info)
return ret
def setResults(self, retval):
self.searchButton.setEnabled(True)
if isinstance(retval, (basestring, QString)):
self.label.setText(retval)
else:
releases, files = retval
if releases:
self.label.setText(translate("WebDB", 'Searching complete.'))
else:
self.label.setText(
translate("WebDB", 'No matching albums were found.'))
if files and self.__autoRetrieve.isChecked():
self.listbox.setReleases(releases, files)
else:
self.listbox.setReleases(releases)
self.listbox.emit(SIGNAL('infoChanged'), '')
class FreeDB(object):
name = 'FreeDB'
tooltip = translate("FreeDB",
'<b>FreeDB does not support text-based searches.</b>')
group_by = ['album', None]
def __init__(self):
object.__init__(self)
self.__retrieved = {}
self.__lasttime = time.time()
def search(self, album, files):
if time.time() - self.__lasttime < 1000:
time.sleep(1)
if files:
results = search(files)
self.__lasttime = time.time()
if results:
results[0] = self.retrieve(results[0][0])
return results
else:
return []
def retrieve(self, info):
if time.time() - self.__lasttime < 1000:
time.sleep(1)
discid = info['#discid']
if discid in self.__retrieved:
return self.__retrieved[discid]
else:
info, tracks = retrieve_from_info(info)
self.__retrieved[info['#discid']] = [info, tracks]
return info, tracks
return info
def library(self):
dbpath = self.dbpath.text().toLocal8Bit()
try:
return QuodLibet(dbpath)
except (IOError, OSError), e:
raise MusicLibError(0, translate(
"QuodLibet", '%1 (%2)').arg(e.strerror).arg(e.filename))
def parse_search_xml(text):
"""Parses the xml retrieved after entering a search query. Returns a
list of the albums found.
"""
doc = minidom.parseString(text)
items = doc.getElementsByTagName('Item')
ret = []
for item in items:
info = {}
for attrib in item.getElementsByTagName('ItemAttributes'):
if not check_binding(attrib):
continue
for child in attrib.childNodes:
if child.nodeType == child.TEXT_NODE:
continue
if child.tagName in XMLKEYS:
text_node = child.firstChild
if text_node.nodeType == text_node.TEXT_NODE:
info[XMLKEYS[child.tagName]] = text_node.data
if not info:
continue
for key in IMAGEKEYS:
image_items = item.getElementsByTagName(key)
if image_items:
info[IMAGEKEYS[key]] = get_image_url(image_items[0])
info['#extrainfo'] = (translate('Amazon', '%s at Amazon.com') %
info.get('album', u''), get_site_url(item))
info['#asin'] = get_asin(item)
info['asin'] = info['#asin']
ret.append(info)
return ret
def submit():
try:
self.curSource.submit(files)
except SubmissionError, e:
traceback.print_exc()
return translate('WebDB',
'An error occured: %1').arg(unicode(e))
def load_musiclib(parent=None):
try:
m = puddlestuff.musiclib.LibChooseDialog(parent)
except puddlestuff.musiclib.MusicLibError:
QMessageBox.critical(
parent, translate("MusicLib", 'No libraries found'),
translate(
"MusicLib",
"No supported music libraries were found. Most likely "
"the required dependencies aren't installed. Visit the "
"puddletag website, <a href='http://puddletag.sourceforge.net'>"
"puddletag.sourceforge.net</a> for more details."))
return
m.setModal(True)
obj.connect(m, SIGNAL('adddock'), emit_received('adddock'))
m.show()
def select_db(self):
filedlg = QFileDialog()
filename = filedlg.getOpenFileName(
self, translate("QuodLibet", 'Select QuodLibet library file...'),
self.dbpath.text())
if filename:
self.dbpath.setText(filename)
def select_db(self):
filedlg = QFileDialog()
filename = filedlg.getOpenFileName(self,
translate("QuodLibet", 'Select QuodLibet library file...'),
self.dbpath.text())
if filename:
self.dbpath.setText(filename)
def search_replace(parent=None):
selectedfiles = status['selectedfiles']
audio, selected = status['firstselection']
try:
text = to_string(selected.values()[0])
except IndexError:
text = translate('Defaults', u'')
func = puddlestuff.findfunc.Function('replace')
func.args = [text, text, False, False]
func.tag = ['__selected']
dialog = actiondlg.CreateFunction(prevfunc=func,
parent=parent,
selected_fields=selected.keys(),
example=audio,
text=text)
dialog.connect(dialog, SIGNAL("valschanged"),
partial(run_func, selectedfiles))
dialog.setModal(True)
dialog.controls[0].combo.setFocus()
dialog.show()
def parse_search_json(data):
"""Parses the xml retrieved after entering a search query. Returns a
list of the albums found.
"""
results = data.get('results', []) + data.get('exactresults', [])
if not results:
return []
albums = []
for result in results:
info = result.copy()
try:
artist, album = result['title'].split(u' - ')
except ValueError:
album = result['title']
artist = u''
info = convert_dict(info, ALBUM_KEYS)
info['artist'] = artist
info['album'] = album
info['discogs_id'] = info['#r_id']
info['#extrainfo'] = (
translate('Discogs', '%s at Discogs.com') % info['album'],
SITE_URL + info['discogs_uri'])
albums.append(check_values(info))
return albums
class Discogs(object):
name = 'Discogs.com'
group_by = [u'album', u'artist']
tooltip = translate("Discogs", """<p><b>Discogs only support searching by release id</b></p>
<p>Enter the release id Eg. "1257896" to search.</p>""")
def __init__(self):
super(Discogs, self).__init__()
self._getcover = True
self.covertype = 1
self.preferences = [
[translate('Discogs', 'Retrieve Cover'), CHECKBOX, True],
[translate("Discogs", 'Cover size to retrieve'), COMBO,
[[translate("Discogs", 'Small'),
translate("Discogs", 'Large')], 1]],
[translate("Discogs", 'Field to use for discogs_id'), TEXT, R_ID],
[translate("Discogs", 'API Key (Stored as plain-text.'
'Leave empty to use default.)'), TEXT, ''],
]
def keyword_search(self, text):
try:
r_id = int(text.strip())
except (TypeError, ValueError):
raise RetrievalError(translate(
"Discogs", 'Discogs release id should be an integer.'))
try:
return [self.retrieve(r_id)]
except Exception, e:
raise RetrievalError(unicode(e))
def submit():
try:
self.curSource.submit(files)
except SubmissionError, e:
traceback.print_exc()
return translate('WebDB',
'An error occured: %1').arg(unicode(e))
def setResults(self, retval):
self.searchButton.setEnabled(True)
if isinstance(retval, (basestring, QString)):
self.label.setText(retval)
else:
releases, files = retval
if releases:
self.label.setText(translate("WebDB",
'Searching complete.'))
else:
self.label.setText(translate("WebDB",
'No matching albums were found.'))
if files and self.__autoRetrieve.isChecked():
self.listbox.setReleases(releases, files)
else:
self.listbox.setReleases(releases)
self.listbox.emit(SIGNAL('infoChanged'), '')
def parse_searchstring(text):
try:
text = [z.split(u';') for z in text.split(u'|') if z]
return [(z.strip(), v.strip()) for z, v in text]
except ValueError:
raise RetrievalError(translate('Tag Sources',
'<b>Error parsing artist/album combinations.</b>'))
return []
def keyword_search(keywords):
write_log(
translate("Discogs",
'Retrieving search results for keywords: %s') % keywords)
keywords = re.sub('(\s+)', u'+', keywords)
url = SEARCH_URL % keywords
text = urlopen(url)
return parse_search_json(json.loads(text))
def search(self, album, artists='', limit=40):
if time.time() - self.__lasttime < 1000:
time.sleep(1)
ret = []
check_matches = False
if isempty(artists):
artist = None
if len(artists) > 1:
artist = 'Various Artists'
elif artists:
if hasattr(artists, 'items'):
artist = list(artists.keys())[0]
else:
artist = artists[0]
if not album and not artist:
raise RetrievalError('Album or Artist required.')
write_log('Searching for %s' % album)
if hasattr(artists, "items"):
album_id = find_id(chain(*list(artists.values())),
"mbrainz_album_id")
if album_id:
try:
write_log(
translate("MusicBrainz",
"Found album id %s in tracks. Retrieving") %
album_id)
return [retrieve_album(album_id)]
except RetrievalError as e:
msg = translate(
"MusicBrainz",
"<b>Error:</b> While retrieving Album ID %1 (%2)")
write_log(msg.arg(album_id).arg(escape(e)))
try:
xml = urlopen(search_album(album, artist, limit))
except urllib.error.URLError as e:
write_log('Error: While retrieving search page %s' % str(e))
raise RetrievalError(str(e))
write_log('Retrieved search results.')
self.__lasttime = time.time()
return parse_album_search(xml)
def parse_searchstring(text):
try:
text = [z.split(u';') for z in text.split(u'|') if z]
return [(z.strip(), v.strip()) for z, v in text]
except ValueError:
raise RetrievalError(
translate('Tag Sources',
'<b>Error parsing artist/album combinations.</b>'))
return []
def library(self):
dbpath = self.dbpath.text().toLocal8Bit()
try:
return QuodLibet(dbpath)
except (IOError, OSError), e:
raise MusicLibError(
0,
translate("QuodLibet",
'%1 (%2)').arg(e.strerror).arg(e.filename))
class MusicBrainz(object):
name = u'MusicBrainz'
group_by = [u'album', 'artist']
def __init__(self):
super(MusicBrainz, self).__init__()
self.__lasttime = time.time()
self.__image_size = LARGE
self.__num_images = 0
self.__get_images = True
self.preferences = [
[translate('MusicBrainz', 'Retrieve Cover'), CHECKBOX, True],
[
translate('MusicBrainz', 'Cover size to retrieve:'), COMBO,
[[
translate('Amazon', 'Small'),
translate('Amazon', 'Large'),
translate('Amazon', 'Original Size')
], 1]
],
[
translate('MusicBrainz', 'Amount of images to retrieve:'),
COMBO,
[[
translate('MusicBrainz', 'Just the front cover'),
translate('MusicBrainz', 'All (can take a while)')
], 0]
],
]
def keyword_search(self, s):
if s.startswith(u':a'):
artist_id = s[len(':a'):].strip()
try:
url = search_album('arid:' +
solr_escape(artist_id.encode('utf8')),
limit=100,
own=True)
return parse_album_search(urlopen(url))
except RetrievalError, e:
msg = translate("MusicBrainz",
'<b>Error:</b> While retrieving %1: %2')
write_log(msg.arg(artist_id).arg(escape(e)))
raise
elif s.startswith(u':b'):
r_id = s[len(u':b'):].strip()
try:
return [self.retrieve(r_id)]
except RetrievalError, e:
msg = translate(
"MusicBrainz",
"<b>Error:</b> While retrieving Album ID %1 (%2)")
write_log(msg.arg(r_id).arg(escape(e)))
raise
def search():
try:
ret = []
if text:
return self.curSource.keyword_search(text), None
else:
return tag_source_search(self.curSource, group, files)
except RetrievalError, e:
return translate('WebDB',
'An error occured: %1').arg(unicode(e))
def search():
try:
ret = []
if text:
return self.curSource.keyword_search(text), None
else:
return tag_source_search(self.curSource, group, files)
except RetrievalError, e:
return translate('WebDB',
'An error occured: %1').arg(unicode(e))
def check_copy_data(data):
#0 = yes
#1 = no
#2 = no images
if len(data) > 5242880:
msgbox = QMessageBox()
msgbox.setText(
translate(
"Messages", "That's a large amount of data to copy.\n"
"It may cause your system to lock up.\n\n"
"Do you want to go ahead?"))
msgbox.setIcon(QMessageBox.Question)
msgbox.addButton(translate("Defaults", "&Yes"), QMessageBox.YesRole)
msgbox.addButton(translate("Defaults", "No"), QMessageBox.NoRole)
msgbox.addButton(translate("Messages", "Copy without images."),
QMessageBox.ApplyRole)
return msgbox.exec_()
else:
return 0
def run_format_func(funcname,
arguments,
m_audio,
s_audio=None,
extra=None,
state=None):
'''Runs the function function using the arguments specified from pudlestuff.function.
Arguments:
funcname -- String with the function name. Looked up using the
dictionary pudlestuff.function.functions
arguments -- List of arguments to pass to the function. Patterns
should not be evaluated. They'll be evaluated here.
m_audio -- Audio file containg multiple multiple values per key.
Eg. {'artist': [u'Artist1': 'Artist2']}
Keyword Arguments
s_audio -- Same as m_audio, but containing strings as values.
Generated on each run unless also passed.
extra -- Dictionary containing extra fields that are to be used
when matching fields.
state -- Dictionary that hold state. Like {'__count': 15}.
Used by some functions in puddlestuff.functions
'''
#Get function
try:
if isinstance(funcname, basestring):
func = functions[funcname]
else:
func = funcname
except KeyError:
raise ParseError(
SYNTAX_ERROR.arg(funcname).arg(
translate('Defaults', 'function does not exist.')))
extra = {} if extra is None else extra
s_audio = stringtags(m_audio) if s_audio is None else s_audio
reserved = {'tags': s_audio, 'm_tags': m_audio, 'state': state}
dicts = [s_audio, extra, state]
topass = get_function_arguments(funcname, func, arguments, reserved, True,
*dicts)
try:
ret = func(**topass)
if ret is None:
return u''
return ret
except TypeError, e:
message = SYNTAX_ERROR.arg(funcname)
message = message.arg(arglen_error(e, topass, func, False))
raise ParseError(message)
def keyword_search(self, text):
try:
r_id = int(text.strip())
except (TypeError, ValueError):
raise RetrievalError(translate(
"Discogs", 'Discogs release id should be an integer.'))
try:
return [self.retrieve(r_id)]
except Exception, e:
raise RetrievalError(unicode(e))
def display_tag(tag):
"""Used to display tags in in a human parseable format."""
tag = dict((k, v) for k, v in tag.iteritems()
if not k.startswith('#') and not isempty(v))
if not tag:
return translate("WebDB", "<b>Nothing to display.</b>")
fmt = u"<b>%s</b>: %s<br />"
text = pprint_tag(tag, fmt, True)
if text.endswith(u'<br />'):
text = text[:-len(u'<br />')]
return text
def keyword_search(self, s):
if s.startswith(u':a'):
artist_id = s[len(':a'):].strip()
try:
url = search_album('arid:' +
solr_escape(artist_id.encode('utf8')), limit=100, own=True)
return parse_album_search(urlopen(url))
except RetrievalError, e:
msg = translate("MusicBrainz",
'<b>Error:</b> While retrieving %1: %2')
write_log(msg.arg(artist_id).arg(escape(e)))
raise
def keyword_search(self, text):
try:
r_id = int(text.strip())
except (TypeError, ValueError):
raise RetrievalError(translate(
"Discogs", 'Discogs release id should be an integer.'))
try:
return [self.retrieve(r_id)]
except Exception, e:
raise RetrievalError(unicode(e))
def display_tag(tag):
"""Used to display tags in in a human parseable format."""
tag = dict((k,v) for k,v in tag.iteritems() if
not k.startswith('#') and not isempty(v))
if not tag:
return translate("WebDB", "<b>Nothing to display.</b>")
fmt = u"<b>%s</b>: %s<br />"
text = pprint_tag(tag, fmt, True)
if text.endswith(u'<br />'):
text = text[:-len(u'<br />')]
return text
def check_copy_data(data):
#0 = yes
#1 = no
#2 = no images
if len(data) > 5242880:
msgbox = QMessageBox()
msgbox.setText(translate("Messages",
"That's a large amount of data to copy.\n"
"It may cause your system to lock up.\n\n"
"Do you want to go ahead?"))
msgbox.setIcon(QMessageBox.Question)
msgbox.addButton(translate("Defaults", "&Yes"),
QMessageBox.YesRole)
msgbox.addButton(translate("Defaults", "No"),
QMessageBox.NoRole)
msgbox.addButton(translate("Messages", "Copy without images."),
QMessageBox.ApplyRole)
return msgbox.exec_()
else:
return 0
def retrieve_cover_links(album_id, extra=None):
if extra is None:
url = "http://coverartarchive.org/release/" + album_id
else:
url = "http://coverartarchive.org/release/%s/%s" % (album_id, extra)
write_log(translate("MusicBrainz", "Retrieving cover: %s") % url)
try:
data, code = urlopen(url, code=True)
except RetrievalError as e:
if e.code == 404:
raise RetrievalError(
translate("MusicBrainz", "No images exist for this album."),
404)
raise e
if code == 200:
if extra is None:
return json.loads(data)
else:
return data
elif code == 400:
raise RetrievalError(translate("MusicBrainz", "Invalid UUID"))
elif code in (405, 406):
raise RetrievalError(translate("MusicBrainz", "Invalid query sent."))
elif code == 503:
raise RetrievalError(
translate("MusicBrainz", "You have exceeded your rate limit."))
elif code == 404:
raise RetrievalError(translate("MusicBrainz", "Image does not exist."))
def __init__(self, parent=None):
QWidget.__init__(self, parent)
self.dbpath = DirLineEdit(os.path.join(HOMEDIR, u".quodlibet/songs"))
self.configpath = DirLineEdit(os.path.join(HOMEDIR, u".quodlibet/config"))
vbox = QVBoxLayout()
def label(text, control):
l = QLabel(text)
l.setBuddy(control)
return l
vbox.addWidget(label(translate("QuodLibet", '&Library Path'), self.dbpath))
hbox = QHBoxLayout()
select_db = QPushButton(translate("QuodLibet", "..."))
self.connect(select_db, SIGNAL('clicked()'), self.select_db)
hbox.addWidget(self.dbpath)
hbox.addWidget(select_db)
vbox.addLayout(hbox)
vbox.addStretch(1)
self.setLayout(vbox)
def search(self, album, artists):
if len(artists) > 1:
artist = u'Various Artists'
else:
artist = [z for z in artists][0]
if hasattr(artists, 'values'):
write_log(
translate("Discogs", 'Checking tracks for Discogs Album ID.'))
tracks = []
[tracks.extend(z) for z in artists.values()]
album_id = find_id(tracks, R_ID)
if not album_id:
write_log(
translate("Discogs", 'No Discogs ID found in tracks.'))
else:
write_log(
translate("Discogs", 'Found Discogs ID: %s') % album_id)
return [self.retrieve(album_id)]
return []
def search(self, album, artists):
if len(artists) > 1:
artist = u'Various Artists'
else:
artist = [z for z in artists][0]
if hasattr(artists, 'values'):
write_log(
translate("Discogs", 'Checking tracks for Discogs Album ID.'))
tracks = []
[tracks.extend(z) for z in artists.values()]
album_id = find_id(tracks, R_ID)
if not album_id:
write_log(
translate("Discogs", 'No Discogs ID found in tracks.'))
else:
write_log(
translate("Discogs", 'Found Discogs ID: %s') % album_id)
return [self.retrieve(album_id)]
return []
def load_mp3tag_sources(dirpath=MTAG_SOURCE_DIR):
"Loads Mp3tag tag sources from dirpath and return the tag source classes."
files = glob.glob(os.path.join(dirpath, '*.src'))
classes = []
for f in files:
try:
idents, search, album = mp3tag.open_script(f)
classes.append(mp3tag.Mp3TagSource(idents, search, album))
except:
logging.exception(
translate("WebDB", "Couldn't load Mp3tag Tag Source %s") % f)
continue
return classes
def retrieve_album(info, image=LARGEIMAGE, rls_type=None):
"""Retrieves album from the information in info.
image must be either one of image_types or None.
If None, no image is retrieved."""
if isinstance(info, (int, long)):
r_id = unicode(info)
info = {}
write_log(
translate("Discogs", 'Retrieving using Release ID: %s') % r_id)
rls_type = u'release'
elif isinstance(info, basestring):
r_id = info
info = {}
write_log(
translate("Discogs", 'Retrieving using Release ID: %s') % r_id)
rls_type = u'release'
else:
if rls_type is None and '#release_type' in info:
rls_type = info['#release_type']
r_id = info['#r_id']
write_log(
translate("Discogs", 'Retrieving album %s') % (info['album']))
site_url = SITE_MASTER_URL if rls_type == MASTER else SITE_RELEASE_URL
site_url += r_id.encode('utf8')
url = master_url % r_id if rls_type == MASTER else release_url % r_id
x = urlopen(url)
ret = parse_album_json(json.loads(x))
info = deepcopy(info)
info.update(ret[0])
if image in image_types and '#cover-url' in info:
data = []
for large, small in info['#cover-url']:
if image == LARGEIMAGE and large:
write_log(
translate("Discogs", 'Retrieving cover: %s') % large)
try:
data.append({DATA: urlopen(large)})
except RetrievalError, e:
write_log(translate('Discogs',
u'Error retrieving image:') + unicode(e))
else:
write_log(
translate("Discogs", 'Retrieving cover: %s') % small)
try:
data.append({DATA: urlopen(small)})
except RetrievalError, e:
write_log(translate('Discogs',
u'Error retrieving image:') + unicode(e))
def keyword_search(keywords):
write_log(translate('Amazon',
'Retrieving search results for keywords: %s') % keywords)
query_pairs = {
"Operation": u"ItemSearch",
'SearchIndex': u'Music',
"ResponseGroup":u"ItemAttributes,Images",
"Service":u"AWSECommerceService",
'ItemPage': u'1',
'Keywords': keywords,
'AssociateTag': u'puddletag-20'}
url = create_aws_url(access_key, secret_key, query_pairs)
xml = urlopen(url)
return parse_search_xml(xml)
def in_lib(state, parent=None):
if state:
if not status['library']:
QMessageBox.critical(parent, translate("MusicLib", 'No libraries found'),
translate("MusicLib", "Load a lib first."))
return False
files = status['allfiles']
lib = status['library']
libartists = status['library'].artists
to_highlight = []
for artist, tracks in split_by_tag(files, 'artist', None).items():
if artist in libartists:
libtracks = lib.get_tracks('artist', artist)
titles = [track['title'][0].lower()
if 'title' in track else '' for track in libtracks]
for track in tracks:
if track.get('title', [u''])[0].lower() in titles:
to_highlight.append(track)
emit('highlight', to_highlight)
return True
else:
emit('highlight', [])
return False
def run_format_func(funcname, arguments, m_audio, s_audio=None, extra=None,
state=None):
'''Runs the function function using the arguments specified from pudlestuff.function.
Arguments:
funcname -- String with the function name. Looked up using the
dictionary pudlestuff.function.functions
arguments -- List of arguments to pass to the function. Patterns
should not be evaluated. They'll be evaluated here.
m_audio -- Audio file containg multiple multiple values per key.
Eg. {'artist': [u'Artist1': 'Artist2']}
Keyword Arguments
s_audio -- Same as m_audio, but containing strings as values.
Generated on each run unless also passed.
extra -- Dictionary containing extra fields that are to be used
when matching fields.
state -- Dictionary that hold state. Like {'__count': 15}.
Used by some functions in puddlestuff.functions
'''
#Get function
try:
if isinstance(funcname, basestring):
func = functions[funcname]
else:
func = funcname
except KeyError:
raise ParseError(SYNTAX_ERROR.arg(funcname).arg(
translate('Defaults', 'function does not exist.')))
extra = {} if extra is None else extra
s_audio = stringtags(m_audio) if s_audio is None else s_audio
reserved = {'tags': s_audio, 'm_tags': m_audio, 'state': state}
dicts = [s_audio, extra, state]
topass = get_function_arguments(funcname, func, arguments,
reserved, True, *dicts)
try:
ret = func(**topass)
if ret is None:
return u''
return ret
except TypeError, e:
message = SYNTAX_ERROR.arg(funcname)
message = message.arg(arglen_error(e, topass, func, False))
raise ParseError(message)
