def submit_listens_to_listenbrainz(user: Dict,
listens: List,
listen_type=LISTEN_TYPE_IMPORT):
""" Submit a batch of listens to ListenBrainz
Args:
user: the user whose listens are to be submitted, dict should contain
at least musicbrainz_id and user_id
listens: a list of listens to be submitted
listen_type: the type of listen (single, import, playing_now)
"""
username = user['musicbrainz_id']
user_metadata = SubmitListenUserMetadata(user_id=user['user_id'],
musicbrainz_id=username)
retries = 10
while retries >= 0:
try:
current_app.logger.debug('Submitting %d listens for user %s',
len(listens), username)
insert_payload(listens, user_metadata, listen_type=listen_type)
current_app.logger.debug('Submitted!')
break
except (InternalServerError, ServiceUnavailable) as e:
retries -= 1
current_app.logger.error(
'ISE while trying to import listens for %s: %s', username,
str(e))
if retries == 0:
raise ExternalServiceError(
'ISE while trying to import listens: %s', str(e))
def submit_listens():
""" Submit listens received from clients into the listenstore after validating them. """
try:
session = _get_session(request.form.get('s', ''))
except BadRequest:
return 'BADSESSION\n', 401
listens = []
index = 0
while True:
listen = _to_native_api(request.form, append_key='[{}]'.format(index))
if listen is None:
break
else:
listens.append(listen)
index += 1
if not listens:
return 'FAILED Invalid data submitted!\n', 400
user = db_user.get(session.user_id)
insert_payload(listens, user)
return 'OK\n'
def submit_listens_to_listenbrainz(listenbrainz_user,
listens,
listen_type=LISTEN_TYPE_IMPORT):
""" Submit a batch of listens to ListenBrainz
Args:
listenbrainz_user (dict): the user whose listens are to be submitted
listens (list): a list of listens to be submitted
listen_type: the type of listen (single, import, playing_now)
"""
username = listenbrainz_user['musicbrainz_id']
retries = 10
while retries >= 0:
try:
current_app.logger.debug('Submitting %d listens for user %s',
len(listens), username)
insert_payload(listens, listenbrainz_user, listen_type=listen_type)
current_app.logger.debug('Submitted!')
break
except (InternalServerError, ServiceUnavailable) as e:
retries -= 1
current_app.logger.error(
'ISE while trying to import listens for %s: %s', username,
str(e))
if retries == 0:
raise spotify.SpotifyListenBrainzError(
'ISE while trying to import listens: %s', str(e))
def submit_listens():
""" Submit listens received from clients into the listenstore after validating them. """
try:
session = _get_session(request.form.get('s', ''))
except BadRequest:
return 'BADSESSION\n', 401
listens = []
index = 0
while True:
listen = _to_native_api(request.form, append_key='[{}]'.format(index))
if listen is None:
break
else:
listens.append(listen)
index += 1
if not listens:
return 'FAILED Invalid data submitted!\n', 400
user = db_user.get(session.user_id)
insert_payload(listens, user)
return 'OK\n'
def process_one_user(user):
""" Get recently played songs for this user and submit them to ListenBrainz.
Args:
user (spotify.Spotify): the user whose plays are to be imported.
Raises:
spotify.SpotifyAPIError: if we encounter errors from the Spotify API.
spotify.SpotifyListenBrainzError: if we encounter a rate limit, even after retrying.
or if we get errors while submitting the data to ListenBrainz
"""
if user.token_expired:
try:
user = spotify.refresh_user_token(user)
except spotify.SpotifyAPIError:
current_app.logger.error('Could not refresh user token from spotify', exc_info=True)
raise
listenbrainz_user = db_user.get(user.user_id)
try:
recently_played = get_user_recently_played(user)
except (spotify.SpotifyListenBrainzError, spotify.SpotifyAPIError) as e:
raise
# convert listens to ListenBrainz format and validate them
listens = []
if 'items' in recently_played:
current_app.logger.debug('Received %d listens from Spotify for %s', len(recently_played['items']), str(user))
for item in recently_played['items']:
listen = _convert_spotify_play_to_listen(item)
try:
validate_listen(listen, LISTEN_TYPE_IMPORT)
listens.append(listen)
except BadRequest:
current_app.logger.error('Could not validate listen for user %s: %s', str(user), json.dumps(listen, indent=3), exc_info=True)
# TODO: api_utils exposes werkzeug exceptions, if it's a more generic module it shouldn't be web-specific
# if we don't have any new listens, return
if len(listens) == 0:
return
latest_listened_at = max(listen['listened_at'] for listen in listens)
# try to submit listens to ListenBrainz
retries = 10
while retries >= 0:
try:
current_app.logger.debug('Submitting %d listens for user %s', len(listens), str(user))
insert_payload(listens, listenbrainz_user, listen_type=LISTEN_TYPE_IMPORT)
current_app.logger.debug('Submitted!')
break
except (InternalServerError, ServiceUnavailable) as e:
retries -= 1
current_app.logger.info('ISE while trying to import listens for %s: %s', str(user), str(e))
if retries == 0:
raise spotify.SpotifyListenBrainzError('ISE while trying to import listens: %s', str(e))
# we've succeeded so update the last_updated field for this user
spotify.update_latest_listened_at(user.user_id, latest_listened_at)
spotify.update_last_updated(user.user_id)
def upload():
if request.method == 'POST':
try:
f = request.files['file']
if f.filename == '':
flash.warning('No file selected.')
return redirect(request.url)
except RequestEntityTooLarge:
raise RequestEntityTooLarge('Maximum filesize upload limit exceeded. File must be <=' +
sizeof_readable(current_app.config['MAX_CONTENT_LENGTH']))
except:
raise InternalServerError("Something went wrong. Could not upload the file")
# Check upload folder
if 'UPLOAD_FOLDER' not in current_app.config:
raise InternalServerError("Could not upload the file. Upload folder not specified")
upload_path = path.join(path.abspath(current_app.config['UPLOAD_FOLDER']), current_user.musicbrainz_id)
if not path.isdir(upload_path):
makedirs(upload_path)
# Write to a file
filename = path.join(upload_path, secure_filename(f.filename))
f.save(filename)
if not zipfile.is_zipfile(filename):
raise BadRequest('Not a valid zip file.')
success = failure = 0
regex = re.compile('json/scrobbles/scrobbles-*')
try:
zf = zipfile.ZipFile(filename, 'r')
files = zf.namelist()
# Iterate over file that match the regex
for f in [f for f in files if regex.match(f)]:
try:
# Load listens file
jsonlist = ujson.loads(zf.read(f))
if not isinstance(jsonlist, list):
raise ValueError
except ValueError:
failure += 1
continue
payload = convert_backup_to_native_format(jsonlist)
for listen in payload:
validate_listen(listen, LISTEN_TYPE_IMPORT)
insert_payload(payload, current_user)
success += 1
except Exception:
raise BadRequest('Not a valid lastfm-backup-file.')
finally:
os.remove(filename)
# reset listen count for user
db_connection = webserver.influx_connection._influx
db_connection.reset_listen_count(current_user.musicbrainz_id)
flash.info('Congratulations! Your listens from %d files have been uploaded successfully.' % success)
return redirect(url_for("profile.import_data"))
def submit_listen():
"""
Submit listens to the server. A user token (found on https://listenbrainz.org/user/import ) must
be provided in the Authorization header!
For complete details on the format of the JSON to be POSTed to this endpoint, see :ref:`json-doc`.
:reqheader Authorization: Token <user token>
:statuscode 200: listen(s) accepted.
:statuscode 400: invalid JSON sent, see error message for details.
:statuscode 401: invalid authorization. See error message for details.
:resheader Content-Type: *application/json*
"""
user = _validate_auth_header()
raw_data = request.get_data()
try:
data = ujson.loads(raw_data.decode("utf-8"))
except ValueError as e:
log_raise_400("Cannot parse JSON document: %s" % e, raw_data)
try:
payload = data['payload']
if len(payload) == 0:
return "success"
if len(raw_data) > len(payload) * MAX_LISTEN_SIZE:
log_raise_400(
"JSON document is too large. In aggregate, listens may not "
"be larger than %d characters." % MAX_LISTEN_SIZE, payload)
if data['listen_type'] not in ('playing_now', 'single', 'import'):
log_raise_400("JSON document requires a valid listen_type key.",
payload)
listen_type = _get_listen_type(data['listen_type'])
if (listen_type == LISTEN_TYPE_SINGLE or listen_type
== LISTEN_TYPE_PLAYING_NOW) and len(payload) > 1:
log_raise_400(
"JSON document contains more than listen for a single/playing_now. "
"It should contain only one.", payload)
except KeyError:
log_raise_400("Invalid JSON document submitted.", raw_data)
# validate listens to make sure json is okay
for listen in payload:
validate_listen(listen, listen_type)
try:
insert_payload(payload,
user,
listen_type=_get_listen_type(data['listen_type']))
except ServiceUnavailable as e:
raise
except Exception as e:
raise InternalServerError("Something went wrong. Please try again.")
return "success"
def submit_listen():
"""
Submit listens to the server. A user token (found on https://listenbrainz.org/profile/ ) must
be provided in the Authorization header!
Listens should be submitted for tracks when the user has listened to half the track or 4 minutes of
the track, whichever is lower. If the user hasn't listened to 4 minutes or half the track, it doesn't
fully count as a listen and should not be submitted.
For complete details on the format of the JSON to be POSTed to this endpoint, see :ref:`json-doc`.
:reqheader Authorization: Token <user token>
:statuscode 200: listen(s) accepted.
:statuscode 400: invalid JSON sent, see error message for details.
:statuscode 401: invalid authorization. See error message for details.
:resheader Content-Type: *application/json*
"""
user = _validate_auth_header()
raw_data = request.get_data()
try:
data = ujson.loads(raw_data.decode("utf-8"))
except ValueError as e:
log_raise_400("Cannot parse JSON document: %s" % e, raw_data)
try:
payload = data['payload']
if len(payload) == 0:
return "success"
if len(raw_data) > len(payload) * MAX_LISTEN_SIZE:
log_raise_400("JSON document is too large. In aggregate, listens may not "
"be larger than %d characters." % MAX_LISTEN_SIZE, payload)
if data['listen_type'] not in ('playing_now', 'single', 'import'):
log_raise_400("JSON document requires a valid listen_type key.", payload)
listen_type = _get_listen_type(data['listen_type'])
if (listen_type == LISTEN_TYPE_SINGLE or listen_type == LISTEN_TYPE_PLAYING_NOW) and len(payload) > 1:
log_raise_400("JSON document contains more than listen for a single/playing_now. "
"It should contain only one.", payload)
except KeyError:
log_raise_400("Invalid JSON document submitted.", raw_data)
# validate listens to make sure json is okay
for listen in payload:
validate_listen(listen, listen_type)
try:
insert_payload(payload, user, listen_type=_get_listen_type(data['listen_type']))
except ServiceUnavailable as e:
raise
except Exception as e:
raise InternalServerError("Something went wrong. Please try again.")
return jsonify({'status': 'ok'})
def process_one_user(user):
""" Get recently played songs for this user and submit them to ListenBrainz.
Args:
user (spotify.Spotify): the user whose plays are to be imported.
Raises:
spotify.SpotifyAPIError: if we encounter errors from the Spotify API.
spotify.SpotifyListenBrainzError: if we encounter a rate limit, even after retrying.
or if we get errors while submitting the data to ListenBrainz
"""
if user.token_expired:
user = spotify.refresh_user_token(user)
listenbrainz_user = db_user.get(user.user_id)
try:
recently_played = get_user_recently_played(user)
except (spotify.SpotifyListenBrainzError, spotify.SpotifyAPIError) as e:
raise
# convert listens to ListenBrainz format and validate them
listens = []
if 'items' in recently_played:
current_app.logger.debug('Received %d listens from Spotify for %s', len(recently_played['items']), str(user))
for item in recently_played['items']:
listen = _convert_spotify_play_to_listen(item)
try:
validate_listen(listen, LISTEN_TYPE_IMPORT)
listens.append(listen)
except BadRequest:
current_app.logger.error('Could not validate listen for user %s: %s', str(user), json.dumps(listen, indent=3), exc_info=True)
# TODO: api_utils exposes werkzeug exceptions, if it's a more generic module it shouldn't be web-specific
latest_listened_at = max(listen['listened_at'] for listen in listens)
# try to submit listens to ListenBrainz
retries = 10
while retries >= 0:
try:
current_app.logger.debug('Submitting %d listens for user %s', len(listens), str(user))
insert_payload(listens, listenbrainz_user, listen_type=LISTEN_TYPE_IMPORT)
current_app.logger.debug('Submitted!')
break
except (InternalServerError, ServiceUnavailable) as e:
retries -= 1
current_app.logger.info('ISE while trying to import listens for %s: %s', str(user), str(e))
if retries == 0:
raise spotify.SpotifyListenBrainzError('ISE while trying to import listens: %s', str(e))
# we've succeeded so update the last_updated field for this user
spotify.update_latest_listened_at(user.user_id, latest_listened_at)
spotify.update_last_updated(user.user_id)
def submit_now_playing():
""" Handle now playing notifications sent by clients """
current_app.logger.info(json.dumps(request.form, indent=4))
try:
session = _get_session(request.form.get('s', ''))
except BadRequest:
return 'BADSESSION\n', 401
listen = _to_native_api(request.form, append_key='')
if listen is None:
return 'FAILED Invalid data submitted!\n', 400
listens = [listen]
user = db_user.get(session.user_id)
insert_payload(listens, user, LISTEN_TYPE_PLAYING_NOW)
return 'OK\n'
def record_listens(request, data):
""" Submit the listen in the lastfm format to be inserted in db.
Accepts listens for both track.updateNowPlaying and track.scrobble methods.
"""
output_format = data.get('format', 'xml')
try:
sk, api_key = data['sk'], data['api_key']
except KeyError:
raise InvalidAPIUsage(CompatError.INVALID_PARAMETERS, output_format=output_format) # Invalid parameters
session = Session.load(sk)
if not session:
if not Token.is_valid_api_key(api_key):
raise InvalidAPIUsage(CompatError.INVALID_API_KEY, output_format=output_format) # Invalid API_KEY
raise InvalidAPIUsage(CompatError.INVALID_SESSION_KEY, output_format=output_format) # Invalid Session KEY
lookup = defaultdict(dict)
for key, value in data.items():
if key in ["sk", "token", "api_key", "method", "api_sig"]:
continue
matches = re.match('(.*)\[(\d+)\]', key)
if matches:
key = matches.group(1)
number = matches.group(2)
else:
number = 0
lookup[number][key] = value
if request.form['method'].lower() == 'track.updatenowplaying':
for i, listen in lookup.items():
if 'timestamp' not in listen:
listen['timestamp'] = calendar.timegm(datetime.now().utctimetuple())
# Convert to native payload then submit 'em after validation.
listen_type, native_payload = _to_native_api(lookup, data['method'], output_format)
for listen in native_payload:
validate_listen(listen, listen_type)
user = db_user.get(session.user_id)
augmented_listens = insert_payload(native_payload, user, listen_type=listen_type)
# With corrections than the original submitted listen.
doc, tag, text = Doc().tagtext()
with tag('lfm', status='ok'):
if listen_type == 'playing_now':
doc.asis(create_response_for_single_listen(list(lookup.values())[0], augmented_listens[0], listen_type))
else:
accepted_listens = len(lookup.values())
# Currently LB accepts all the listens and ignores none
with tag('scrobbles', accepted=accepted_listens, ignored='0'):
for original_listen, augmented_listen in zip(list(lookup.values()), augmented_listens):
doc.asis(create_response_for_single_listen(original_listen, augmented_listen, listen_type))
return format_response('<?xml version="1.0" encoding="utf-8"?>\n' + yattag.indent(doc.getvalue()),
output_format)
def submit_now_playing():
""" Handle now playing notifications sent by clients """
current_app.logger.info(json.dumps(request.form, indent=4))
try:
session = _get_session(request.form.get('s', ''))
except BadRequest:
return 'BADSESSION\n', 401
listen = _to_native_api(request.form, append_key='')
if listen is None:
return 'FAILED Invalid data submitted!\n', 400
listens = [listen]
user = db_user.get(session.user_id)
insert_payload(listens, user, LISTEN_TYPE_PLAYING_NOW)
return 'OK\n'
def record_listens(request, data):
""" Submit the listen in the lastfm format to be inserted in db.
Accepts listens for both track.updateNowPlaying and track.scrobble methods.
"""
output_format = data.get('format', 'xml')
try:
sk, api_key = data['sk'], data['api_key']
except KeyError:
raise InvalidAPIUsage(
CompatError.INVALID_PARAMETERS,
output_format=output_format) # Invalid parameters
session = Session.load(sk, api_key)
if not session:
if not Token.is_valid_api_key(api_key):
raise InvalidAPIUsage(
CompatError.INVALID_API_KEY,
output_format=output_format) # Invalid API_KEY
raise InvalidAPIUsage(
CompatError.INVALID_SESSION_KEY,
output_format=output_format) # Invalid Session KEY
lookup = defaultdict(dict)
for key, value in data.items():
if key in ["sk", "token", "api_key", "method", "api_sig"]:
continue
matches = re.match('(.*)\[(\d+)\]', key)
if matches:
key = matches.group(1)
number = matches.group(2)
else:
number = 0
lookup[number][key] = value
if request.form['method'].lower() == 'track.updatenowplaying':
for i, listen in lookup.items():
if 'timestamp' not in listen:
listen['timestamp'] = calendar.timegm(
datetime.now().utctimetuple())
# Convert to native payload then submit 'em after validation.
listen_type, native_payload = _to_native_api(lookup, data['method'],
output_format)
for listen in native_payload:
validate_listen(listen, listen_type)
augmented_listens = insert_payload(native_payload,
session.user,
listen_type=listen_type)
# With corrections than the original submitted listen.
doc, tag, text = Doc().tagtext()
with tag('lfm', status='ok'):
with tag('nowplaying' if listen_type ==
'playing_now' else 'scrobbles'):
for origL, augL in zip(list(lookup.values()), augmented_listens):
corr = defaultdict(lambda: '0')
track = augL['track_metadata']['track_name']
if origL['track'] != augL['track_metadata']['track_name']:
corr['track'] = '1'
artist = augL['track_metadata']['artist_name']
if origL['artist'] != augL['track_metadata']['artist_name']:
corr['artist'] = '1'
ts = augL['listened_at']
albumArtist = artist
if origL.get('albumArtist', origL['artist']) != artist:
corr['albumArtist'] = '1'
album = augL['track_metadata'].get('release_name', '')
if origL.get('album', '') != album:
corr['album'] = '1'
with tag('scrobble'):
with tag('track', corrected=corr['track']):
text(track)
with tag('artist', corrected=corr['artist']):
text(artist)
with tag('album', corrected=corr['album']):
text(album)
with tag('albumArtist', corrected=corr['albumArtist']):
text(albumArtist)
with tag('timestamp'):
text(ts)
with tag('ignoredMessage', code="0"):
text('')
return format_response(
'<?xml version="1.0" encoding="utf-8"?>\n' +
yattag.indent(doc.getvalue()), output_format)
def submit_listen():
"""
Submit listens to the server. A user token (found on https://listenbrainz.org/profile/ ) must
be provided in the Authorization header! Each request should also contain at least one listen
in the payload.
Listens should be submitted for tracks when the user has listened to half the track or 4 minutes of
the track, whichever is lower. If the user hasn't listened to 4 minutes or half the track, it doesn't
fully count as a listen and should not be submitted.
For complete details on the format of the JSON to be POSTed to this endpoint, see :ref:`json-doc`.
:reqheader Authorization: Token <user token>
:reqheader Content-Type: *application/json*
:statuscode 200: listen(s) accepted.
:statuscode 400: invalid JSON sent, see error message for details.
:statuscode 401: invalid authorization. See error message for details.
:resheader Content-Type: *application/json*
"""
user = validate_auth_header(fetch_email=True)
if mb_engine and current_app.config[
"REJECT_LISTENS_WITHOUT_USER_EMAIL"] and not user["email"]:
raise APIUnauthorized(REJECT_LISTENS_WITHOUT_EMAIL_ERROR)
raw_data = request.get_data()
try:
data = ujson.loads(raw_data.decode("utf-8"))
except ValueError as e:
log_raise_400("Cannot parse JSON document: %s" % e, raw_data)
try:
payload = data['payload']
if not isinstance(payload, list):
raise APIBadRequest(
"The payload in the JSON document should be a list of listens.",
payload)
if len(payload) == 0:
log_raise_400("JSON document does not contain any listens",
payload)
if len(raw_data) > len(payload) * MAX_LISTEN_SIZE:
log_raise_400(
"JSON document is too large. In aggregate, listens may not "
"be larger than %d characters." % MAX_LISTEN_SIZE, payload)
if data['listen_type'] not in ('playing_now', 'single', 'import'):
log_raise_400("JSON document requires a valid listen_type key.",
payload)
listen_type = _get_listen_type(data['listen_type'])
if (listen_type == LISTEN_TYPE_SINGLE or listen_type
== LISTEN_TYPE_PLAYING_NOW) and len(payload) > 1:
log_raise_400(
"JSON document contains more than listen for a single/playing_now. "
"It should contain only one.", payload)
except KeyError:
log_raise_400("Invalid JSON document submitted.", raw_data)
try:
# validate listens to make sure json is okay
validated_payload = [
validate_listen(listen, listen_type) for listen in payload
]
except ListenValidationError as err:
raise APIBadRequest(err.message, err.payload)
user_metadata = SubmitListenUserMetadata(
user_id=user['id'], musicbrainz_id=user['musicbrainz_id'])
insert_payload(validated_payload, user_metadata, listen_type)
return jsonify({'status': 'ok'})
def record_listens(request, data):
""" Submit the listen in the lastfm format to be inserted in db.
Accepts listens for both track.updateNowPlaying and track.scrobble methods.
"""
output_format = data.get('format', 'xml')
try:
sk, api_key = data['sk'], data['api_key']
except KeyError:
raise InvalidAPIUsage(
CompatError.INVALID_PARAMETERS,
output_format=output_format) # Invalid parameters
session = Session.load(sk)
if not session:
if not Token.is_valid_api_key(api_key):
raise InvalidAPIUsage(
CompatError.INVALID_API_KEY,
output_format=output_format) # Invalid API_KEY
raise InvalidAPIUsage(
CompatError.INVALID_SESSION_KEY,
output_format=output_format) # Invalid Session KEY
lookup = defaultdict(dict)
for key, value in data.items():
if key in ["sk", "token", "api_key", "method", "api_sig"]:
continue
matches = re.match('(.*)\[(\d+)\]', key)
if matches:
key = matches.group(1)
number = matches.group(2)
else:
number = 0
lookup[number][key] = value
if request.form['method'].lower() == 'track.updatenowplaying':
for i, listen in lookup.items():
if 'timestamp' not in listen:
listen['timestamp'] = calendar.timegm(
datetime.now().utctimetuple())
# Convert to native payload then submit 'em after validation.
listen_type, native_payload = _to_native_api(lookup, data['method'],
output_format)
for listen in native_payload:
validate_listen(listen, listen_type)
user = db_user.get(session.user_id)
augmented_listens = insert_payload(native_payload,
user,
listen_type=listen_type)
# With corrections than the original submitted listen.
doc, tag, text = Doc().tagtext()
with tag('lfm', status='ok'):
if listen_type == 'playing_now':
doc.asis(
create_response_for_single_listen(
list(lookup.values())[0], augmented_listens[0],
listen_type))
else:
accepted_listens = len(lookup.values())
# Currently LB accepts all the listens and ignores none
with tag('scrobbles', accepted=accepted_listens, ignored='0'):
for original_listen, augmented_listen in zip(
list(lookup.values()), augmented_listens):
doc.asis(
create_response_for_single_listen(
original_listen, augmented_listen, listen_type))
return format_response(
'<?xml version="1.0" encoding="utf-8"?>\n' +
yattag.indent(doc.getvalue()), output_format)
def record_listens(data):
""" Submit the listen in the lastfm format to be inserted in db.
Accepts listens for both track.updateNowPlaying and track.scrobble methods.
"""
output_format = data.get('format', 'xml')
try:
sk, api_key = data['sk'], data['api_key']
except KeyError:
raise InvalidAPIUsage(
CompatError.INVALID_PARAMETERS,
output_format=output_format) # Invalid parameters
session = Session.load(sk)
if not session:
if not Token.is_valid_api_key(api_key):
raise InvalidAPIUsage(
CompatError.INVALID_API_KEY,
output_format=output_format) # Invalid API_KEY
raise InvalidAPIUsage(
CompatError.INVALID_SESSION_KEY,
output_format=output_format) # Invalid Session KEY
user = db_user.get(session.user_id, fetch_email=True)
if mb_engine and current_app.config[
"REJECT_LISTENS_WITHOUT_USER_EMAIL"] and user["email"] is None:
raise InvalidAPIUsage(
CompatError.NO_EMAIL,
output_format=output_format) # No email available for user in LB
lookup = defaultdict(dict)
for key, value in data.items():
if key in ["sk", "token", "api_key", "method", "api_sig", "format"]:
continue
matches = re.match('(.*)\[(\d+)\]', key)
if matches:
key = matches.group(1)
number = matches.group(2)
else:
number = 0
lookup[number][key] = value
if data['method'].lower() == 'track.updatenowplaying':
for i, listen in lookup.items():
if 'timestamp' not in listen:
listen['timestamp'] = calendar.timegm(
datetime.now().utctimetuple())
# Convert to native payload then submit 'em after validation.
listen_type, native_payload = _to_native_api(lookup, data['method'],
output_format)
try:
validated_payload = [
validate_listen(listen, listen_type) for listen in native_payload
]
except ListenValidationError as err:
# Unsure about which LastFMError code to use but 5 or 6 probably make the most sense.
# see listenbrainz.webserver.errors.py for a detailed list of all available codes
raise InvalidAPIUsage(LastFMError(code=6, message=err.message), 400,
output_format)
user_metadata = SubmitListenUserMetadata(
user_id=user['id'], musicbrainz_id=user['musicbrainz_id'])
augmented_listens = insert_payload(validated_payload,
user_metadata,
listen_type=listen_type)
# With corrections than the original submitted listen.
doc, tag, text = Doc().tagtext()
with tag('lfm', status='ok'):
if listen_type == 'playing_now':
doc.asis(
create_response_for_single_listen(
list(lookup.values())[0], augmented_listens[0],
listen_type))
else:
accepted_listens = len(lookup.values())
# Currently LB accepts all the listens and ignores none
with tag('scrobbles', accepted=accepted_listens, ignored='0'):
for original_listen, augmented_listen in zip(
list(lookup.values()), augmented_listens):
doc.asis(
create_response_for_single_listen(
original_listen, augmented_listen, listen_type))
return format_response(
'<?xml version="1.0" encoding="utf-8"?>\n' +
yattag.indent(doc.getvalue()), output_format)
