def test_year_range_filter_element(self):
        rlist = [Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd', year=1980),
                 Recording(mbid='73a9d0db-0ec7-490e-9a85-0525a5ccef8e', year=1990),
                 Recording(mbid='139654ae-2c02-4e0f-aee0-c47da6e59ff1', year=2000)]
        e = troi.filters.YearRangeFilterElement(1985, 1995)
        flist = e.read([rlist])
        assert len(flist) == 1

        assert flist[0].mbid == '73a9d0db-0ec7-490e-9a85-0525a5ccef8e'

        e = troi.filters.YearRangeFilterElement(1985, 1995, inverse=True)
        flist = e.read([rlist])
        assert len(flist) == 2

        assert flist[0].mbid == '8756f690-18ca-488d-a456-680fdaf234bd'
        assert flist[1].mbid == '139654ae-2c02-4e0f-aee0-c47da6e59ff1'

        e = troi.filters.YearRangeFilterElement(1985)
        flist = e.read([rlist])
        assert len(flist) == 2

        assert flist[0].mbid == '73a9d0db-0ec7-490e-9a85-0525a5ccef8e'
        assert flist[1].mbid == '139654ae-2c02-4e0f-aee0-c47da6e59ff1'

        e = troi.filters.YearRangeFilterElement(1985, inverse=True)
        flist = e.read([rlist])
        assert len(flist) == 1

        assert flist[0].mbid == '8756f690-18ca-488d-a456-680fdaf234bd'
    def test_ensure_conformity(self):
        # Test artists
        alist = [
            Artist(mbids=['8756f690-18ca-488d-a456-680fdaf234bd']),
            Artist(mbids=['73a9d0db-0ec7-490e-9a85-0525a5ccef8e'])
        ]
        blist = [Artist(mbids=['a1c35a51-d102-4ce7-aefb-79a361e843b6'])]
        assert troi.operations._ensure_conformity(alist, blist) == True

        alist = [
            Artist(mbids=['8756f690-18ca-488d-a456-680fdaf234bd']),
            Artist(mbids=['73a9d0db-0ec7-490e-9a85-0525a5ccef8e'])
        ]
        blist = [Release(mbid='a1c35a51-d102-4ce7-aefb-79a361e843b6')]
        with self.assertRaises(TypeError):
            troi.operations._ensure_conformity(alist, blist)

        # Test recording (not testing release since rel and rec use same code)
        alist = [
            Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd'),
            Recording(mbid='73a9d0db-0ec7-490e-9a85-0525a5ccef8e')
        ]
        blist = [Recording(mbid='a1c35a51-d102-4ce7-aefb-79a361e843b6')]
        assert troi.operations._ensure_conformity(alist, blist) == True

        alist = [
            Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd'),
            Recording(mbid='73a9d0db-0ec7-490e-9a85-0525a5ccef8e')
        ]
        blist = [Release(mbid='a1c35a51-d102-4ce7-aefb-79a361e843b6')]
        with self.assertRaises(TypeError):
            troi.operations._ensure_conformity(alist, blist)
Ejemplo n.º 3
0
    def read(self, inputs):
        print("  annoy: read for %s/%s" % (self.metric, self.mbid))

        url = self.SERVER_URL + self.metric + "/" + self.mbid
        r = requests.get(url)
        if r.status_code != 200:
            r.raise_for_status()

        try:
            results = ujson.loads(r.text)
        except Exception as err:
            raise RuntimeError(str(err))

        entities = []
        for row in results:
            r = Recording(mbid=row['recording_mbid'],
                          acousticbrainz={
                              'similarity': row['distance'],
                              'offset': row['offset']
                          })
            r.add_note("Related to %s" % self.mbid)
            entities.append(r)

        print("  annoy: read %d recordings" % len(entities))

        return entities
    def read(self, inputs):
        self.debug("read for %s/%s" % (self.metric, self.mbid))

        url = self.SERVER_URL + self.metric + "/" + self.mbid
        self.debug(f"url: {url}")
        r = requests.get(url, params={'remove_dups': 'true'})
        if r.status_code != 200:
            raise PipelineError("Cannot fetch annoy similarities from AcousticBrainz: HTTP code %d" % r.status_code)

        try:
            results = ujson.loads(r.text)
        except ValueError as err:
            raise PipelineError("Cannot fetch annoy similarities from AcousticBrainz: Invalid JSON returned: " + str(err))

        entities = []
        for row in results:
            r = Recording(mbid=row['recording_mbid'], 
                          acousticbrainz={
                              'metric': self.metric,
                              'similarity_from': self.mbid,
                              'similarity': row['distance'], 
                              'offset': row['offset']
                          }
                          )
            r.add_note("Related to %s with metric %s" % (self.mbid, self.metric))
            entities.append(r)

        self.debug("read %d recordings" % len(entities))

        return entities
    def test_artist_credit_filter_include(self):
        rlist = [ Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd', artist=Artist(artist_credit_id=65)), 
                  Recording(mbid='73a9d0db-0ec7-490e-9a85-0525a5ccef8e', artist=Artist(artist_credit_id=197)) ]
        alist = [ 197 ]

        e = troi.filters.ArtistCreditFilterElement(alist, include=True)
        flist = e.read([rlist])
        assert len(flist) == 1
        assert flist[0].artist.artist_credit_id == 197
        assert flist[0].mbid == "73a9d0db-0ec7-490e-9a85-0525a5ccef8e"

        alist = [ 1 ]
        e = troi.filters.ArtistCreditFilterElement(alist, include=True)
        flist = e.read([rlist])
        assert len(flist) == 0
Ejemplo n.º 6
0
    def read(self, inputs):

        data = [{
            'area_id': self.area_id,
            'start_year': self.start_year,
            'end_year': self.end_year
        }]
        r = requests.post(self.SERVER_URL, json=data)
        if r.status_code != 200:
            raise PipelineError(
                "Cannot fetch area random recordings from ListenBrainz. HTTP code %s"
                % r.status_code)

        try:
            rows = ujson.loads(r.text)
        except ValueError as err:
            raise PipelineError(
                "Cannot fetch area random recordings from ListenBrainz. Invalid JSON returned: "
                + str(err))

        recordings = []
        for row in rows:
            recordings.append(
                Recording(mbid=row['recording_mbid'],
                          name=row['recording_name'],
                          year=row['year'],
                          artist=Artist(
                              name=row['artist_credit_name'],
                              artist_credit_id=row['artist_credit_id'])))

        return recordings
Ejemplo n.º 7
0
    def read(self, inputs=[]):
        recording_list = []

        remaining = self.MAX_RECORDINGS_TO_FETCH if self.count < 0 else self.count
        while True:
            try:
                recordings = self.client.get_user_recommendation_recordings(
                    self.user_name,
                    self.artist_type,
                    count=min(MAX_NUM_RECORDINGS_PER_REQUEST, remaining),
                    offset=self.offset + len(recording_list))
            except (requests.exceptions.HTTPError,
                    pylistenbrainz.errors.ListenBrainzAPIException) as err:
                if not str(err):
                    err = "Does the user '%s' exist?" % self.user_name
                raise PipelineError(
                    "Cannot fetch recommeded tracks from ListenBrainz: " +
                    str(err))

            if not recordings or not len(recordings['payload']['mbids']):
                break

            for r in recordings['payload']['mbids']:
                recording_list.append(
                    Recording(mbid=r['recording_mbid'], ranking=r['score']))

            remaining -= len(recordings['payload']['mbids'])
            if remaining <= 0:
                break

        if recordings:
            self._last_updated = recordings['payload']['last_updated']

        return recording_list
    def test_union(self):
        # Test artists
        alist = [Artist(mbids=['8756f690-18ca-488d-a456-680fdaf234bd'])]
        blist = [Artist(mbids=['a1c35a51-d102-4ce7-aefb-79a361e843b6'])]
        e = troi.operations.UnionElement()
        ulist = e.read([alist, blist])
        assert len(ulist) == 2
        assert ulist[0].mbids == ['8756f690-18ca-488d-a456-680fdaf234bd']
        assert ulist[1].mbids == ['a1c35a51-d102-4ce7-aefb-79a361e843b6']

        # Test recording (not testing release since rel and rec use same code)
        alist = [Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd')]
        blist = [Recording(mbid='a1c35a51-d102-4ce7-aefb-79a361e843b6')]
        ulist = e.read([alist, blist])
        assert len(ulist) == 2
        assert ulist[0].mbid == '8756f690-18ca-488d-a456-680fdaf234bd'
        assert ulist[1].mbid == 'a1c35a51-d102-4ce7-aefb-79a361e843b6'
    def test_unique(self):
        # Test artists
        alist = [
            Artist(mbids=['8756f690-18ca-488d-a456-680fdaf234bd']),
            Artist(mbids=['a1c35a51-d102-4ce7-aefb-79a361e843b6'])
        ]
        e = troi.operations.UniqueElement('mbids')
        u_alist = e.read([alist])
        assert len(u_alist) == 2

        alist = [
            Artist(mbids=['8756f690-18ca-488d-a456-680fdaf234bd']),
            Artist(mbids=['8756f690-18ca-488d-a456-680fdaf234bd'])
        ]
        e = troi.operations.UniqueElement('mbids')
        u_alist = e.read([alist])
        assert len(u_alist) == 1
        assert u_alist[0].mbids == ['8756f690-18ca-488d-a456-680fdaf234bd']

        alist = [Artist(artist_credit_id=65), Artist(artist_credit_id=65)]
        e = troi.operations.UniqueElement('artist_credit_id')
        u_alist = e.read([alist])
        assert len(u_alist) == 1
        assert u_alist[0].artist_credit_id == 65

        # Test recording (not testing release since rel and rec use same code)
        rlist = [
            Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd'),
            Recording(mbid='a1c35a51-d102-4ce7-aefb-79a361e843b6')
        ]
        e = troi.operations.UniqueElement('mbids')
        with self.assertRaises(ValueError):
            u_rlist = e.read([rlist])

        e = troi.operations.UniqueElement('mbid')
        u_rlist = e.read([rlist])
        assert len(u_rlist) == 2

        rlist = [
            Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd'),
            Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd')
        ]
        u_rlist = e.read([rlist])
        assert len(u_rlist) == 1
        assert u_rlist[0].mbid == '8756f690-18ca-488d-a456-680fdaf234bd'
    def test_artist_credit_filter(self):
        rlist = [
            Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd',
                      artist=Artist(artist_credit_id=65)),
            Recording(mbid='73a9d0db-0ec7-490e-9a85-0525a5ccef8e',
                      artist=Artist(artist_credit_id=197))
        ]
        alist = [Artist(artist_credit_id=65)]

        e = troi.operations.ArtistCreditFilterElement()
        flist = e.read([rlist, alist])
        assert len(flist) == 1
        assert flist[0].artist.artist_credit_id == 65
        assert flist[0].mbid == "8756f690-18ca-488d-a456-680fdaf234bd"

        alist = [Artist(artist_credit_id=1)]
        flist = e.read([rlist, alist])
        assert len(flist) == 0
Ejemplo n.º 11
0
    def read(self, inputs=[]):
        recording_list = []
        recordings = self.client.get_user_recommendation_recordings(
            self.user_name, self.artist_type, self.count, self.offset)

        artist_type = self.artist_type + "_artist"
        for r in recordings['payload']['mbids']:
            recording_list.append(
                Recording(mbid=r[0], listenbrainz={'rating': r[1]}))

        return recording_list
    def test_artist_credit_limiter_higher_ranked(self):
        rlist = [ Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd', artist=Artist(artist_credit_id=65), ranking=1.0), 
                  Recording(mbid='139654ae-2c02-4e0f-aee0-c47da6e59ff1', artist=Artist(artist_credit_id=65), ranking=.5), 
                  Recording(mbid='73a9d0db-0ec7-490e-9a85-0525a5ccef8e', artist=Artist(artist_credit_id=197), ranking=.1) ]

        e = troi.filters.ArtistCreditLimiterElement(1)
        flist = e.read([rlist])
        assert len(flist) == 2
        assert flist[0].artist.artist_credit_id == 65
        assert flist[0].mbid == "8756f690-18ca-488d-a456-680fdaf234bd"
        assert flist[1].artist.artist_credit_id == 197
        assert flist[1].mbid == "73a9d0db-0ec7-490e-9a85-0525a5ccef8e"

        e = troi.filters.ArtistCreditLimiterElement(1, exclude_lower_ranked=False)
        flist = e.read([rlist])
        assert len(flist) == 2
        assert flist[0].artist.artist_credit_id == 65
        assert flist[0].mbid == "139654ae-2c02-4e0f-aee0-c47da6e59ff1"
        assert flist[1].artist.artist_credit_id == 197
        assert flist[1].mbid == "73a9d0db-0ec7-490e-9a85-0525a5ccef8e"
    def test_intersection(self):
        # Test artists
        alist = [
            Artist(mbids=['8756f690-18ca-488d-a456-680fdaf234bd']),
            Artist(mbids=['73a9d0db-0ec7-490e-9a85-0525a5ccef8e'])
        ]
        blist = [Artist(mbids=['8756f690-18ca-488d-a456-680fdaf234bd'])]
        e = troi.operations.IntersectionElement('mbid')
        with self.assertRaises(ValueError):
            ilist = e.read([alist, blist])

        e = troi.operations.IntersectionElement('mbids')
        ilist = e.read([alist, blist])
        assert len(ilist) == 1
        assert ilist[0].mbids == blist[0].mbids

        alist = [Artist(mbids=['73a9d0db-0ec7-490e-9a85-0525a5ccef8e'])]
        blist = [Artist(mbids=['8756f690-18ca-488d-a456-680fdaf234bd'])]
        ilist = e.read([alist, blist])
        assert len(ilist) == 0

        # Test recording (not testing release since rel and rec use same code)
        alist = [
            Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd'),
            Recording(mbid='73a9d0db-0ec7-490e-9a85-0525a5ccef8e')
        ]
        blist = [Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd')]
        e = troi.operations.IntersectionElement('mbids')
        with self.assertRaises(ValueError):
            ilist = e.read([alist, blist])

        e = troi.operations.IntersectionElement('mbid')
        ilist = e.read([alist, blist])
        assert len(ilist) == 1
        assert ilist[0].mbid == blist[0].mbid

        alist = [Recording(mbid='73a9d0db-0ec7-490e-9a85-0525a5ccef8e')]
        blist = [Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd')]
        ilist = e.read([alist, blist])
        assert len(ilist) == 0
Ejemplo n.º 14
0
    def test_recording(self):

        r = Recording()
        assert r.mbid == None
        assert r.msid == None
        assert r.name == None

        r = Recording("Strangers", "8fe3f1d4-b6d5-4726-89ad-926e3420b9e3",
                      "97b01626-65fc-4c32-b30c-c4d7eab1b339")
        assert r.name == "Strangers"
        assert r.mbid == "8fe3f1d4-b6d5-4726-89ad-926e3420b9e3"
        assert r.msid == "97b01626-65fc-4c32-b30c-c4d7eab1b339"

        r = Recording(listenbrainz={1: 2},
                      musicbrainz={3: 4},
                      acousticbrainz={5: 6})
        assert r.lb[1] == 2
        assert r.mb[3] == 4
        assert r.ab[5] == 6
        assert r.name == None
        assert r.mbid == None
        assert r.msid == None
Ejemplo n.º 15
0
    def test_year_sort_element(self):
        rlist = [
            Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd', year=1980),
            Recording(mbid='73a9d0db-0ec7-490e-9a85-0525a5ccef8e', year=1970),
            Recording(mbid='07316967-cfcb-4920-b8ca-e96dcb4afc08'),
            Recording(mbid='88b433b3-2c4f-4c8b-839b-77a203ec950f', year=1990)
        ]

        e = troi.sorts.YearSortElement()
        flist = e.read([rlist])
        assert len(flist) == 4
        assert flist[0].mbid == '73a9d0db-0ec7-490e-9a85-0525a5ccef8e'
        assert flist[1].mbid == '8756f690-18ca-488d-a456-680fdaf234bd'
        assert flist[2].mbid == '88b433b3-2c4f-4c8b-839b-77a203ec950f'
        assert flist[3].mbid == '07316967-cfcb-4920-b8ca-e96dcb4afc08'

        e = troi.sorts.YearSortElement(reverse=True)
        flist = e.read([rlist])
        assert len(flist) == 4
        assert flist[0].mbid == '07316967-cfcb-4920-b8ca-e96dcb4afc08'
        assert flist[1].mbid == '88b433b3-2c4f-4c8b-839b-77a203ec950f'
        assert flist[2].mbid == '8756f690-18ca-488d-a456-680fdaf234bd'
        assert flist[3].mbid == '73a9d0db-0ec7-490e-9a85-0525a5ccef8e'
    def test_consecutive_recording_filter_element(self):
        rlist = [Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd'),
                 Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd'),
                 Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd'),
                 Recording(mbid='139654ae-2c02-4e0f-aee0-c47da6e59ff1'),
                 Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd'),
                 Recording(mbid='73a9d0db-0ec7-490e-9a85-0525a5ccef8e'),
                 Recording(mbid='73a9d0db-0ec7-490e-9a85-0525a5ccef8e'),
                 Recording(mbid='139654ae-2c02-4e0f-aee0-c47da6e59ff1')]
        e = troi.filters.ConsecutiveRecordingFilterElement()
        flist = e.read([rlist])
        assert len(flist) == 5

        assert flist[0].mbid == '8756f690-18ca-488d-a456-680fdaf234bd'
        assert flist[1].mbid == '139654ae-2c02-4e0f-aee0-c47da6e59ff1'
        assert flist[2].mbid == '8756f690-18ca-488d-a456-680fdaf234bd'
        assert flist[3].mbid == '73a9d0db-0ec7-490e-9a85-0525a5ccef8e'
        assert flist[4].mbid == '139654ae-2c02-4e0f-aee0-c47da6e59ff1'
    def test_difference(self):
        # Test artists
        alist = [
            Artist(mbids=['8756f690-18ca-488d-a456-680fdaf234bd']),
            Artist(mbids=['73a9d0db-0ec7-490e-9a85-0525a5ccef8e'])
        ]
        blist = [Artist(mbids=['8756f690-18ca-488d-a456-680fdaf234bd'])]
        e = troi.operations.DifferenceElement('mbid')
        with self.assertRaises(ValueError):
            ilist = e.read([alist, blist])

        e = troi.operations.DifferenceElement('mbids')
        ilist = e.read([alist, blist])
        assert len(ilist) == 1
        assert ilist[0].mbids == ['73a9d0db-0ec7-490e-9a85-0525a5ccef8e']

        alist = [
            Artist(mbids=['8756f690-18ca-488d-a456-680fdaf234bd']),
            Artist(mbids=['73a9d0db-0ec7-490e-9a85-0525a5ccef8e'])
        ]
        blist = [Artist(mbids=['a1c35a51-d102-4ce7-aefb-79a361e843b6'])]
        dlist = e.read([alist, blist])
        assert len(dlist) == 2
        assert dlist[0].mbids == ['8756f690-18ca-488d-a456-680fdaf234bd']
        assert dlist[1].mbids == ['73a9d0db-0ec7-490e-9a85-0525a5ccef8e']

        # Test recording (not testing release since rel and rec use same code)
        alist = [
            Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd'),
            Recording(mbid='73a9d0db-0ec7-490e-9a85-0525a5ccef8e')
        ]
        blist = [Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd')]
        e = troi.operations.DifferenceElement('mbids')
        with self.assertRaises(ValueError):
            ilist = e.read([alist, blist])

        e = troi.operations.DifferenceElement('mbid')
        ilist = e.read([alist, blist])
        assert len(ilist) == 1
        assert ilist[0].mbid == '73a9d0db-0ec7-490e-9a85-0525a5ccef8e'

        alist = [
            Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd'),
            Recording(mbid='73a9d0db-0ec7-490e-9a85-0525a5ccef8e')
        ]
        blist = [Recording(mbid='a1c35a51-d102-4ce7-aefb-79a361e843b6')]
        dlist = e.read([alist, blist])
        assert len(dlist) == 2
        assert dlist[0].mbid == '8756f690-18ca-488d-a456-680fdaf234bd'
        assert dlist[1].mbid == '73a9d0db-0ec7-490e-9a85-0525a5ccef8e'
Ejemplo n.º 18
0
    def test_playlist(self):

        r = Playlist()
        assert r.mbid is None
        assert r.name is None
        assert r.filename is None
        assert r.recordings == None

        p = Playlist("cooking playlist", "8fe3f1d4-b6d5-4726-89ad-926e3420b9e3", "mk_noms.jspf")
        assert p.name == "cooking playlist"
        assert p.mbid == "8fe3f1d4-b6d5-4726-89ad-926e3420b9e3"
        assert p.filename == "mk_noms.jspf"
        assert p.recordings == None

        r = Recording("Strangers", "8fe3f1d4-b6d5-4726-89ad-926e3420b9e3", "97b01626-65fc-4c32-b30c-c4d7eab1b339")
        p = Playlist("eating playlist", "8fe3f1d4-b6d5-4726-89ad-926e3420b9e3", "omnomnom.jspf", [r])
        assert p.name == "eating playlist"
        assert p.mbid == "8fe3f1d4-b6d5-4726-89ad-926e3420b9e3"
        assert p.filename == "omnomnom.jspf"
        assert p.recordings == [r]
Ejemplo n.º 19
0
    def read(self, inputs=[]):
        recording_list = []
        recordings = self.client.get_user_recordings(self.user_name,
                                                     self.count, self.offset,
                                                     self.time_range)
        for r in recordings['payload']['recordings']:
            artist = Artist(r['artist_name'],
                            mbids=r['artist_mbids'],
                            msid=r['artist_msid'])
            release = Release(r['release_name'],
                              mbid=r['release_mbid'],
                              msid=r['release_msid'])
            recording_list.append(
                Recording(r['track_name'],
                          mbid=r['recording_mbid'],
                          msid=r['recording_msid'],
                          artist=artist,
                          release=release))

        return recording_list
    def test_artist_credit_limiter_playlist(self):
        p = Playlist("test playlist")
        p.recordings = [ Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd', artist=Artist(artist_credit_id=65), ranking=1.0), 
                         Recording(mbid='139654ae-2c02-4e0f-aee0-c47da6e59ff1', artist=Artist(artist_credit_id=65), ranking=.5), 
                         Recording(mbid='73a9d0db-0ec7-490e-9a85-0525a5ccef8e', artist=Artist(artist_credit_id=197), ranking=.1) ]

        p2 = Playlist("test playlist 2")
        p2.recordings = [ Recording(mbid='8756f690-18ca-488d-a456-680fdaf234bd', artist=Artist(artist_credit_id=48), ranking=1.0), 
                          Recording(mbid='73a9d0db-0ec7-490e-9a85-0525a5ccef8e', artist=Artist(artist_credit_id=197), ranking=.1), 
                          Recording(mbid='139654ae-2c02-4e0f-aee0-c47da6e59ff1', artist=Artist(artist_credit_id=48), ranking=.5)]

        e = troi.filters.ArtistCreditLimiterElement(1)
        plist = e.read([[p, p2]])
        assert len(plist) == 2
        assert len(plist[0].recordings) == 2
        assert plist[0].recordings[0].artist.artist_credit_id == 65
        assert plist[0].recordings[0].mbid == "8756f690-18ca-488d-a456-680fdaf234bd"
        assert plist[0].recordings[1].artist.artist_credit_id == 197
        assert plist[0].recordings[1].mbid == "73a9d0db-0ec7-490e-9a85-0525a5ccef8e"
        assert len(plist[1].recordings) == 2
        assert plist[1].recordings[0].artist.artist_credit_id == 48
        assert plist[1].recordings[0].mbid == "8756f690-18ca-488d-a456-680fdaf234bd"
        assert plist[1].recordings[1].artist.artist_credit_id == 197
        assert plist[1].recordings[1].mbid == "73a9d0db-0ec7-490e-9a85-0525a5ccef8e"