Пример #1
0
 def _parse_submission(self, values, suffix):
     # type: (MultiDict, str) -> None
     p = {}  # type: Dict[str, Any]
     p['index'] = (suffix or '')[1:]
     p['puid'] = values.get('puid' + suffix)
     if p['puid'] and not is_uuid(p['puid']):
         raise errors.InvalidUUIDError('puid' + suffix)
     p['foreignid'] = values.get('foreignid' + suffix)
     if p['foreignid'] and not is_foreignid(p['foreignid']):
         raise errors.InvalidForeignIDError('foreignid' + suffix)
     p['mbids'] = values.getlist('mbid' + suffix)
     if p['mbids'] and not all(map(is_uuid, p['mbids'])):
         raise errors.InvalidUUIDError('mbid' + suffix)
     self._parse_duration_and_format(p, values, suffix)
     fingerprint_string = values.get('fingerprint' + suffix)
     if not fingerprint_string:
         raise errors.MissingParameterError('fingerprint' + suffix)
     p['fingerprint'] = decode_fingerprint(
         fingerprint_string.encode('ascii', 'ignore'))
     if not p['fingerprint']:
         logger.info('Got invalid fingerprint %r', fingerprint_string)
         raise errors.InvalidFingerprintError()
     p['bitrate'] = values.get('bitrate' + suffix, type=int) or None
     if p['bitrate'] is not None and p['bitrate'] <= 0:
         raise errors.InvalidBitrateError('bitrate' + suffix)
     p['track'] = values.get('track' + suffix)
     p['artist'] = values.get('artist' + suffix)
     p['album'] = values.get('album' + suffix)
     p['album_artist'] = values.get('albumartist' + suffix)
     p['track_no'] = values.get('trackno' + suffix, type=int)
     p['disc_no'] = values.get('discno' + suffix, type=int)
     p['year'] = values.get('year' + suffix, type=int)
     self.submissions.append(p)
Пример #2
0
 def parse(self, values, conn):
     super(TrackListByPUIDHandlerParams, self).parse(values, conn)
     self.puid = values.get('puid')
     if not self.puid:
         raise errors.MissingParameterError('puid')
     if not is_uuid(self.puid):
         raise errors.InvalidUUIDError('puid')
Пример #3
0
 def _parse_submission(self, values, suffix):
     p = {}
     p['puid'] = values.get('puid' + suffix)
     if p['puid'] and not is_uuid(p['puid']):
         raise errors.InvalidUUIDError('puid' + suffix)
     p['foreignid'] = values.get('foreignid' + suffix)
     if p['foreignid'] and not is_foreignid(p['foreignid']):
         raise errors.InvalidForeignIDError('foreignid' + suffix)
     p['mbids'] = values.getlist('mbid' + suffix)
     if p['mbids'] and not all(map(is_uuid, p['mbids'])):
         raise errors.InvalidUUIDError('mbid' + suffix)
     self._parse_duration_and_format(p, values, suffix)
     fingerprint_string = values.get('fingerprint' + suffix)
     if not fingerprint_string:
         raise errors.MissingParameterError('fingerprint' + suffix)
     p['fingerprint'] = decode_fingerprint(fingerprint_string)
     if not p['fingerprint']:
         raise errors.InvalidFingerprintError()
     p['bitrate'] = values.get('bitrate' + suffix, type=int) or None
     if p['bitrate'] is not None and p['bitrate'] <= 0:
         raise errors.InvalidBitrateError('bitrate' + suffix)
     p['track'] = values.get('track' + suffix)
     p['artist'] = values.get('artist' + suffix)
     p['album'] = values.get('album' + suffix)
     p['album_artist'] = values.get('albumartist' + suffix)
     p['track_no'] = values.get('trackno' + suffix, type=int)
     p['disc_no'] = values.get('discno' + suffix, type=int)
     p['year'] = values.get('year' + suffix, type=int)
     self.submissions.append(p)
Пример #4
0
 def _parse_query(self, values, suffix):
     # type: (MultiDict, str) -> Union[TrackLookupQuery, FingerprintLookupQuery]
     index = int(suffix[1:]) if suffix else None
     track_gid = values.get('trackid' + suffix)
     if track_gid:
         if not is_uuid(track_gid):
             raise errors.InvalidUUIDError('trackid' + suffix)
         return TrackLookupQuery(index=index, track_gid=track_gid)
     else:
         duration = values.get(self.duration_name + suffix,
                               type=int,
                               default=0)
         if not duration:
             raise errors.MissingParameterError(self.duration_name + suffix)
         fingerprint_string = values.get('fingerprint' + suffix)
         if not fingerprint_string:
             raise errors.MissingParameterError('fingerprint' + suffix)
         fingerprint = decode_fingerprint(
             fingerprint_string.encode('ascii', 'ignore'))
         if not fingerprint:
             logger.info('Got invalid fingerprint %r', fingerprint_string)
             raise errors.InvalidFingerprintError()
         return FingerprintLookupQuery(index=index,
                                       duration=duration,
                                       fingerprint=fingerprint)
Пример #5
0
 def parse(self, values, conn):
     super(TrackListByPUIDHandlerParams, self).parse(values, conn)
     self.puid = values.get('puid')
     if not self.puid:
         raise errors.MissingParameterError('puid')
     if not is_uuid(self.puid):
         raise errors.InvalidUUIDError('puid')
Пример #6
0
 def _parse_submission(self, values, suffix):
     p = {}
     p["puid"] = values.get("puid" + suffix)
     if p["puid"] and not is_uuid(p["puid"]):
         raise errors.InvalidUUIDError("puid" + suffix)
     p["foreignid"] = values.get("foreignid" + suffix)
     if p["foreignid"] and not is_foreignid(p["foreignid"]):
         raise errors.InvalidForeignIDError("foreignid" + suffix)
     p["mbids"] = values.getlist("mbid" + suffix)
     if p["mbids"] and not all(map(is_uuid, p["mbids"])):
         raise errors.InvalidUUIDError("mbid" + suffix)
     self._parse_duration_and_format(p, values, suffix)
     fingerprint_string = values.get("fingerprint" + suffix)
     if not fingerprint_string:
         raise errors.MissingParameterError("fingerprint" + suffix)
     p["fingerprint"] = decode_fingerprint(fingerprint_string)
     if not p["fingerprint"]:
         raise errors.InvalidFingerprintError()
     p["bitrate"] = values.get("bitrate" + suffix, type=int) or None
     if p["bitrate"] is not None and p["bitrate"] <= 0:
         raise errors.InvalidBitrateError("bitrate" + suffix)
     p["track"] = values.get("track" + suffix)
     p["artist"] = values.get("artist" + suffix)
     p["album"] = values.get("album" + suffix)
     p["album_artist"] = values.get("albumartist" + suffix)
     p["track_no"] = values.get("trackno" + suffix, type=int)
     p["disc_no"] = values.get("discno" + suffix, type=int)
     p["year"] = values.get("year" + suffix, type=int)
     self.submissions.append(p)
Пример #7
0
 def _parse_submission(self, values, suffix):
     p = {}
     p['puid'] = values.get('puid' + suffix)
     if p['puid'] and not is_uuid(p['puid']):
         raise errors.InvalidUUIDError('puid' + suffix)
     p['mbids'] = values.getlist('mbid' + suffix)
     if p['mbids'] and not all(map(is_uuid, p['mbids'])):
         raise errors.InvalidUUIDError('mbid' + suffix)
     self._parse_duration_and_format(p, values, suffix)
     fingerprint_string = values.get('fingerprint' + suffix)
     if not fingerprint_string:
         raise errors.MissingParameterError('fingerprint' + suffix)
     p['fingerprint'] = decode_fingerprint(fingerprint_string)
     if not p['fingerprint']:
         raise errors.InvalidFingerprintError()
     p['bitrate'] = values.get('bitrate' + suffix, type=int)
     self.submissions.append(p)
Пример #8
0
 def _parse_query(self, values, suffix):
     p = {}
     p['index'] = (suffix or '')[1:]
     p['track_gid'] = values.get('trackid' + suffix)
     if p['track_gid'] and not is_uuid(p['track_gid']):
         raise errors.InvalidUUIDError('trackid' + suffix)
     if not p['track_gid']:
         p['duration'] = values.get(self.duration_name + suffix, type=int)
         if not p['duration']:
             raise errors.MissingParameterError(self.duration_name + suffix)
         fingerprint_string = values.get('fingerprint' + suffix)
         if not fingerprint_string:
             raise errors.MissingParameterError('fingerprint' + suffix)
         p['fingerprint'] = decode_fingerprint(fingerprint_string)
         if not p['fingerprint']:
             raise errors.InvalidFingerprintError()
     self.fingerprints.append(p)
Пример #9
0
 def _parse_query(self, values, suffix):
     p = {}
     p["index"] = (suffix or "")[1:]
     p["track_gid"] = values.get("trackid" + suffix)
     if p["track_gid"] and not is_uuid(p["track_gid"]):
         raise errors.InvalidUUIDError("trackid" + suffix)
     if not p["track_gid"]:
         p["duration"] = values.get(self.duration_name + suffix, type=int)
         if not p["duration"]:
             raise errors.MissingParameterError(self.duration_name + suffix)
         fingerprint_string = values.get("fingerprint" + suffix)
         if not fingerprint_string:
             raise errors.MissingParameterError("fingerprint" + suffix)
         p["fingerprint"] = decode_fingerprint(fingerprint_string)
         if not p["fingerprint"]:
             raise errors.InvalidFingerprintError()
     self.fingerprints.append(p)
Пример #10
0
 def _parse_query(self, values, suffix):
     p = {}
     p['index'] = (suffix or '')[1:]
     p['track_gid'] = values.get('trackid' + suffix)
     if p['track_gid'] and not is_uuid(p['track_gid']):
         raise errors.InvalidUUIDError('trackid' + suffix)
     if not p['track_gid']:
         p['duration'] = values.get(self.duration_name + suffix, type=int)
         if not p['duration']:
             raise errors.MissingParameterError(self.duration_name + suffix)
         fingerprint_string = values.get('fingerprint' + suffix)
         if not fingerprint_string:
             raise errors.MissingParameterError('fingerprint' + suffix)
         p['fingerprint'] = decode_fingerprint(
             fingerprint_string.encode('ascii', 'ignore'))
         if not p['fingerprint']:
             raise errors.InvalidFingerprintError()
     self.fingerprints.append(p)
Пример #11
0
 def _handle_request(self, req):
     from acoustid.data.musicbrainz import lookup_recording_metadata
     from acoustid.utils import is_uuid
     track_id = self.url_args['id']
     if is_uuid(track_id):
         track_gid = track_id
         track_id = resolve_track_gid(self.conn, track_id)
     else:
         track_id = int(track_id)
         query = sql.select([schema.track.c.gid], schema.track.c.id == track_id)
         track_gid = self.conn.execute(query).scalar()
     title = 'Track "%s"' % (track_gid,)
     track = {
         'id': track_id
     }
     #matrix = get_track_fingerprint_matrix(self.conn, track_id)
     #ids = sorted(matrix.keys())
     #if not ids:
     #    title = 'Incorrect Track'
     #    return self.render_template('track-not-found.html', title=title,
     #        track_id=track_id)
     #fingerprints = [{'id': id, 'i': i + 1} for i, id in enumerate(ids)]
     #color1 = (172, 0, 0)
     #color2 = (255, 255, 255)
     #for id1 in ids:
     #    for id2 in ids:
     #        sim = matrix[id1][id2]
     #        color = [color1[i] + (color2[i] - color1[i]) * sim for i in range(3)]
     #        matrix[id1][id2] = {
     #            'value': sim,
     #            'color': '#%02x%02x%02x' % tuple(color),
     #        }
     query = sql.select(
         [schema.fingerprint.c.id,
          schema.fingerprint.c.length,
          schema.fingerprint.c.submission_count],
         schema.fingerprint.c.track_id == track_id)
     fingerprints = self.conn.execute(query).fetchall()
     query = sql.select(
         [schema.track_puid.c.puid,
          schema.track_puid.c.submission_count],
         schema.track_puid.c.track_id == track_id)
     puids = list(self.conn.execute(query).fetchall())
     query = sql.select(
         [schema.track_mbid.c.mbid,
          schema.track_mbid.c.submission_count,
          schema.track_mbid.c.disabled],
         schema.track_mbid.c.track_id == track_id)
     mbids = self.conn.execute(query).fetchall()
     metadata = lookup_recording_metadata(self.conn, [r['mbid'] for r in mbids])
     recordings = []
     for mbid in mbids:
         recording = metadata.get(mbid['mbid'], {})
         recording['mbid'] = mbid['mbid']
         recording['submission_count'] = mbid['submission_count']
         recording['disabled'] = mbid['disabled']
         recordings.append(recording)
     recordings.sort(key=lambda r: r.get('name', r.get('mbid')))
     moderator = is_moderator(self.conn, self.session.get('id'))
     return self.render_template('track.html', title=title,
         fingerprints=fingerprints, recordings=recordings, puids=puids,
         moderator=moderator, track=track)
Пример #12
0
def track(track_id_or_gid):
    # xtype: (str) -> str

    fingerprint_db = db.get_fingerprint_db()
    musicbrainz_db = db.get_musicbrainz_db()

    if is_uuid(track_id_or_gid):
        track_gid = track_id_or_gid
        track_id = resolve_track_gid(fingerprint_db, track_gid)
    else:
        try:
            track_id = int(track_id_or_gid)
        except ValueError:
            track_id = None
        query = sql.select([schema.track.c.gid], schema.track.c.id == track_id)
        track_gid = fingerprint_db.execute(query).scalar()

    if track_id is None or track_gid is None:
        abort(404)

    title = 'Track "%s"' % (track_gid, )
    track = {'id': track_id}

    query = sql.select([
        schema.fingerprint.c.id, schema.fingerprint.c.length,
        schema.fingerprint.c.submission_count
    ], schema.fingerprint.c.track_id == track_id).order_by(
        schema.fingerprint.c.length)
    fingerprints = fingerprint_db.execute(query).fetchall()

    query = sql.select([
        schema.track_mbid.c.id, schema.track_mbid.c.mbid,
        schema.track_mbid.c.submission_count, schema.track_mbid.c.disabled
    ], schema.track_mbid.c.track_id == track_id)
    mbids = fingerprint_db.execute(query).fetchall()

    metadata = lookup_recording_metadata(musicbrainz_db,
                                         [r['mbid'] for r in mbids])

    recordings = []
    for mbid in mbids:
        recording = metadata.get(mbid['mbid'], {})
        recording['mbid'] = mbid['mbid']
        recording['submission_count'] = mbid['submission_count']
        recording['disabled'] = mbid['disabled']
        recordings.append(recording)
    recordings.sort(key=lambda r: r.get('name', r.get('mbid')))

    user_metadata = (db.session.query(
        Meta.track, Meta.artist, Meta.album,
        sql.func.sum(TrackMeta.submission_count)).select_from(TrackMeta).join(
            Meta).filter(TrackMeta.track_id == track_id).group_by(
                Meta.track, Meta.artist,
                Meta.album).order_by(sql.func.min(TrackMeta.created)).all())

    edits = db.session.query(TrackMBIDChange).\
        filter(TrackMBIDChange.track_mbid_id.in_(m.id for m in mbids)).\
        order_by(TrackMBIDChange.created.desc()).all()

    edits_accounts = db.session.query(Account).options(load_only('mbuser', 'name')).\
        filter(Account.id.in_(e.account_id for e in edits)).all()
    edits_accounts_by_id = {}
    for account in edits_accounts:
        edits_accounts_by_id[account.id] = account

    edits_track_mbids = db.session.query(TrackMBID).options(load_only('mbid')).\
        filter(TrackMBID.id.in_(e.track_mbid_id for e in edits)).all()
    edits_track_mbids_by_id = {}
    for track_mbid in edits_track_mbids:
        edits_track_mbids_by_id[track_mbid.id] = track_mbid

    for edit in edits:
        account = edits_accounts_by_id.get(edit.account_id)
        if account is not None:
            edit.account = account
        track_mbid = edits_track_mbids_by_id.get(edit.track_mbid_id)
        if track_mbid is not None:
            edit.track_mbid = track_mbid

    moderator = is_moderator(db.get_app_db(), session.get('id'))

    return render_template('track.html',
                           title=title,
                           fingerprints=fingerprints,
                           recordings=recordings,
                           moderator=moderator,
                           track=track,
                           edits=edits,
                           user_metadata=user_metadata)
Пример #13
0
def track(track_id):
    conn = db.session.connection()

    if is_uuid(track_id):
        track_gid = track_id
        track_id = resolve_track_gid(conn, track_id)
    else:
        track_id = int(track_id)
        query = sql.select([schema.track.c.gid], schema.track.c.id == track_id)
        track_gid = conn.execute(query).scalar()

    title = 'Track "%s"' % (track_gid,)
    track = {
        'id': track_id
    }

    query = sql.select(
        [schema.fingerprint.c.id,
         schema.fingerprint.c.length,
         schema.fingerprint.c.submission_count],
        schema.fingerprint.c.track_id == track_id).order_by(schema.fingerprint.c.length)
    fingerprints = conn.execute(query).fetchall()

    query = sql.select(
        [schema.track_mbid.c.id,
         schema.track_mbid.c.mbid,
         schema.track_mbid.c.submission_count,
         schema.track_mbid.c.disabled],
        schema.track_mbid.c.track_id == track_id)
    mbids = conn.execute(query).fetchall()

    metadata = lookup_recording_metadata(conn, [r['mbid'] for r in mbids])

    recordings = []
    for mbid in mbids:
        recording = metadata.get(mbid['mbid'], {})
        recording['mbid'] = mbid['mbid']
        recording['submission_count'] = mbid['submission_count']
        recording['disabled'] = mbid['disabled']
        recordings.append(recording)
    recordings.sort(key=lambda r: r.get('name', r.get('mbid')))

    user_metadata = db.session.query(TrackMeta).\
        options(joinedload('meta', innerjoin=True)).\
        filter(TrackMeta.track_id == track_id).\
        order_by(TrackMeta.created).all()

    edits = db.session.query(TrackMBIDChange).\
        options(joinedload('account', innerjoin=True).load_only('mbuser', 'name')).\
        options(joinedload('track_mbid', innerjoin=True).load_only('mbid')).\
        filter(TrackMBIDChange.track_mbid_id.in_(m.id for m in mbids)).\
        order_by(TrackMBIDChange.created.desc()).all()

    moderator = is_moderator(conn, session.get('id'))

    return render_template('track.html', title=title,
        fingerprints=fingerprints, recordings=recordings,
        moderator=moderator, track=track,
        edits=edits,
        user_metadata=user_metadata,
        )
Пример #14
0
def test_is_uuid():
    assert_true(is_uuid('83fdc319-b05e-4edc-9371-f7ff09fc642e'))
    assert_false(is_uuid('83fdc319-b05e-4edc-9371-xxxxxxxxxxxx'))