def send_feedback(dsn, event_id, name, email, comment, timeout):
"""Send feedback, blocking.
Args:
dsn (str): The DSN
event_id (str): The event ID this feedback should be attached to
name (text_type): The user name
email (text_type): The user email
comment (text_type): The feedback text
timeout (float): The timeout for this request
Raises:
SentryError: In case of timeout or other errors
"""
name = text_type(name).encode("utf-8")
email = text_type(email).encode("utf-8")
comment = text_type(comment).encode("utf-8")
data = urlencode([('name', name), ('email', email), ('comments', comment)])
if not isinstance(data, bytes):
# py3
data = data.encode("utf-8")
headers = {"Referer": "https://quodlibet.github.io"}
params = urlencode([("dsn", dsn), ("eventId", event_id)])
try:
req = Request("https://sentry.io/api/embed/error-page/?" + params,
data=data,
headers=headers)
urlopen(req, timeout=timeout).close()
except EnvironmentError as e:
raise SentryError(e)
def send_feedback(dsn, event_id, name, email, comment, timeout):
"""Send feedback, blocking.
Args:
dsn (str): The DSN
event_id (str): The event ID this feedback should be attached to
name (str): The user name
email (str): The user email
comment (str): The feedback text
timeout (float): The timeout for this request
Raises:
SentryError: In case of timeout or other errors
"""
name = str(name).encode("utf-8")
email = str(email).encode("utf-8")
comment = str(comment).encode("utf-8")
data = urlencode(
[('name', name), ('email', email), ('comments', comment)])
if not isinstance(data, bytes):
# py3
data = data.encode("utf-8")
headers = {"Referer": "https://quodlibet.github.io"}
params = urlencode([("dsn", dsn), ("eventId", event_id)])
try:
req = Request(
"https://sentry.io/api/embed/error-page/?" + params,
data=data, headers=headers)
urlopen(req, timeout=timeout).close()
except EnvironmentError as e:
raise SentryError(e)
def get_url(url, post=None, get=None):
post_params = urlencode(post or {})
get_params = urlencode(get or {})
if get:
get_params = '?' + get_params
# add post, get data and headers
url = '%s%s' % (url, get_params)
if post_params:
request = Request(url, post_params)
else:
request = Request(url)
# for discogs
request.add_header('Accept-Encoding', 'gzip')
request.add_header('User-Agent', USER_AGENT)
url_sock = urlopen(request)
enc = get_encoding_from_socket(url_sock)
# unzip the response if needed
data = url_sock.read()
if url_sock.headers.get("content-encoding", "") == "gzip":
data = gzip.GzipFile(fileobj=cBytesIO(data)).read()
url_sock.close()
content_type = url_sock.headers.get('Content-Type', '').split(';', 1)[0]
domain = re.compile('\w+://([^/]+)/').search(url).groups(0)[0]
print_d("Got %s data from %s" % (content_type, domain))
return (data if content_type.startswith('image')
else data.decode(enc))
def get_url(url, post={}, get={}):
post_params = urlencode(post)
get_params = urlencode(get)
if get:
get_params = "?" + get_params
# add post, get data and headers
url = "%s%s" % (url, get_params)
if post_params:
request = Request(url, post_params)
else:
request = Request(url)
# for discogs
request.add_header("Accept-Encoding", "gzip")
request.add_header("User-Agent", USER_AGENT)
url_sock = urlopen(request)
enc = get_encoding_from_socket(url_sock)
# unzip the response if needed
data = url_sock.read()
if url_sock.headers.get("content-encoding", "") == "gzip":
data = gzip.GzipFile(fileobj=cBytesIO(data)).read()
url_sock.close()
return data, enc
def urlopen_hack(**kwargs):
# There is no way to make raven use the system cert store. This makes
# it use the standard urlopen instead.
url = kwargs["url"]
data = kwargs["data"]
timeout = kwargs["timeout"]
return urlopen(url, data, timeout)
def urlopen_hack(**kwargs):
# There is no way to make raven use the system cert store. This makes
# it use the standard urlopen instead.
url = kwargs["url"]
data = kwargs["data"]
timeout = kwargs["timeout"]
return urlopen(url, data, timeout)
def get_url(url, post=None, get=None):
post_params = urlencode(post or {})
get_params = urlencode(get or {})
if get:
get_params = '?' + get_params
# add post, get data and headers
url = '%s%s' % (url, get_params)
if post_params:
request = Request(url, post_params)
else:
request = Request(url)
# for discogs
request.add_header('Accept-Encoding', 'gzip')
request.add_header('User-Agent', USER_AGENT)
url_sock = urlopen(request)
enc = get_encoding_from_socket(url_sock)
# unzip the response if needed
data = url_sock.read()
if url_sock.headers.get("content-encoding", "") == "gzip":
data = gzip.GzipFile(fileobj=BytesIO(data)).read()
url_sock.close()
content_type = url_sock.headers.get('Content-Type', '').split(';', 1)[0]
domain = re.compile(r'\w+://([^/]+)/').search(url).groups(0)[0]
print_d("Got %s data from %s" % (content_type, domain))
return (data if content_type.startswith('image') else data.decode(enc))
def test_dir_for(self):
# uri format of files added via drag and drop or add button
# (Gtk.SelectionData.get_uris()): file:///path/to/file.ext
url_based_file: addinfourl = urlopen("file:///" +
self.PLAYLIST_FILE_PATH)
reader_based_file: BufferedReader = open(self.PLAYLIST_FILE_PATH, "rb")
try:
dir_of_url_based_file: str = _dir_for(url_based_file)
self.assertEqual(
os.path.realpath(os.path.dirname(self.PLAYLIST_FILE_PATH)),
os.path.realpath(dir_of_url_based_file),
"determining the directory of url based files"
" should result in a correct path")
dir_of_reader_based_file: str = _dir_for(reader_based_file)
self.assertEqual(
os.path.realpath(os.path.dirname(self.PLAYLIST_FILE_PATH)),
os.path.realpath(dir_of_reader_based_file, ),
"determining the directory of reader based files"
" should result in a correct path")
finally:
url_based_file.close()
reader_based_file.close()
def __search(self, song, buffer, refresh, add):
artist = song.comma("artist")
title = song.comma("title")
try:
sock = urlopen(
"http://lyricwiki.org/api.php?"
"client=QuodLibet&func=getSong&artist=%s&song=%s&fmt=text" % (
quote(artist.encode('utf-8')),
quote(title.encode('utf-8'))))
text = sock.read()
except Exception as err:
encoding = util.get_locale_encoding()
try:
err = err.strerror.decode(encoding, 'replace')
except:
err = _("Unable to download lyrics.")
GLib.idle_add(buffer.set_text, err)
return
sock.close()
if text == 'Not found':
GLib.idle_add(
buffer.set_text, _("No lyrics found for this song."))
return
else:
GLib.idle_add(buffer.set_text, text)
GLib.idle_add(refresh.set_sensitive, True)
def _do_search(self, song):
"""Returns a URL or None"""
fetch_url = create_api_search_url(song)
try:
response = urlopen(fetch_url, timeout=self.TIMEOUT)
except EnvironmentError:
return
try:
xml = response.read()
except IOError:
return
try:
dom = minidom.parseString(xml)
except Exception:
# who knows...
return
page_id_nodes = dom.getElementsByTagName("page_id")
if not page_id_nodes or not page_id_nodes[0].hasChildNodes():
return
url_nodes = dom.getElementsByTagName("url")
try:
page = url_nodes[0].firstChild.data
except (IndexError, AttributeError):
return
else:
return page
def _do_search(self, song):
"""Returns a URL or None"""
fetch_url = create_api_search_url(song)
try:
response = urlopen(fetch_url, timeout=self.TIMEOUT)
except EnvironmentError:
return
try:
xml = response.read()
except IOError:
return
try:
dom = minidom.parseString(xml)
except Exception:
# who knows...
return
page_id_nodes = dom.getElementsByTagName("page_id")
if not page_id_nodes or not page_id_nodes[0].hasChildNodes():
return
url_nodes = dom.getElementsByTagName("url")
try:
page = url_nodes[0].firstChild.data
except (IndexError, AttributeError):
return
else:
return page
def get_size_of_url(url):
request = Request(url)
request.add_header('Accept-Encoding', 'gzip')
request.add_header('User-Agent', USER_AGENT)
url_sock = urlopen(request)
size = url_sock.headers.get('content-length')
url_sock.close()
return format_size(int(size)) if size else ''
def get_size_of_url(url):
request = Request(url)
request.add_header('Accept-Encoding', 'gzip')
request.add_header('User-Agent', USER_AGENT)
url_sock = urlopen(request)
size = url_sock.headers.get('content-length')
url_sock.close()
return format_size(int(size)) if size else ''
def get_size_of_url(url):
request = Request(url)
request.add_header("Accept-Encoding", "gzip")
request.add_header("User-Agent", USER_AGENT)
url_sock = urlopen(request)
size = url_sock.headers.get("content-length")
url_sock.close()
return format_size(int(size)) if size else ""
def __drag_data_received(self, view, ctx, x, y, sel, tid, etime, library):
# TreeModelSort doesn't support GtkTreeDragDestDrop.
view.emit_stop_by_name('drag-data-received')
model = view.get_model()
if tid == DND_QL:
filenames = qltk.selection_get_filenames(sel)
songs = list(filter(None, [library.get(f) for f in filenames]))
if not songs:
Gtk.drag_finish(ctx, False, False, etime)
return
try:
path, pos = view.get_dest_row_at_pos(x, y)
except TypeError:
playlist = FileBackedPlaylist.from_songs(PLAYLISTS, songs,
library)
GLib.idle_add(self._select_playlist, playlist)
else:
playlist = model[path][0]
playlist.extend(songs)
self.changed(playlist)
Gtk.drag_finish(ctx, True, False, etime)
# Cause a refresh to the dragged-to playlist if it is selected
# so that the dragged (duplicate) track(s) appears
if playlist is self.__get_name_of_current_selected_playlist():
model, plist_iter = self.__selected_playlists()
songlist = qltk.get_top_parent(self).songlist
self.activate(resort=not songlist.is_sorted())
else:
if tid == DND_URI_LIST:
uri = sel.get_uris()[0]
name = os.path.basename(uri)
elif tid == DND_MOZ_URL:
data = sel.get_data()
uri, name = data.decode('utf16', 'replace').split('\n')
else:
Gtk.drag_finish(ctx, False, False, etime)
return
name = _name_for(name or os.path.basename(uri))
try:
sock = urlopen(uri)
if uri.lower().endswith('.pls'):
playlist = parse_pls(sock, name, library=library)
elif (uri.lower().endswith('.m3u') or
uri.lower().endswith('.m3u8')):
playlist = parse_m3u(sock, name, library=library)
else:
raise IOError
library.add(playlist.songs)
self.changed(playlist)
Gtk.drag_finish(ctx, True, False, etime)
except IOError:
Gtk.drag_finish(ctx, False, False, etime)
qltk.ErrorMessage(
qltk.get_top_parent(self),
_("Unable to import playlist"),
_("Quod Libet can only import playlists in the M3U/M3U8 "
"and PLS formats.")).run()
def __drag_data_received(self, view, ctx, x, y, sel, tid, etime, library):
# TreeModelSort doesn't support GtkTreeDragDestDrop.
view.emit_stop_by_name('drag-data-received')
model = view.get_model()
if tid == DND_QL:
filenames = qltk.selection_get_filenames(sel)
songs = list(filter(None, [library.get(f) for f in filenames]))
if not songs:
Gtk.drag_finish(ctx, False, False, etime)
return
try:
path, pos = view.get_dest_row_at_pos(x, y)
except TypeError:
playlist = XSPFBackedPlaylist.from_songs(PLAYLISTS, songs,
library)
GLib.idle_add(self._select_playlist, playlist)
else:
playlist = model[path][0]
playlist.extend(songs)
self.changed(playlist)
Gtk.drag_finish(ctx, True, False, etime)
# Cause a refresh to the dragged-to playlist if it is selected
# so that the dragged (duplicate) track(s) appears
if playlist is self.__get_name_of_current_selected_playlist():
model, plist_iter = self.__selected_playlists()
songlist = qltk.get_top_parent(self).songlist
self.activate(resort=not songlist.is_sorted())
else:
if tid == DND_URI_LIST:
uri = sel.get_uris()[0]
name = os.path.basename(uri)
elif tid == DND_MOZ_URL:
data = sel.get_data()
uri, name = data.decode('utf16', 'replace').split('\n')
else:
Gtk.drag_finish(ctx, False, False, etime)
return
name = _name_for(name or os.path.basename(uri))
try:
sock = urlopen(uri)
if uri.lower().endswith('.pls'):
playlist = parse_pls(sock, name, library=library)
elif (uri.lower().endswith('.m3u') or
uri.lower().endswith('.m3u8')):
playlist = parse_m3u(sock, name, library=library)
else:
raise IOError
library.add(playlist.songs)
self.changed(playlist)
Gtk.drag_finish(ctx, True, False, etime)
except IOError:
Gtk.drag_finish(ctx, False, False, etime)
qltk.ErrorMessage(
qltk.get_top_parent(self),
_("Unable to import playlist"),
_("Quod Libet can only import playlists in the M3U/M3U8 "
"and PLS formats.")).run()
def __drag_data_received(self, view, ctx, x, y, sel, tid, etime, library):
# TreeModelSort doesn't support GtkTreeDragDestDrop.
view.emit_stop_by_name('drag-data-received')
model = view.get_model()
if tid == DND_QL:
filenames = qltk.selection_get_filenames(sel)
songs = filter(None, map(library.get, filenames))
if not songs:
Gtk.drag_finish(ctx, False, False, etime)
return
try:
path, pos = view.get_dest_row_at_pos(x, y)
except TypeError:
playlist = FileBackedPlaylist.from_songs(PLAYLISTS, songs,
library)
GLib.idle_add(self._select_playlist, playlist)
else:
playlist = model[path][0]
playlist.extend(songs)
self.changed(playlist)
Gtk.drag_finish(ctx, True, False, etime)
else:
if tid == DND_URI_LIST:
uri = sel.get_uris()[0]
name = os.path.basename(uri)
elif tid == DND_MOZ_URL:
data = sel.get_data()
uri, name = data.decode('utf16', 'replace').split('\n')
else:
Gtk.drag_finish(ctx, False, False, etime)
return
name = name or os.path.basename(uri) or _("New Playlist")
uri = uri.encode('utf-8')
try:
sock = urlopen(uri)
f = NamedTemporaryFile()
f.write(sock.read())
f.flush()
if uri.lower().endswith('.pls'):
playlist = parse_pls(f.name, library=library)
elif uri.lower().endswith('.m3u'):
playlist = parse_m3u(f.name, library=library)
else:
raise IOError
library.add_filename(playlist)
if name:
playlist.rename(name)
self.changed(playlist)
Gtk.drag_finish(ctx, True, False, etime)
except IOError:
Gtk.drag_finish(ctx, False, False, etime)
qltk.ErrorMessage(
qltk.get_top_parent(self),
_("Unable to import playlist"),
_("Quod Libet can only import playlists in the M3U "
"and PLS formats.")).run()
def __drag_data_received(self, view, ctx, x, y, sel, tid, etime, library):
# TreeModelSort doesn't support GtkTreeDragDestDrop.
view.emit_stop_by_name('drag-data-received')
model = view.get_model()
if tid == DND_QL:
filenames = qltk.selection_get_filenames(sel)
songs = listfilter(None, [library.get(f) for f in filenames])
if not songs:
Gtk.drag_finish(ctx, False, False, etime)
return
try:
path, pos = view.get_dest_row_at_pos(x, y)
except TypeError:
playlist = FileBackedPlaylist.from_songs(PLAYLISTS, songs,
library)
GLib.idle_add(self._select_playlist, playlist)
else:
playlist = model[path][0]
playlist.extend(songs)
self.changed(playlist)
Gtk.drag_finish(ctx, True, False, etime)
else:
if tid == DND_URI_LIST:
uri = sel.get_uris()[0]
name = os.path.basename(uri)
elif tid == DND_MOZ_URL:
data = sel.get_data()
uri, name = data.decode('utf16', 'replace').split('\n')
else:
Gtk.drag_finish(ctx, False, False, etime)
return
name = name or os.path.basename(uri) or _("New Playlist")
uri = uri.encode('utf-8')
try:
sock = urlopen(uri)
f = NamedTemporaryFile()
f.write(sock.read())
f.flush()
if uri.lower().endswith('.pls'):
playlist = parse_pls(f.name, library=library)
elif uri.lower().endswith('.m3u'):
playlist = parse_m3u(f.name, library=library)
else:
raise IOError
library.add_filename(playlist)
if name:
playlist.rename(name)
self.changed(playlist)
Gtk.drag_finish(ctx, True, False, etime)
except IOError:
Gtk.drag_finish(ctx, False, False, etime)
qltk.ErrorMessage(
qltk.get_top_parent(self),
_("Unable to import playlist"),
_("Quod Libet can only import playlists in the M3U "
"and PLS formats.")).run()
def send_handshake(self, show_dialog=False):
# construct url
stamp = int(time.time())
auth = md5(self.password.encode("utf-8") +
str(stamp).encode("utf-8")).hexdigest()
url = "%s/?hs=true&p=%s&c=%s&v=%s&u=%s&a=%s&t=%d" % (
self.base_url, self.PROTOCOL_VERSION, self.CLIENT,
self.CLIENT_VERSION, self.username, auth, stamp)
print_d("Sending handshake to service.")
try:
resp = urlopen(url)
except UrllibError:
if show_dialog:
self.quick_dialog(
_("Could not contact service '%s'.") %
util.escape(self.base_url), Gtk.MessageType.ERROR)
else:
print_d("Could not contact service. Queueing submissions.")
return False
except ValueError:
self.quick_dialog(_("Authentication failed: invalid URL."),
Gtk.MessageType.ERROR)
self.broken = True
return False
# check response
lines = resp.read().decode("utf-8", "ignore").rstrip().split("\n")
status = lines.pop(0)
print_d("Handshake status: %s" % status)
if status == "OK":
self.session_id, self.nowplaying_url, self.submit_url = lines
self.handshake_sent = True
print_d("Session ID: %s, NP URL: %s, Submit URL: %s" %
(self.session_id, self.nowplaying_url, self.submit_url))
return True
elif status == "BADAUTH":
self.quick_dialog(
_("Authentication failed: Invalid username '%s' "
"or bad password.") % util.escape(self.username),
Gtk.MessageType.ERROR)
self.broken = True
elif status == "BANNED":
self.quick_dialog(_("Client is banned. Contact the author."),
Gtk.MessageType.ERROR)
self.broken = True
elif status == "BADTIME":
self.quick_dialog(
_("Wrong system time. Submissions may fail "
"until it is corrected."), Gtk.MessageType.ERROR)
else: # "FAILED"
self.quick_dialog(util.escape(status), Gtk.MessageType.ERROR)
self.changed()
return False
def send_handshake(self, show_dialog=False):
# construct url
stamp = int(time.time())
auth = md5(self.password.encode("utf-8") +
str(stamp).encode("utf-8")).hexdigest()
url = "%s/?hs=true&p=%s&c=%s&v=%s&u=%s&a=%s&t=%d" % (
self.base_url, self.PROTOCOL_VERSION, self.CLIENT,
self.CLIENT_VERSION, self.username, auth, stamp)
print_d("Sending handshake to service.")
try:
resp = urlopen(url)
except UrllibError:
if show_dialog:
self.quick_dialog(
_("Could not contact service '%s'.") %
util.escape(self.base_url), Gtk.MessageType.ERROR)
else:
print_d("Could not contact service. Queueing submissions.")
return False
except ValueError:
self.quick_dialog(_("Authentication failed: invalid URL."),
Gtk.MessageType.ERROR)
self.broken = True
return False
# check response
lines = resp.read().decode("utf-8", "ignore").rstrip().split("\n")
status = lines.pop(0)
print_d("Handshake status: %s" % status)
if status == "OK":
self.session_id, self.nowplaying_url, self.submit_url = lines
self.handshake_sent = True
print_d("Session ID: %s, NP URL: %s, Submit URL: %s" % (
self.session_id, self.nowplaying_url, self.submit_url))
return True
elif status == "BADAUTH":
self.quick_dialog(_("Authentication failed: Invalid username '%s' "
"or bad password.") % util.escape(self.username),
Gtk.MessageType.ERROR)
self.broken = True
elif status == "BANNED":
self.quick_dialog(_("Client is banned. Contact the author."),
Gtk.MessageType.ERROR)
self.broken = True
elif status == "BADTIME":
self.quick_dialog(_("Wrong system time. Submissions may fail "
"until it is corrected."), Gtk.MessageType.ERROR)
else: # "FAILED"
self.quick_dialog(util.escape(status), Gtk.MessageType.ERROR)
self.changed()
return False
def __process(self, results):
req_data = []
req_data.append(
urlencode({
"format": "json",
"client": APP_KEY,
"batch": "1",
}))
for i, result in enumerate(results):
postfix = ".%d" % i
req_data.append(
urlencode({
"duration" + postfix: str(int(round(result.length))),
"fingerprint" + postfix: result.chromaprint,
}))
req_data.append("meta=releases+recordings+tracks+sources")
urldata = "&".join(req_data)
obj = BytesIO()
gzip.GzipFile(fileobj=obj, mode="wb").write(urldata.encode())
urldata = obj.getvalue()
headers = {
"Content-Encoding": "gzip",
"Content-type": "application/x-www-form-urlencoded"
}
req = Request(self.URL, urldata, headers)
releases = {}
error = ""
try:
response = urlopen(req, timeout=self.TIMEOUT)
except EnvironmentError as e:
error = "urllib error: " + str(e)
else:
try:
data = response.read()
data = json.loads(data.decode())
except ValueError as e:
error = str(e)
else:
if data["status"] == "ok":
for result_data in data.get("fingerprints", []):
if "index" not in result_data:
continue
index = result_data["index"]
releases[index] = parse_acoustid_response(result_data)
for i, result in enumerate(results):
yield LookupResult(result, releases.get(str(i), []), error)
def apicall(method, **kwargs):
"""Performs Last.fm API call."""
real_args = {'api_key': API_KEY, 'format': 'json', 'method': method}
real_args.update(kwargs)
url = ''.join(["https://ws.audioscrobbler.com/2.0/?", urlencode(real_args)])
uobj = urlopen(url)
json_text = uobj.read().decode("utf-8")
resp = json.loads(json_text)
if 'error' in resp:
errmsg = f"Last.fm API error: {resp.get('message', '')}"
print_e(errmsg)
raise EnvironmentError(resp['error'], errmsg)
return resp
def __process(self, results):
req_data = []
req_data.append(urlencode({
"format": "json",
"client": APP_KEY,
"batch": "1",
}))
for i, result in enumerate(results):
postfix = ".%d" % i
req_data.append(urlencode({
"duration" + postfix: str(int(round(result.length))),
"fingerprint" + postfix: result.chromaprint,
}))
req_data.append("meta=releases+recordings+tracks+sources")
urldata = "&".join(req_data)
obj = cBytesIO()
gzip.GzipFile(fileobj=obj, mode="wb").write(urldata)
urldata = obj.getvalue()
headers = {
"Content-Encoding": "gzip",
"Content-type": "application/x-www-form-urlencoded"
}
req = Request(self.URL, urldata, headers)
releases = {}
error = ""
try:
response = urlopen(req, timeout=self.TIMEOUT)
except EnvironmentError as e:
error = "urllib error: " + str(e)
else:
try:
data = response.read()
data = json.loads(data)
except ValueError as e:
error = str(e)
else:
if data["status"] == "ok":
for result_data in data.get("fingerprints", []):
if "index" not in result_data:
continue
index = result_data["index"]
releases[index] = parse_acoustid_response(result_data)
for i, result in enumerate(results):
yield LookupResult(result, releases.get(str(i), []), error)
def __send(self, urldata):
if self.__stopped:
return
gatekeeper.wait()
self.__done += len(urldata)
basedata = urlencode({
"format": "xml",
"client": APP_KEY,
"user": get_api_key(),
})
urldata = "&".join([basedata] + list(map(urlencode, urldata)))
obj = BytesIO()
gzip.GzipFile(fileobj=obj, mode="wb").write(urldata.encode())
urldata = obj.getvalue()
headers = {
"Content-Encoding": "gzip",
"Content-type": "application/x-www-form-urlencoded"
}
req = Request(self.URL, urldata, headers)
error = None
try:
response = urlopen(req, timeout=self.TIMEOUT)
except EnvironmentError as e:
error = "urllib error: " + str(e)
else:
xml = response.read()
try:
dom = parseString(xml)
except:
error = "xml error"
else:
status = dom.getElementsByTagName("status")
if not status or not status[0].childNodes or not \
status[0].childNodes[0].nodeValue == "ok":
error = "response status error"
if error:
print_w("[fingerprint] Submission failed: " + error)
# emit progress
self.__idle(self.__progress_cb,
float(self.__done) / len(self.__results))
def __send(self, urldata):
if self.__stopped:
return
gatekeeper.wait()
self.__done += len(urldata)
basedata = urlencode({
"format": "xml",
"client": APP_KEY,
"user": get_api_key(),
})
urldata = "&".join([basedata] + map(urlencode, urldata))
obj = cBytesIO()
gzip.GzipFile(fileobj=obj, mode="wb").write(urldata)
urldata = obj.getvalue()
headers = {
"Content-Encoding": "gzip",
"Content-type": "application/x-www-form-urlencoded"
}
req = Request(self.URL, urldata, headers)
error = None
try:
response = urlopen(req, timeout=self.TIMEOUT)
except EnvironmentError as e:
error = "urllib error: " + str(e)
else:
xml = response.read()
try:
dom = parseString(xml)
except:
error = "xml error"
else:
status = dom.getElementsByTagName("status")
if not status or not status[0].childNodes or not \
status[0].childNodes[0].nodeValue == "ok":
error = "response status error"
if error:
print_w("[fingerprint] Submission failed: " + error)
# emit progress
self.__idle(self.__progress_cb,
float(self.__done) / len(self.__results))
def apicall(method, **kwargs):
"""Performs Last.fm API call."""
real_args = {
'api_key': API_KEY,
'format': 'json',
'method': method,
}
real_args.update(kwargs)
url = ''.join(["https://ws.audioscrobbler.com/2.0/?",
urlencode(real_args)])
log(url)
uobj = urlopen(url)
resp = json.load(uobj)
if 'error' in resp:
errmsg = 'Last.fm API error: %s' % resp.get('message', '')
log(errmsg)
raise EnvironmentError(resp['error'], errmsg)
return resp
def __start_next(self):
started = len([r for r in self.downloads if r[2] != 0])
iter = self.downloads.get_iter_first()
while iter is not None:
if started >= 2:
break
if self.downloads[iter][2] == 0:
url = urlopen(self.downloads[iter][3])
sock = url.fp._sock
sock.setblocking(0)
self.downloads[iter][0] = sock
sig_id = qltk.io_add_watch(
sock, GLib.PRIORITY_DEFAULT,
GLib.IO_IN | GLib.IO_ERR | GLib.IO_HUP, self.__got_data,
self.downloads[iter][1], iter)
self.downloads[iter][2] = sig_id
started += 1
iter = self.downloads.iter_next(iter)
def __start_next(self):
started = len(filter(lambda row: row[2] != 0, self.downloads))
iter = self.downloads.get_iter_first()
while iter is not None:
if started >= 2:
break
if self.downloads[iter][2] == 0:
url = urlopen(self.downloads[iter][3])
sock = url.fp._sock
sock.setblocking(0)
self.downloads[iter][0] = sock
sig_id = qltk.io_add_watch(
sock, GLib.PRIORITY_DEFAULT,
GLib.IO_IN | GLib.IO_ERR | GLib.IO_HUP,
self.__got_data, self.downloads[iter][1], iter)
self.downloads[iter][2] = sig_id
started += 1
iter = self.downloads.iter_next(iter)
def _check_submit(self, url, data):
data_str = urlencode(data).encode("ascii")
try:
resp = urlopen(url, data_str)
except EnvironmentError:
print_d("Audioscrobbler server not responding, will try later.")
return False
resp_save = resp.read().decode("utf-8", "ignore")
status = resp_save.rstrip().split("\n")[0]
print_d("Submission status: %s" % status)
if status == "OK":
return True
elif status == "BADSESSION":
self.handshake_sent = False
return False
else:
return False
def apicall(method, **kwargs):
"""Performs Last.fm API call."""
real_args = {
'api_key': API_KEY,
'format': 'json',
'method': method,
}
real_args.update(kwargs)
url = ''.join(
["https://ws.audioscrobbler.com/2.0/?",
urlencode(real_args)])
log(url)
uobj = urlopen(url)
resp = json.load(uobj)
if 'error' in resp:
errmsg = 'Last.fm API error: %s' % resp.get('message', '')
log(errmsg)
raise EnvironmentError(resp['error'], errmsg)
return resp
def _check_submit(self, url, data):
data_str = urlencode(data)
try:
resp = urlopen(url, data_str)
except EnvironmentError:
print_d("Audioscrobbler server not responding, will try later.")
return False
resp_save = resp.read()
status = resp_save.rstrip().split("\n")[0]
print_d("Submission status: %s" % status)
if status == "OK":
return True
elif status == "BADSESSION":
self.handshake_sent = False
return False
else:
return False
def __search(self, song, buffer, refresh, add):
artist = song.comma("artist")
title = song.comma("title")
try:
sock = urlopen(
"http://lyricwiki.org/api.php?"
"client=QuodLibet&func=getSong&artist=%s&song=%s&fmt=text" %
(quote(artist.encode('utf-8')), quote(title.encode('utf-8'))))
text = sock.read()
except Exception as err:
util.print_exc()
GLib.idle_add(buffer.set_text, text_type(err))
return
sock.close()
if text == 'Not found':
GLib.idle_add(buffer.set_text, _("No lyrics found for this song."))
return
else:
GLib.idle_add(buffer.set_text, text)
GLib.idle_add(refresh.set_sensitive, True)
def get_encoding(url):
request = Request(url)
request.add_header("Accept-Encoding", "gzip")
request.add_header("User-Agent", USER_AGENT)
url_sock = urlopen(request)
return get_encoding_from_socket(url_sock)
def get_encoding(url):
request = Request(url)
request.add_header('Accept-Encoding', 'gzip')
request.add_header('User-Agent', USER_AGENT)
url_sock = urlopen(request)
return get_encoding_from_socket(url_sock)
def __set_async(self, url):
"""Manages various things:
Fast switching of covers (aborting old HTTP requests),
The image cache, etc."""
self.current_job += 1
job = self.current_job
self.stop_loading = True
while self.loading:
time.sleep(0.05)
self.stop_loading = False
if job != self.current_job:
return
self.loading = True
GLib.idle_add(self.button.set_sensitive, False)
self.current_pixbuf = None
pbloader = GdkPixbuf.PixbufLoader()
pbloader.connect('closed', self.__close)
# Look for cached images
raw_data = None
for entry in self.data_cache:
if entry[0] == url:
raw_data = entry[1]
break
if not raw_data:
pbloader.connect('area-updated', self.__update)
data_store = BytesIO()
try:
request = Request(url)
request.add_header('User-Agent', USER_AGENT)
url_sock = urlopen(request)
except EnvironmentError:
print_w(_("[albumart] HTTP Error: %s") % url)
else:
while not self.stop_loading:
tmp = url_sock.read(1024 * 10)
if not tmp:
break
pbloader.write(tmp)
data_store.write(tmp)
url_sock.close()
if not self.stop_loading:
raw_data = data_store.getvalue()
self.data_cache.insert(0, (url, raw_data))
while 1:
cache_sizes = [
len(data[1]) for data in self.data_cache
]
if sum(cache_sizes) > self.max_cache_size:
del self.data_cache[-1]
else:
break
data_store.close()
else:
# Sleep for fast switching of cached images
time.sleep(0.05)
if not self.stop_loading:
pbloader.write(raw_data)
try:
pbloader.close()
except GLib.GError:
pass
self.current_data = raw_data
if not self.stop_loading:
GLib.idle_add(self.button.set_sensitive, True)
self.loading = False
def __set_async(self, url):
"""Manages various things:
Fast switching of covers (aborting old HTTP requests),
The image cache, etc."""
self.current_job += 1
job = self.current_job
self.stop_loading = True
while self.loading:
time.sleep(0.05)
self.stop_loading = False
if job != self.current_job:
return
self.loading = True
GLib.idle_add(self.button.set_sensitive, False)
self.current_pixbuf = None
pbloader = GdkPixbuf.PixbufLoader()
pbloader.connect('closed', self.__close)
# Look for cached images
raw_data = None
for entry in self.data_cache:
if entry[0] == url:
raw_data = entry[1]
break
if not raw_data:
pbloader.connect('area-updated', self.__update)
data_store = cBytesIO()
try:
request = Request(url)
request.add_header('User-Agent', USER_AGENT)
url_sock = urlopen(request)
except EnvironmentError:
print_w(_("[albumart] HTTP Error: %s") % url)
else:
while not self.stop_loading:
tmp = url_sock.read(1024 * 10)
if not tmp:
break
pbloader.write(tmp)
data_store.write(tmp)
url_sock.close()
if not self.stop_loading:
raw_data = data_store.getvalue()
self.data_cache.insert(0, (url, raw_data))
while 1:
cache_sizes = [len(data[1]) for data in
self.data_cache]
if sum(cache_sizes) > self.max_cache_size:
del self.data_cache[-1]
else:
break
data_store.close()
else:
# Sleep for fast switching of cached images
time.sleep(0.05)
if not self.stop_loading:
pbloader.write(raw_data)
try:
pbloader.close()
except GLib.GError:
pass
self.current_data = raw_data
if not self.stop_loading:
GLib.idle_add(self.button.set_sensitive, True)
self.loading = False
def get_encoding(url):
request = Request(url)
request.add_header('Accept-Encoding', 'gzip')
request.add_header('User-Agent', USER_AGENT)
url_sock = urlopen(request)
return get_encoding_from_socket(url_sock)
