Plugins: albumart2.1.py

#Copyright 2005 Eduardo Gonzalez, Niklas Janlert, Christoph Reiter
#Amazon API code by Mark Pilgrim
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License version 2 as
# published by the Free Software Foundation

import os
import sys
import urllib
import urllib2
import re
import time
import threading
from cStringIO import StringIO
import gtk
import gobject
import pango
import util
import qltk
import config

from plugins.songsmenu import SongsMenuPlugin

if sys.version_info < (2, 4): from sets import Set as set

try:
    import amazon
except ImportError:
    import _amazon as amazon

class AlbumArtWindow(gtk.Window):
    def __init__(self, songs):
        gtk.Window.__init__(self)
        self.set_border_width(12)
        self.set_title("AlbumArt")
        self.set_default_size(720, 450)

        #TreeView stuff
        self.liststore = liststore = gtk.ListStore(object, str)
        treeview = gtk.TreeView(liststore)
        treeview.set_headers_visible(False)
        selection = treeview.get_selection()
        selection.set_mode(gtk.SELECTION_SINGLE)
        selection.connect("changed", self.__preview)

        rend = gtk.CellRendererPixbuf()
        def cell_data(column, cell, model, iter):
            cell.set_property("pixbuf", model[iter][0]["thumb"])
        tvcol1 = gtk.TreeViewColumn("Pixbuf", rend)
        tvcol1.set_cell_data_func(rend, cell_data)
        tvcol1.set_sizing(gtk.TREE_VIEW_COLUMN_GROW_ONLY)
        rend.set_property('xpad', 2)
        rend.set_property('ypad', 2)
        rend.set_property('width', 56)
        rend.set_property('height', 56)
        treeview.append_column(tvcol1)

        rend = gtk.CellRendererText()
        rend.set_property("ellipsize", pango.ELLIPSIZE_END)
        tvcol2 = gtk.TreeViewColumn("Info", rend, markup=1)
        treeview.append_column(tvcol2)

        sw = gtk.ScrolledWindow()
        sw.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
        sw.set_shadow_type(gtk.SHADOW_IN)
        sw.add(treeview)

        #Image frame and save button
        self.image = image = gtk.Image()
        frame = gtk.Frame()
        frame.set_shadow_type(gtk.SHADOW_IN)
        frame.add(image)
        scrolled = gtk.ScrolledWindow()
        scrolled.add_with_viewport(frame)
        scrolled.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
        vbox = gtk.VBox(spacing=5)
        vbox.pack_start(scrolled)
        self.button = button = gtk.Button(stock=gtk.STOCK_SAVE)
        button.set_sensitive(False)
        def save_cb(button, combo):
            model, path = selection.get_selected()
            data = model[path][0]["cover_data"]
            fname = self.__get_fname(songs, combo)
            self.__save_cover(data, fname)
        combo = gtk.combo_box_new_text()
        try: set_fn = config.get("plugins", "cover_fn")
        except: set_fn = ".folder.jpg"
        active = -1
        for i, fn in enumerate([".folder.jpg", "folder.jpg", "cover.jpg"]):
            combo.append_text(fn)
            if fn == set_fn: active = i
        if active == -1:
            combo.append_text(set_fn)
            combo.set_active(len(combo.get_model()) - 1)
        else: combo.set_active(active)
        button.connect("clicked", save_cb, combo)
        bbox = gtk.HButtonBox()
        bbox.pack_start(combo)
        bbox.pack_start(button, expand=False, fill=False)
        bbox.set_layout(gtk.BUTTONBOX_SPREAD)
        vbox.pack_start(bbox, expand=False, fill=False)

        hpaned = gtk.HPaned()
        hpaned.pack1(sw)
        hpaned.pack2(vbox)
        hpaned.set_position(300)
        self.add(hpaned)

        #define search engnines
        self.engines = [self.__search_amazon, self.__search_walmart,
                        self.__search_darktown, self.__search_itunes]

        #max covers per site
        self.max_albums = 4
        
        #for progress calculation
        self.progress = 0
        
        #use albumartist if available
        if songs[0]("albumartist"):
            artist = songs[0]("albumartist")
        else:
            artist = songs[0]("artist")
        query = artist + " " + songs[0]("album")
        query = query.encode("latin1", "replace")
        
        #show search status row
        iter = self.liststore.insert(0)
        self.liststore.set(iter, 0, {"bag":None,"thumb":None,"thumb_data":None})
        self.liststore.set_value(iter, 1,
                                 "<i><b>Searching progress: 0%</b></i>")

        #start all search engines in seperate threads
        for i in xrange(len(self.engines)):
            thread = threading.Thread(target=self.__search,
                                      args=(query,i,iter,))
            thread.setDaemon(True)
            thread.start()

        self.show_all()

    def __search(self, query, num, iter):

        try:
            bags = self.engines[num](query)
            for bag in bags:
                gobject.idle_add(self.__add_bag, self.liststore, bag)
        except:
            pass
        
        self.progress += 1
        self.liststore.set_value(iter, 1, "<i><b>Searching progress: "
                                 +str(self.progress*100/len(self.engines))
                                 +"%</b></i>")

        if self.progress == len(self.engines):
            time.sleep(2)
            if self.liststore.iter_next(iter) == None:
                self.liststore.set_value(iter, 1,
                                         "<i><b>No albumart found</b></i>")
            else:
                self.liststore.remove(iter)
            
                

    def __search_amazon(self, query):
        amazon.setLicense("0RKH4ZH1JCFZHMND91G2")
        try:
            bags = amazon.searchByKeyword(
                query, type="lite", product_line="music")
        except:
            pass
        else:
            #delete products with no images and return the rest
            count=0
            while count < self.max_albums and count < len(bags):
                if len(bags[count].ImageUrlLarge) and \
                   len(bags[count].ImageUrlSmall):
                    count+=1
                else:
                    del bags[count]
            return bags[:self.max_albums]
        return []
            
    def __search_darktown(self, query):
        class item: pass
        bags = []
        
        #Artists @ Darkdown often miss the leading "The", better remove it
        #for better search results - also ' and . should be removed
        if query[:4] == "The ":
            query = query[4:]
        query = query.replace("'"," ")
        query = query.replace(".","")
        
        mainUrl = urllib.urlopen('http://www.darktown.to/search.php?'
                'action=search&what='+urllib.quote(query)+'&category=audio')
        mainData = mainUrl.read()
        mainRe = re.findall('javascript:openCentered\(\'(.*?)Front\'', mainData)
        
        count = 0
        for result in mainRe:
            if count >= self.max_albums: break
            count += 1
            
            resultUrl = urllib.urlopen('http://www.darktown.to'+result+'Front')
            resultData = resultUrl.read()

            resultImgBig = re.findall('href="(.*?)">DOWNLOAD</a>', resultData)
            resultImgSmall = re.findall('src="(.*?)"', resultData)
            resultArtist = re.findall('<b><font size=4>(.*?)</font', resultData)
            resultTitle = re.findall('</font></b><br><b>(.*?)</b><br><br><b>',
                                     resultData)

            cover = item()
            cover.ImageUrlSmall = resultImgSmall[0]
            cover.ImageUrlLarge = resultImgBig[0]
            cover.Artists = item()
            cover.Artists.Artist = resultArtist[0].decode("latin1", "replace")
            cover.ProductName = resultTitle[0].decode("latin1", "replace")
            
            bags.append(cover)
 
        return bags
    
    def __search_itunes(self, query):
        class item: pass
        bags = []
        
        #search for music product in itunes store
        mainUrl = urllib.urlopen('http://ax.phobos.apple.com.edgesuite.net/'
                             'WebObjects/MZStoreServices.woa/wa/itmsSearch?'
                             'media=music&term='+query.replace(' ','+'))
        mainData = mainUrl.read()
        p = re.compile('<TD class="searchResults" WIDTH="232" HEIGHT="20">'
                       '(.*?)</FONT></TD>', re.DOTALL)
        filterRe = re.findall(p, mainData)
        if not len(filterRe):
            return bags
        linkRe = re.findall('<a class="searchResults" href="(.*?)">',
                            filterRe[0])

        #follow the link and extract the shop url and the product title
        subUrl = urllib.urlopen('http://ax.phobos.apple.com.edgesuite.net'
                             +linkRe[0].replace('&amp;','&'))
        subData = subUrl.read()
        subRe = re.findall('<a href="(.*?)">',subData)

        name = re.findall('<img height="15" width="61" alt="(.*?)"',subData)
        name = name[0].split(' - ')

        #now use the joshers or tpembles php-script to get the actual image
        #FIXME: code from http://tpemble.urfbownd.net/itunes/
        #should be ported to python and included here...
        
        try:
            #joshers: 
            params = urllib.urlencode({'url': subRe[0]})
            url = urllib.urlopen('http://www.thejosher.net/iTunes/methodtwo.php'
                                 , params)
            data = url.read()
            links = re.findall('<a href="http://a1.phobos.(.*?).jpg">'
                               ,data)
        except:    
            #tpembles: (slower server, but just in case the other one goes off)
            params = urllib.urlencode({'url': subRe[0]})
            url = urllib.urlopen('http://tpemble.urfbownd.net/itunes/'
                                 'itunes-art.php', params)
            data = url.read()
            links = re.findall('<a href="http://a1.phobos.(.*?).170x170-75'
                               '.jpg">', data)

        image_large = 'http://a1.phobos.'+links[0]+'.jpg'
        image_small = 'http://a1.phobos.'+links[0]+'.60x60-50.jpg'

        #sometimes the image is a tif and no jpg.. 404 will be raised
        try:
            urllib2.urlopen(image_large)
            urllib2.urlopen(image_small)
        except:
            return bags

        #add the albumart to the list
        cover = item()
        cover.ImageUrlSmall = image_small 
        cover.ImageUrlLarge = image_large
        cover.Artists = item()
        cover.Artists.Artist = name[0]
        cover.ProductName = name[1]

        bags.append(cover)

        return bags
        
    def __search_walmart(self, query):
        class item: pass
        bags = []

        mainUrl = urllib.urlopen('http://www.walmart.com/search/search-ng.do?'
                                 'search_constraint=4104&search_query='
                                 +urllib.quote(query)+'&ic='
                                 +str(self.max_albums)+'_0')

        mainData = mainUrl.read()
        
        #abort if nothing was found
        if mainData.find('no matches found') != -1 or \
            mainData.find('not find any matches') != -1:
            return bags
        
        countRe = re.findall('<h1>(\d*) items found for', mainData)

        #walmart will redirect to the specific album page
        #if the query exactly matches the product title ... so 2 ways needed
        if len(countRe):
        
            #abort if it returns too much shit
            if int(countRe[0]) > 50:
                return bags
                
            mainRe = re.findall('<div class="ItemPic"><a href=\'.*?\'><img src='
                                '\'(.*?)\' width="60" height="60" border="0" '
                                'alt=\'(.*?)\'', mainData)
        
            artistRe = re.findall('Artist: <span class="BodySLtgry">'
                                  '(<a href=\'.*?\'>|)(.*?)(</a>|)</span>',
                                  mainData)
            
            for num in xrange(len(mainRe)):  
                cover = item()
                cover.ImageUrlSmall = mainRe[num][0]
                cover.ImageUrlLarge = mainRe[num][0][:-9]+"500X500.jpg"
                cover.Artists = item()
                cover.Artists.Artist = artistRe[num][1]
                cover.ProductName = mainRe[num][1]
                
                bags.append(cover)
            
        else:
            mainRe = re.findall('<img src=\'(.*?)\' width="150" height="150" '
                                'border="0" alt=\'(.*?)\'', mainData)
            artistRe = re.findall('<span class="BodyXSLtgry">&gt;</span>&nbsp;'
                                  '<a href=".*?">(.*?)</a>&nbsp;\s*', mainData)
         
            cover = item()
            cover.ImageUrlSmall = mainRe[0][0][:-11]+"60X60.gif"
            cover.ImageUrlLarge = mainRe[0][0][:-11]+"500X500.jpg"
            cover.Artists = item()
            cover.Artists.Artist = artistRe[-1]
            cover.ProductName = mainRe[0][1]
            
            bags.append(cover)
            
        return bags

    def __add_bag(self, model, bag):
        # Text part
        title = util.escape(getattr(bag, "ProductName", ""))
        artist = (getattr(bag, "Artists", None) and 
                  getattr(bag.Artists, "Artist", None) or "")
        if isinstance(artist, list):
            artist = ", ".join(artist)
        artist = util.escape(artist)
        if hasattr(bag, "ReleaseDate"):
            date = "(%s)" %util.escape(bag.ReleaseDate)
        else:
            date = ""
        markup = "<i><b>%s</b></i> %s\n%s" %(title, date, artist)

        item = {"bag": bag, "thumb": None, "thumb_data": ""}
        iter = model.append([item, markup])

        # Image part
        urlinfo = urllib.urlopen(bag.ImageUrlSmall)
        sock = urlinfo.fp._sock
        sock.setblocking(0)
        data = StringIO()

        loader = gtk.gdk.PixbufLoader()
        loader.connect("closed", self.__got_thumb_cb, data, item, model, iter)

        gobject.io_add_watch(
            sock, gobject.IO_IN | gobject.IO_ERR | gobject.IO_HUP, 
            self.__copy_image, loader, data)

    def __got_thumb_cb(self, loader, data, item, model, iter):
        cover = loader.get_pixbuf()
        if cover.get_width() > 1:
            w = h = 48
            cover = cover.scale_simple(w, h, gtk.gdk.INTERP_NEAREST)
            thumb = gtk.gdk.Pixbuf(
                gtk.gdk.COLORSPACE_RGB, True, 8, w + 2, h + 2)
            thumb.fill(0x000000ff)
            cover.copy_area(0, 0, w, h, thumb, 1, 1)
            item["thumb"] = thumb
            item["thumb_data"] = data.getvalue()
            model.row_changed(model.get_path(iter), iter)
        
    def __preview(self, selection):
        model, path = selection.get_selected()
        try:
            item = model[path][0]
        except:
            return
        self.image.hide()
        self.button.set_sensitive(False)
        
        if item["thumb"]: # If there exists no thumbnail, then nothing bigger.
            if "cover" not in item:
                self.__get_cover(item, item["bag"].ImageUrlLarge)
            else:
                self.image.set_from_pixbuf(item["cover"])
                self.image.show()
                self.button.set_sensitive(True)

    def __get_cover(self, item, url):
        data = StringIO()
        urlinfo = urllib.urlopen(url)
        sock = urlinfo.fp._sock
        sock.setblocking(0)
        loader = gtk.gdk.PixbufLoader()
        gobject.io_add_watch(
            sock, gobject.IO_IN | gobject.IO_ERR | gobject.IO_HUP, 
            self.__copy_image, loader, data)
        loader.connect("closed", self.__got_cover_cb, data, item, url)
        def update(loader, x, y, w, h, image):
            if (w, h) > (1, 1):
                image.set_from_pixbuf(loader.get_pixbuf())
                image.show()
        loader.connect("area-updated", update, self.image)

    def __got_cover_cb(self, loader, data, item, url):
        cover = loader.get_pixbuf()
        # For some reason we get a 1x1 image if the given size didn't exist
        if cover.get_width() > 1:
            item["cover"] = cover
            item["cover_data"] = data.getvalue()
            self.image.set_from_pixbuf(item["cover"])
            self.button.set_sensitive(True)
        elif url == item["bag"].ImageUrlLarge:
            self.__get_cover(item, item["bag"].ImageUrlMedium)
        else:
            item["cover"] = item["thumb"]
            item["cover_data"] = item["thumb_data"]
            self.image.set_from_pixbuf(item["cover"])
            self.button.set_sensitive(True)

    def __copy_image(self, src, condition, loader, data):
        if condition in (gobject.IO_ERR, gobject.IO_HUP):
            loader.close()
            src.close()
            return False
        else: # Read
            buf = src.recv(1024)
            if buf:
                loader.write(buf)
                data.write(buf)
                return True # Run again
            else:
                loader.close()
                src.close()
                return False

    def __save_cover(self, data, fname):
        if os.path.exists(fname) and not qltk.ConfirmAction(None, 
            "File exists", "The file <b>%s</b> already exists."
            "\n\nOverwrite?" %util.escape(fname)).run():
            return

        f = open(fname, "w")
        f.write(data)
        f.close()
        self.destroy()

    def __get_fname(self, songs, combo):
        append = combo.get_model()[(combo.get_active(),)][0]
        dirname = songs[0]("~dirname")
        fname = os.path.join(dirname, append)
        #print "Will save to", fname
        config.set("plugins", "cover_fn", append)
        return fname

class DownloadAlbumArt(SongsMenuPlugin):
    PLUGIN_ID = "Download Album art"
    PLUGIN_NAME = _("Download Album Art")
    PLUGIN_DESC = "Downloads album covers from Amazon.com, " \
                  "Walmart.com, iTunes.com and Darktown.to"
    PLUGIN_ICON = gtk.STOCK_FIND
    PLUGIN_VERSION = "0.25"

    def PluginPreferences(parent):
        vbox = gtk.VBox(spacing=5)
        vbox.set_border_width(5)
        bAM = gtk.Button("Visit Amazon.com")
        bAM.connect('clicked', lambda s:util.website('http://www.amazon.com/'))
        vbox.pack_start(bAM)
        bWM = gtk.Button("Visit Walmart.com")
        bWM.connect('clicked', lambda s:util.website('http://www.walmart.com/'))
        vbox.pack_start(bWM)
        bIT = gtk.Button("Visit iTunes.com")
        bIT.connect('clicked', lambda s:util.website('http://www.itunes.com/'))
        vbox.pack_start(bIT)
        bDT = gtk.Button("Visit Darktown.to")
        bDT.connect('clicked', lambda s:util.website('http://www.darktown.to/'))
        vbox.pack_start(bDT)
        return vbox
        
    PluginPreferences = staticmethod(PluginPreferences)

    plugin_album = AlbumArtWindow