def get_images(self, uris):
if type(uris) in {str, unicode}:
uris = [uris]
# Add bluetooth image to BT URIs
images = {}
for uri in uris:
if uri.startswith(BTPlayerUri.BT_SONG):
images[uri] = [models.Image(**ICON_BT)]
elif uri.startswith(BTPlayerUri.BT_DEVICE):
# TODO: Different images per device type (phone, pc, etc)
images[uri] = [models.Image(**ICON_BT)]
elif uri == BTPlayerUri.BT_SCAN:
images[uri] = [models.Image(**ICON_BT)]
else:
images[uri] = []
return images
def get_images(self, uris):
result = {}
for uri in uris:
image_uris = set()
try:
track = self.lookup_pandora_track(uri)
if track.is_ad is True:
image_uri = track.image_url
else:
image_uri = track.album_art_url
if image_uri:
image_uris.update([image_uri])
except (TypeError, KeyError):
pandora_uri = PandoraUri.factory(uri)
if isinstance(pandora_uri, TrackUri):
# Could not find the track as expected - exception.
logger.exception(
"Failed to lookup image for Pandora URI '{}'.".format(
uri))
else:
# Lookup
logger.warning(
"No images available for Pandora URIs of type '{}'.".
format(pandora_uri.uri_type))
pass
result[uri] = [models.Image(uri=u) for u in image_uris]
return result
def test_images(rss):
assert dict(rss.images()) == {
'podcast+http://www.example.com/everything.xml': [
models.Image(uri='http://example.com/everything/Podcast.jpg')
],
'podcast+http://www.example.com/everything.xml#episode3': [
models.Image(uri='http://example.com/everything/Episode3.jpg')
],
'podcast+http://www.example.com/everything.xml#episode2': [
models.Image(uri='http://example.com/everything/Episode2.jpg')
],
('podcast+http://www.example.com/everything.xml'
'#http://example.com/everything/Episode1.mp3'): [
models.Image(uri='http://example.com/everything/Podcast.jpg')
]
}
def get_image(self, item_id):
url = f'{self.hostname}/Items/{item_id}/Images/Primary'
# Verify if image exists instead of returning bad URLs
image = self.http.head(item_id, url)
if image:
return models.Image(uri=url, )
else:
return []
def test_images(backend, server, items):
with mock.patch.object(backend, "client") as m:
m.servers.return_value = Future.fromvalue([server])
m.server.return_value = Future.fromvalue(server)
m.search.return_value = Future.fromvalue([items, False])
assert backend.library.get_images(item["URI"] for item in items) == {
items[0]["URI"]: (models.Image(uri=items[0]["AlbumArtURL"]), ),
items[1]["URI"]: tuple(),
}
def test_default_get_images_impl_falls_back_to_album_image(self):
album = models.Album(images=['imageuri'])
track = models.Track(uri='trackuri', album=album)
library = dummy_backend.DummyLibraryProvider(backend=None)
library.dummy_library.append(track)
expected = {'trackuri': [models.Image(uri='imageuri')]}
self.assertEqual(library.get_images(['trackuri']), expected)
def get_images(self, uris):
result = dict()
for uri in uris:
_, kind, id = uri.split(":", 2)
if kind == "track":
track = self._track_cache.get(uri)
if track is None:
continue
artwork_uri = "https://" + track.artwork.replace(
"%%", "400x400")
result[uri] = [models.Image(uri=artwork_uri)]
if kind == "playlist":
pass
return result
def get_images(self, uris):
"""
See :meth:`mopidy.core.LibraryController.get_images`.
*MAY be implemented by subclass.*
Default implementation will simply call lookup and try and use the
album art for any tracks returned. Most extensions should replace this
with something smarter or simply return an empty dictionary.
"""
result = {}
for uri in uris:
image_uris = set()
for track in self.lookup(uri):
if track.album and track.album.images:
image_uris.update(track.album.images)
result[uri] = [models.Image(uri=u) for u in image_uris]
return result
def get_images(self, uris):
result = {}
for uri in uris:
image_uris = set()
try:
image_uri = None
pandora_uri = PandoraUri.factory(uri)
logger.info("Retrieving images for Pandora {} {}...".format(
pandora_uri.uri_type, pandora_uri.uri))
if isinstance(pandora_uri, AdItemUri) or isinstance(
pandora_uri, TrackUri):
track = self.lookup_pandora_track(uri)
if track.is_ad is True:
image_uri = track.image_url
else:
image_uri = track.album_art_url
elif isinstance(pandora_uri, StationUri):
# GenreStations don't appear to have artwork available via the
# json API
if not isinstance(pandora_uri, GenreStationUri):
station = self.backend.api.get_station(
pandora_uri.station_id)
image_uri = station.art_url
else:
# Lookup
logger.warning(
"No images available for Pandora URIs of type '{}'.".
format(pandora_uri.uri_type))
if image_uri:
image_uris.update(
[image_uri.replace("http://", "https://", 1)])
except (TypeError, KeyError):
pandora_uri = PandoraUri.factory(uri)
if isinstance(pandora_uri, TrackUri):
# Could not find the track as expected - exception.
logger.exception(
"Failed to lookup image for Pandora URI '{}'.".format(
uri))
result[uri] = [models.Image(uri=u) for u in image_uris]
return result
def get_images(self, uris):
"""
Lookup the images for the given URIs.
The default implementation will simply call :meth:`lookup` and
try and use the album art for any tracks returned. Most local
libraries should replace this with something smarter or simply
return an empty dictionary.
:param list uris: list of URIs to find images for
:rtype: {uri: tuple of :class:`mopidy.models.Image`}
"""
result = {}
for uri in uris:
image_uris = set()
tracks = self.lookup(uri)
# local libraries may return single track
if isinstance(tracks, models.Track):
tracks = [tracks]
for track in tracks:
if track.album and track.album.images:
image_uris.update(track.album.images)
result[uri] = [models.Image(uri=u) for u in image_uris]
return result
def images(obj):
if 'AlbumArtURL' in obj:
return obj['URI'], [models.Image(uri=obj['AlbumArtURL'])]
else:
return obj['URI'], []
def _translate_image(i):
return models.Image(uri=i['url'], height=i['height'], width=i['width'])
"format": "VBR MP3",
"track": "01",
},
{
"name": "cover.jpg",
"format": "JPEG"
},
],
"metadata": {
"identifier": "album",
"title": "Album",
"mediatype": "audio"
},
}
IMAGES = [models.Image(uri=URL)]
def test_root_images(library, client_mock):
results = library.get_images(["internetarchive:"])
client_mock.getitem.assert_not_called()
assert results == {}
def test_album_images(library, client_mock):
client_mock.getitem.return_value = ITEM
client_mock.geturl.return_value = URL
results = library.get_images(["internetarchive:album"])
client_mock.getitem.assert_called_once_with("album")
assert results == {"internetarchive:album": IMAGES}
def _translate_image(i):
return models.Image(uri=i["url"], height=i["height"], width=i["width"])
def _new_image(id, id_type):
return models.Image(
uri=f"http://images.osl.wimpmusic.com/im/im?w=512&h=512&{id_type}={id}",
width=512,
height=512,
)
def images(obj):
if "AlbumArtURL" in obj:
return obj["URI"], [models.Image(uri=str(obj["AlbumArtURL"]))]
else:
return obj["URI"], []
def __image(cls, etree):
elem = etree.find(cls.ITUNES_PREFIX + 'image')
if elem is not None:
return models.Image(uri=elem.get('href'))
else:
return None
