Merge lp:~smasher816/pithos/pithos-pause into lp:~kevin-mehall/pithos/trunk

[Smasher816]

Added the '-s' command line option
to start pithos paused and hidden.

all of my changes have #Smasher816 at the end of the line, for easy adding
bin/pithos - contains the main changes
pithos/plugins/notification_icon.py - has a small change to fix "Show Pithos" if started hidden

This option is nice for me, and i'm sure many others could use it.
For instance. Pithos starts with my computer, then I can press play on my keyboard to get music at any time.

Unmerged revisions

190. By Smasher816 on 2012-03-11

Start Paused + Hidden
via '-s' command line flag

=== modified file 'bin/pithos'
--- bin/pithos	2012-01-01 00:14:23 +0000
+++ bin/pithos	2012-03-11 20:43:36 +0000
@@ -168,6 +168,8 @@
         self.prefs_dlg = PreferencesPithosDialog.NewPreferencesPithosDialog()
         self.preferences = self.prefs_dlg.get_preferences()
         
+        self.startPaused = self.cmdopts.hide #SMASHER816
+
         if self.prefs_dlg.fix_perms():
             # Changes were made, save new config variable
             self.prefs_dlg.save()
@@ -184,7 +186,7 @@
             self.show_preferences(is_startup=True)
         
         self.set_proxy()
-        self.set_audio_format()
+        self.set_audio_format()     
         self.pandora_connect()
          
     def init_core(self):
@@ -477,7 +479,10 @@
             self.statusbar.pop(self.statusbar.get_context_id('net'))
             if self.start_new_playlist:
                 self.start_song(start_index)
-                
+            if self.startPaused: #SMASHER816
+                self.startPaused=False
+                self.user_pause()   
+
             self.gstreamer_errorcount_2 = self.gstreamer_errorcount_1
             self.gstreamer_errorcount_1 = 0
             self.playcount = 0
@@ -794,6 +799,7 @@
     parser = optparse.OptionParser(version="Pithos %s"%(VERSION))
     parser.add_option("-v", "--verbose", action="store_true", dest="verbose", help="Show debug messages")
     parser.add_option("-t", "--test", action="store_true", dest="test", help="Use a mock web interface instead of connecting to the real Pandora server")
+    parser.add_option("-s", "--hide", action="store_true", dest="hide", help="Start Hidden and Paused") #SMASHER816
     (options, args) = parser.parse_args()
             
     if not options.test and try_to_raise():
@@ -808,7 +814,8 @@
             
         logging.info("Pithos %s"%VERSION)
             
-        window = NewPithosWindow(options)
-        window.show()
+        window = NewPithosWindow(options)        
+        if not window.startPaused: #SMASHER816
+            window.show()
         gtk.main()
 

=== added directory 'build'
=== added directory 'build/lib.linux-x86_64-2.7'
=== added directory 'build/lib.linux-x86_64-2.7/pithos'
=== added file 'build/lib.linux-x86_64-2.7/pithos/AboutPithosDialog.py'
--- build/lib.linux-x86_64-2.7/pithos/AboutPithosDialog.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/AboutPithosDialog.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,72 @@
+# -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
+### BEGIN LICENSE
+# Copyright (C) 2010 Kevin Mehall <[e-mail]>
+#This program is free software: you can redistribute it and/or modify it 
+#under the terms of the GNU General Public License version 3, as published 
+#by the Free Software Foundation.
+#
+#This program is distributed in the hope that it will be useful, but 
+#WITHOUT ANY WARRANTY; without even the implied warranties of 
+#MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+#PURPOSE.  See the GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License along 
+#with this program.  If not, see <http://www.gnu.org/licenses/>.
+### END LICENSE
+
+import sys
+import os
+import gtk
+
+from pithos.pithosconfig import getdatapath
+
+class AboutPithosDialog(gtk.AboutDialog):
+    __gtype_name__ = "AboutPithosDialog"
+
+    def __init__(self):
+        """__init__ - This function is typically not called directly.
+        Creation of a AboutPithosDialog requires redeading the associated ui
+        file and parsing the ui definition extrenally, 
+        and then calling AboutPithosDialog.finish_initializing().
+    
+        Use the convenience function NewAboutPithosDialog to create 
+        NewAboutPithosDialog objects.
+    
+        """
+        pass
+
+    def finish_initializing(self, builder):
+        """finish_initalizing should be called after parsing the ui definition
+        and creating a AboutPithosDialog object with it in order to finish
+        initializing the start of the new AboutPithosDialog instance.
+    
+        """
+        #get a reference to the builder and set up the signals
+        self.builder = builder
+        self.builder.connect_signals(self)
+
+        #code for other initialization actions should be added here
+
+def NewAboutPithosDialog():
+    """NewAboutPithosDialog - returns a fully instantiated
+    AboutPithosDialog object. Use this function rather than
+    creating a AboutPithosDialog instance directly.
+    
+    """
+
+    #look for the ui file that describes the ui
+    ui_filename = os.path.join(getdatapath(), 'ui', 'AboutPithosDialog.ui')
+    if not os.path.exists(ui_filename):
+        ui_filename = None
+
+    builder = gtk.Builder()
+    builder.add_from_file(ui_filename)    
+    dialog = builder.get_object("about_pithos_dialog")
+    dialog.finish_initializing(builder)
+    return dialog
+
+if __name__ == "__main__":
+    dialog = NewAboutPithosDialog()
+    dialog.show()
+    gtk.main()
+

=== added file 'build/lib.linux-x86_64-2.7/pithos/PreferencesPithosDialog.py'
--- build/lib.linux-x86_64-2.7/pithos/PreferencesPithosDialog.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/PreferencesPithosDialog.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,229 @@
+# -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
+### BEGIN LICENSE
+# Copyright (C) 2010 Kevin Mehall <[e-mail]>
+#This program is free software: you can redistribute it and/or modify it 
+#under the terms of the GNU General Public License version 3, as published 
+#by the Free Software Foundation.
+#
+#This program is distributed in the hope that it will be useful, but 
+#WITHOUT ANY WARRANTY; without even the implied warranties of 
+#MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+#PURPOSE.  See the GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License along 
+#with this program.  If not, see <http://www.gnu.org/licenses/>.
+### END LICENSE
+
+import sys
+import os
+import stat
+import logging
+
+import gtk
+import gobject
+
+from pithos.pithosconfig import getdatapath, valid_audio_formats
+from pithos.plugins.scrobble import LastFmAuth
+
+try:
+    from xdg.BaseDirectory import xdg_config_home
+    config_home = xdg_config_home
+except ImportError:
+    config_home = os.path.dirname(__file__)
+    
+configfilename = os.path.join(config_home, 'pithos.ini')
+
+class PreferencesPithosDialog(gtk.Dialog):
+    __gtype_name__ = "PreferencesPithosDialog"
+    prefernces = {}
+
+    def __init__(self):
+        """__init__ - This function is typically not called directly.
+        Creation of a PreferencesPithosDialog requires redeading the associated ui
+        file and parsing the ui definition extrenally,
+        and then calling PreferencesPithosDialog.finish_initializing().
+
+        Use the convenience function NewPreferencesPithosDialog to create
+        NewAboutPithosDialog objects.
+        """
+
+        pass
+
+    def finish_initializing(self, builder):
+        """finish_initalizing should be called after parsing the ui definition
+        and creating a AboutPithosDialog object with it in order to finish
+        initializing the start of the new AboutPithosDialog instance.
+        """
+
+        #get a reference to the builder and set up the signals
+        self.builder = builder
+        self.builder.connect_signals(self)
+        
+        self.__load_preferences()
+
+
+    def get_preferences(self):
+        """get_preferences  - returns a dictionary object that contains
+        preferences for pithos.
+        """
+        return self.__preferences
+
+    def __load_preferences(self):
+        #default preferences that will be overwritten if some are saved
+        self.__preferences = {
+            "username":'',
+            "password":'',
+            "notify":True,
+            "last_station_id":None,
+            "proxy":'',
+            "show_icon": False,
+            "lastfm_key": False,
+            "enable_mediakeys":True,
+            "enable_screensaverpause":False,
+            "volume": 1.0,
+            # If set, allow insecure permissions. Implements CVE-2011-1500
+            "unsafe_permissions": False,
+            "audio_format": valid_audio_formats[0],
+        }
+        
+        try:
+            f = open(configfilename)
+        except IOError:
+            f = []
+        
+        for line in f:
+            sep = line.find('=')
+            key = line[:sep]
+            val = line[sep+1:].strip()
+            if val == 'None': val=None
+            elif val == 'False': val=False
+            elif val == 'True': val=True
+            self.__preferences[key]=val
+        self.setup_fields()
+
+    def fix_perms(self):
+        """Apply new file permission rules, fixing CVE-2011-1500.
+        If the file is 0644 and if "unsafe_permissions" is not True, 
+           chmod 0600
+        If the file is world-readable (but not exactly 0644) and if 
+        "unsafe_permissions" is not True:
+           chmod o-rw
+        """
+        def complain_unsafe():
+            # Display this message iff permissions are unsafe, which is why
+            #   we don't just check once and be done with it. 
+            logging.warning("Ignoring potentially unsafe permissions due to user override.")
+        
+        changed = False
+        
+        if os.path.exists(configfilename):
+            # We've already written the file, get current permissions
+            config_perms = stat.S_IMODE(os.stat(configfilename).st_mode)
+            if config_perms == (stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IROTH):
+                if self.__preferences["unsafe_permissions"]:
+                    return complain_unsafe()
+                # File is 0644, set to 0600
+                logging.warning("Removing world- and group-readable permissions, to fix CVE-2011-1500 in older software versions. To force, set unsafe_permissions to True in pithos.ini.")
+                os.chmod(configfilename, stat.S_IRUSR | stat.S_IWUSR)
+                changed = True
+                
+            elif config_perms & stat.S_IROTH:
+                if self.__preferences["unsafe_permissions"]:
+                    return complain_unsafe()
+                # File is o+r, 
+                logging.warning("Removing world-readable permissions, configuration should not be globally readable. To force, set unsafe_permissions to True in pithos.ini.")
+                config_perms ^= stat.S_IROTH
+                os.chmod(configfilename, config_perms)
+                changed = True
+
+            if config_perms & stat.S_IWOTH:
+                if self.__preferences["unsafe_permissions"]:
+                    return complain_unsafe()
+                logging.warning("Removing world-writable permissions, configuration should not be globally writable. To force, set unsafe_permissions to True in pithos.ini.")
+                config_perms ^= stat.S_IWOTH
+                os.chmod(configfilename, config_perms)
+                changed = True
+        
+        return changed
+
+    def save(self):         
+        existed = os.path.exists(configfilename)
+        f = open(configfilename, 'w')
+
+        if not existed:
+            # make the file owner-readable and writable only
+            os.fchmod(f.fileno(), (stat.S_IRUSR | stat.S_IWUSR))
+
+        for key in self.__preferences:
+            f.write('%s=%s\n'%(key, self.__preferences[key]))
+        f.close()
+        
+    def setup_fields(self):
+        self.builder.get_object('prefs_username').set_text(self.__preferences["username"])
+        self.builder.get_object('prefs_password').set_text(self.__preferences["password"])
+        self.builder.get_object('prefs_proxy').set_text(self.__preferences["proxy"])
+        
+        audio_format_combo = self.builder.get_object('prefs_audio_format')
+        fmt_store = gtk.ListStore(gobject.TYPE_STRING)
+        for audio_format in valid_audio_formats:
+            fmt_store.append((audio_format,))
+        audio_format_combo.set_model(fmt_store)
+        render_text = gtk.CellRendererText()
+        audio_format_combo.pack_start(render_text, expand=True)
+        audio_format_combo.add_attribute(render_text, "text", 0)
+        audio_pref_idx = list(valid_audio_formats).index(self.__preferences["audio_format"])
+        audio_format_combo.set_active(audio_pref_idx)
+        
+        
+        self.builder.get_object('checkbutton_notify').set_active(self.__preferences["notify"])
+        self.builder.get_object('checkbutton_screensaverpause').set_active(self.__preferences["enable_screensaverpause"])
+        self.builder.get_object('checkbutton_icon').set_active(self.__preferences["show_icon"])
+        
+        self.lastfm_auth = LastFmAuth(self.__preferences, "lastfm_key", self.builder.get_object('lastfm_btn'))
+        
+    def ok(self, widget, data=None):
+        """ok - The user has elected to save the changes.
+        Called before the dialog returns gtk.RESONSE_OK from run().
+        """
+        
+        self.__preferences["username"] = self.builder.get_object('prefs_username').get_text()
+        self.__preferences["password"] = self.builder.get_object('prefs_password').get_text()
+        self.__preferences["proxy"] = self.builder.get_object('prefs_proxy').get_text()
+        self.__preferences["audio_format"] = valid_audio_formats[self.builder.get_object('prefs_audio_format').get_active()]
+        self.__preferences["notify"] = self.builder.get_object('checkbutton_notify').get_active()
+        self.__preferences["enable_screensaverpause"] = self.builder.get_object('checkbutton_screensaverpause').get_active()
+        self.__preferences["show_icon"] = self.builder.get_object('checkbutton_icon').get_active()
+        
+        self.save()
+
+    def cancel(self, widget, data=None):
+        """cancel - The user has elected cancel changes.
+        Called before the dialog returns gtk.RESPONSE_CANCEL for run()
+        """
+
+        self.setup_fields() # restore fields to previous values
+        pass
+            
+
+def NewPreferencesPithosDialog():
+    """NewPreferencesPithosDialog - returns a fully instantiated
+    PreferencesPithosDialog object. Use this function rather than
+    creating a PreferencesPithosDialog instance directly.
+    """
+
+    #look for the ui file that describes the ui
+    ui_filename = os.path.join(getdatapath(), 'ui', 'PreferencesPithosDialog.ui')
+    if not os.path.exists(ui_filename):
+        ui_filename = None
+
+    builder = gtk.Builder()
+    builder.add_from_file(ui_filename)
+    dialog = builder.get_object("preferences_pithos_dialog")
+    dialog.finish_initializing(builder)
+    return dialog
+
+if __name__ == "__main__":
+    dialog = NewPreferencesPithosDialog()
+    dialog.show()
+    gtk.main()
+

=== added file 'build/lib.linux-x86_64-2.7/pithos/SearchDialog.py'
--- build/lib.linux-x86_64-2.7/pithos/SearchDialog.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/SearchDialog.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,116 @@
+# -*- coding: utf-8 -*-
+### BEGIN LICENSE
+# This file is in the public domain
+### END LICENSE
+
+import sys
+import os
+import gtk, gobject
+import cgi
+
+from pithos.pithosconfig import getdatapath
+
+class SearchDialog(gtk.Dialog):
+    __gtype_name__ = "SearchDialog"
+
+    def __init__(self):
+        """__init__ - This function is typically not called directly.
+        Creation of a SearchDialog requires redeading the associated ui
+        file and parsing the ui definition extrenally, 
+        and then calling SearchDialog.finish_initializing().
+    
+        Use the convenience function NewSearchDialog to create 
+        a SearchDialog object.
+    
+        """
+        pass
+
+    def finish_initializing(self, builder, worker_run):
+        """finish_initalizing should be called after parsing the ui definition
+        and creating a SearchDialog object with it in order to finish
+        initializing the start of the new SearchDialog instance.
+    
+        """
+        #get a reference to the builder and set up the signals
+        self.builder = builder
+        self.builder.connect_signals(self)
+        
+        self.entry = self.builder.get_object('entry')
+        self.treeview = self.builder.get_object('treeview')
+        self.okbtn = self.builder.get_object('okbtn')
+        self.searchbtn = self.builder.get_object('searchbtn')
+        self.model = gtk.ListStore(gobject.TYPE_PYOBJECT, str)
+        self.treeview.set_model(self.model)
+        
+        self.worker_run = worker_run
+        
+        self.result = None
+
+
+    def ok(self, widget, data=None):
+        """ok - The user has elected to save the changes.
+        Called before the dialog returns gtk.RESONSE_OK from run().
+
+        """
+        
+
+    def cancel(self, widget, data=None):
+        """cancel - The user has elected cancel changes.
+        Called before the dialog returns gtk.RESPONSE_CANCEL for run()
+
+        """         
+        pass
+        
+    def search_clicked(self, widget):
+        self.search(self.entry.get_text())
+        
+    def search(self, query):
+        if not query: return
+        def callback(results):
+            self.model.clear()
+            for i in results:
+                if i.resultType is 'song':
+                    mk = "<b>%s</b> by %s"%(cgi.escape(i.title), cgi.escape(i.artist))
+                elif i.resultType is 'artist':
+                    mk = "<b>%s</b> (artist)"%(cgi.escape(i.name))
+                self.model.append((i, mk))
+            self.treeview.show()
+            self.searchbtn.set_sensitive(True)
+            self.searchbtn.set_label("Search")
+        self.worker_run('search', (query,), callback, "Searching...")
+        self.searchbtn.set_sensitive(False)
+        self.searchbtn.set_label("Searching...")
+        
+    def get_selected(self):
+        sel = self.treeview.get_selection().get_selected()
+        if sel:
+            return self.treeview.get_model().get_value(sel[1], 0)
+            
+    def cursor_changed(self, *ignore):
+        self.result = self.get_selected()
+        self.okbtn.set_sensitive(not not self.result)
+        
+
+def NewSearchDialog(worker_run):
+    """NewSearchDialog - returns a fully instantiated
+    dialog-camel_case_nameDialog object. Use this function rather than
+    creating SearchDialog instance directly.
+    
+    """
+
+    #look for the ui file that describes the ui
+    ui_filename = os.path.join(getdatapath(), 'ui', 'SearchDialog.ui')
+    if not os.path.exists(ui_filename):
+        ui_filename = None
+
+    builder = gtk.Builder()
+    builder.add_from_file(ui_filename)    
+    dialog = builder.get_object("search_dialog")
+    dialog.finish_initializing(builder, worker_run)
+    return dialog
+
+if __name__ == "__main__":
+    dialog = NewSearchDialog()
+    dialog.show()
+    gtk.main()
+

=== added file 'build/lib.linux-x86_64-2.7/pithos/StationsDialog.py'
--- build/lib.linux-x86_64-2.7/pithos/StationsDialog.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/StationsDialog.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,219 @@
+# -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
+### BEGIN LICENSE
+# Copyright (C) 2010 Kevin Mehall <[e-mail]>
+#This program is free software: you can redistribute it and/or modify it 
+#under the terms of the GNU General Public License version 3, as published 
+#by the Free Software Foundation.
+#
+#This program is distributed in the hope that it will be useful, but 
+#WITHOUT ANY WARRANTY; without even the implied warranties of 
+#MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+#PURPOSE.  See the GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License along 
+#with this program.  If not, see <http://www.gnu.org/licenses/>.
+### END LICENSE
+
+import sys
+import os
+import gtk
+import logging
+import webbrowser
+
+from pithos.pithosconfig import getdatapath
+from pithos import SearchDialog
+
+class StationsDialog(gtk.Dialog):
+    __gtype_name__ = "StationsDialog"
+
+    def __init__(self):
+        """__init__ - This function is typically not called directly.
+        Creation of a StationsDialog requires redeading the associated ui
+        file and parsing the ui definition extrenally, 
+        and then calling StationsDialog.finish_initializing().
+    
+        Use the convenience function NewStationsDialog to create 
+        a StationsDialog object.
+    
+        """
+        pass
+
+    def finish_initializing(self, builder, pithos):
+        """finish_initalizing should be called after parsing the ui definition
+        and creating a StationsDialog object with it in order to finish
+        initializing the start of the new StationsDialog instance.
+    
+        """
+        #get a reference to the builder and set up the signals
+        self.builder = builder
+        self.builder.connect_signals(self)
+        
+        self.pithos = pithos
+        self.model = pithos.stations_model
+        self.worker_run = pithos.worker_run
+        self.quickmix_changed = False
+        self.searchDialog = None
+        
+        self.modelfilter = self.model.filter_new()
+        self.modelfilter.set_visible_func(lambda m, i: m.get_value(i, 0) and not  m.get_value(i, 0).isQuickMix)
+
+        self.modelsortable = gtk.TreeModelSort(self.modelfilter)
+        """
+        @todo Leaving it as sorting by date added by default. 
+        Probably should make a radio select in the window or an option in program options for user preference
+        """
+#        self.modelsortable.set_sort_column_id(1, gtk.SORT_ASCENDING)
+        
+        self.treeview = self.builder.get_object("treeview")
+        self.treeview.set_model(self.modelsortable)
+        self.treeview.connect('button_press_event', self.on_treeview_button_press_event)
+        
+        name_col   = gtk.TreeViewColumn()
+        name_col.set_title("Name")
+        render_text = gtk.CellRendererText()
+        render_text.set_property('editable', True)
+        render_text.connect("edited", self.station_renamed)
+        name_col.pack_start(render_text, expand=True)
+        name_col.add_attribute(render_text, "text", 1)
+        name_col.set_expand(True)
+        name_col.set_sort_column_id(1)
+        self.treeview.append_column(name_col)
+        
+        qm_col   = gtk.TreeViewColumn()
+        qm_col.set_title("In QuickMix")
+        render_toggle = gtk.CellRendererToggle()
+        qm_col.pack_start(render_toggle, expand=True)
+        def qm_datafunc(column, cell, model, iter):
+            if model.get_value(iter,0).useQuickMix:
+                cell.set_active(True)
+            else:
+                cell.set_active(False)
+        qm_col.set_cell_data_func(render_toggle, qm_datafunc)
+        render_toggle.connect("toggled", self.qm_toggled)
+        self.treeview.append_column(qm_col)
+        
+        self.station_menu = builder.get_object("station_menu")
+        
+    def qm_toggled(self, renderer, path):
+        station = self.modelfilter[path][0]
+        station.useQuickMix = not station.useQuickMix
+        self.quickmix_changed = True
+        
+    def station_renamed(self, cellrenderertext, path, new_text):
+        station = self.modelfilter[path][0]
+        self.worker_run(station.rename, (new_text,), context='net', message="Renaming Station...")
+        self.model[self.modelfilter.convert_path_to_child_path(path)][1] = new_text
+        
+    def selected_station(self):
+        sel = self.treeview.get_selection().get_selected()
+        if sel:
+            return self.treeview.get_model().get_value(sel[1], 0)
+           
+    def on_treeview_button_press_event(self, treeview, event):
+        if event.button == 3:
+            x = int(event.x)
+            y = int(event.y)
+            time = event.time
+            pthinfo = treeview.get_path_at_pos(x, y)
+            if pthinfo is not None:
+                path, col, cellx, celly = pthinfo
+                treeview.grab_focus()
+                treeview.set_cursor( path, col, 0)
+                self.station_menu.popup( None, None, None, event.button, time)
+            return True
+            
+    def on_menuitem_listen(self, widget):
+        station = self.selected_station()
+        self.pithos.station_changed(station)
+        self.hide()
+        
+    def on_menuitem_info(self, widget):
+        webbrowser.open(self.selected_station().info_url)
+        
+    def on_menuitem_rename(self, widget):
+        sel = self.treeview.get_selection().get_selected()
+        path = self.modelfilter.get_path(sel[1])
+        self.treeview.set_cursor(path, self.treeview.get_column(0) ,True)
+        
+    def on_menuitem_delete(self, widget):
+        station = self.selected_station()
+        
+        dialog = self.builder.get_object("delete_confirm_dialog")
+        dialog.set_property("text", "Are you sure you want to delete the station \"%s\"?"%(station.name))
+        response = dialog.run()
+        dialog.hide()
+        
+        if response:
+            self.worker_run(station.delete, context='net', message="Deleting Station...")
+            del self.pithos.stations_model[self.pithos.station_index(station)]
+            if self.pithos.current_station is station:
+                self.pithos.station_changed(self.model[0][0])
+                
+    def add_station(self, widget):
+        if self.searchDialog:
+            self.searchDialog.present()
+        else:
+            self.searchDialog = SearchDialog.NewSearchDialog(self.worker_run)
+            self.searchDialog.show_all()
+            self.searchDialog.connect("response", self.add_station_cb)
+            
+    def refresh_stations(self, widget):
+        self.pithos.refresh_stations(self.pithos)
+        
+    def add_station_cb(self, dialog, response):
+        print "in add_station_cb", dialog.result, response
+        if response == 1:
+            self.worker_run("add_station_by_music_id", (dialog.result.musicId,), self.station_added, "Creating station...")
+        dialog.hide()
+        dialog.destroy()
+        self.searchDialog = None
+        
+    def station_added(self, station):
+        logging.debug("1 "+ repr(station))
+        it = self.model.insert_after(self.model.get_iter(1), (station, station.name))
+        logging.debug("2 "+ repr(it))
+        self.pithos.station_changed(station)
+        logging.debug("3 ")
+        self.modelfilter.refilter()
+        logging.debug("4")
+        self.treeview.set_cursor(0)
+        logging.debug("5 ")
+        
+    def add_genre_station(self, widget):
+        """
+        This is just a stub for the non-completed buttn
+        """
+        
+    def on_close(self, widget, data=None):
+        self.hide()
+        
+        if self.quickmix_changed:
+            self.worker_run("save_quick_mix",  message="Saving QuickMix...")
+            self.quickmix_changed = False
+        
+        logging.info("closed dialog")
+        return True
+
+def NewStationsDialog(pithos):
+    """NewStationsDialog - returns a fully instantiated
+    Dialog object. Use this function rather than
+    creating StationsDialog instance directly.
+    
+    """
+
+    #look for the ui file that describes the ui
+    ui_filename = os.path.join(getdatapath(), 'ui', 'StationsDialog.ui')
+    if not os.path.exists(ui_filename):
+        ui_filename = None
+
+    builder = gtk.Builder()
+    builder.add_from_file(ui_filename)    
+    dialog = builder.get_object("stations_dialog")
+    dialog.finish_initializing(builder, pithos)
+    return dialog
+
+if __name__ == "__main__":
+    dialog = NewStationsDialog()
+    dialog.show()
+    gtk.main()
+

=== added file 'build/lib.linux-x86_64-2.7/pithos/__init__.py'
=== added file 'build/lib.linux-x86_64-2.7/pithos/dbus_service.py'
--- build/lib.linux-x86_64-2.7/pithos/dbus_service.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/dbus_service.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,92 @@
+# -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
+### BEGIN LICENSE
+# Copyright (C) 2010 Kevin Mehall <[e-mail]>
+#This program is free software: you can redistribute it and/or modify it 
+#under the terms of the GNU General Public License version 3, as published 
+#by the Free Software Foundation.
+#
+#This program is distributed in the hope that it will be useful, but 
+#WITHOUT ANY WARRANTY; without even the implied warranties of 
+#MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+#PURPOSE.  See the GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License along 
+#with this program.  If not, see <http://www.gnu.org/licenses/>.
+### END LICENSE
+
+import dbus.service
+
+DBUS_BUS = "net.kevinmehall.Pithos"
+DBUS_OBJECT_PATH = "/net/kevinmehall/Pithos"
+
+def song_to_dict(song):
+    d = {}
+    if song:
+        for i in ['artist', 'title', 'album', 'songDetailURL']:
+            d[i] = getattr(song, i)
+    return d
+  
+class PithosDBusProxy(dbus.service.Object):
+    def __init__(self, window):
+        self.bus = dbus.SessionBus()
+        bus_name = dbus.service.BusName(DBUS_BUS, bus=self.bus)
+        dbus.service.Object.__init__(self, bus_name, DBUS_OBJECT_PATH)
+        self.window = window
+        self.window.connect("song-changed", self.songchange_handler)
+        self.window.connect("play-state-changed", self.playstate_handler)
+        
+    def playstate_handler(self, window, state):
+        self.PlayStateChanged(state)
+        
+    def songchange_handler(self, window, song):
+        self.SongChanged(song_to_dict(song))
+    
+    @dbus.service.method(DBUS_BUS)
+    def PlayPause(self):
+        self.window.playpause()
+    
+    @dbus.service.method(DBUS_BUS)
+    def SkipSong(self):
+        self.window.next_song()
+    
+    @dbus.service.method(DBUS_BUS)
+    def LoveCurrentSong(self):
+        self.window.love_song()
+    
+    @dbus.service.method(DBUS_BUS)
+    def BanCurrentSong(self):
+        self.window.ban_song()
+    
+    @dbus.service.method(DBUS_BUS)
+    def TiredCurrentSong(self):
+        self.window.tired_song()
+        
+    @dbus.service.method(DBUS_BUS)
+    def Present(self):
+        self.window.bring_to_top()
+        
+    @dbus.service.method(DBUS_BUS, out_signature='a{sv}')
+    def GetCurrentSong(self):
+        return song_to_dict(self.window.current_song)
+        
+    @dbus.service.method(DBUS_BUS, out_signature='b')
+    def IsPlaying(self):
+        return self.window.playing
+        
+    @dbus.service.signal(DBUS_BUS, signature='b')
+    def PlayStateChanged(self, state):
+        pass
+        
+    @dbus.service.signal(DBUS_BUS, signature='a{sv}')
+    def SongChanged(self, songinfo):
+        pass    
+
+
+def try_to_raise():
+    bus = dbus.SessionBus()
+    try:
+        proxy = bus.get_object(DBUS_BUS, DBUS_OBJECT_PATH)
+        proxy.Present()
+        return True
+    except dbus.exceptions.DBusException as e:
+        return False

=== added file 'build/lib.linux-x86_64-2.7/pithos/gobject_worker.py'
--- build/lib.linux-x86_64-2.7/pithos/gobject_worker.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/gobject_worker.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,68 @@
+# -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
+### BEGIN LICENSE
+# Copyright (C) 2010 Kevin Mehall <[e-mail]>
+#This program is free software: you can redistribute it and/or modify it 
+#under the terms of the GNU General Public License version 3, as published 
+#by the Free Software Foundation.
+#
+#This program is distributed in the hope that it will be useful, but 
+#WITHOUT ANY WARRANTY; without even the implied warranties of 
+#MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+#PURPOSE.  See the GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License along 
+#with this program.  If not, see <http://www.gnu.org/licenses/>.
+### END LICENSE
+
+import threading
+import Queue
+import gobject
+import traceback
+gobject.threads_init()
+
+class GObjectWorker():
+    def __init__(self):
+        self.thread = threading.Thread(target=self._run)
+        self.thread.daemon = True
+        self.queue = Queue.Queue()
+        self.thread.start()
+        
+    def _run(self):
+        while True:
+            command, args, callback, errorback = self.queue.get()
+            try:
+                result = command(*args)
+                if callback:
+                    gobject.idle_add(callback, result)
+            except Exception, e:
+                e.traceback = traceback.format_exc()
+                if errorback:
+                    gobject.idle_add(errorback, e)
+                
+    def send(self, command, args=(), callback=None, errorback=None):
+        if errorback is None: errorback = self._default_errorback
+        self.queue.put((command, args, callback, errorback))
+        
+    def _default_errorback(self, error):
+        print "Unhandled exception in worker thread:\n", error.traceback
+        
+if __name__ == '__main__':
+    worker = GObjectWorker()
+    import time, gtk
+    
+    def test_cmd(a, b):
+        print "running..."
+        time.sleep(5)
+        print "done"
+        return a*b
+        
+    def test_cb(result):
+        print "got result", result
+        
+    print "sending"
+    worker.send(test_cmd, (3,4), test_cb)
+    worker.send(test_cmd, ((), ()), test_cb) #trigger exception in worker to test error handling
+    
+    gtk.main()
+        
+                

=== added directory 'build/lib.linux-x86_64-2.7/pithos/pandora'
=== added file 'build/lib.linux-x86_64-2.7/pithos/pandora/__init__.py'
--- build/lib.linux-x86_64-2.7/pithos/pandora/__init__.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/pandora/__init__.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,24 @@
+# -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
+### BEGIN LICENSE
+# Copyright (C) 2010 Kevin Mehall <[e-mail]>
+#This program is free software: you can redistribute it and/or modify it 
+#under the terms of the GNU General Public License version 3, as published 
+#by the Free Software Foundation.
+#
+#This program is distributed in the hope that it will be useful, but 
+#WITHOUT ANY WARRANTY; without even the implied warranties of 
+#MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+#PURPOSE.  See the GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License along 
+#with this program.  If not, see <http://www.gnu.org/licenses/>.
+### END LICENSE
+
+from pithos.pandora.pandora import *
+
+def make_pandora(testing=False):
+    if testing:
+        from pithos.pandora.fake import FakePandora
+        return FakePandora()
+    else:
+        return Pandora()

=== added file 'build/lib.linux-x86_64-2.7/pithos/pandora/blowfish.py'
--- build/lib.linux-x86_64-2.7/pithos/pandora/blowfish.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/pandora/blowfish.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,171 @@
+#
+# blowfish.py
+# Copyright (C) 2002 Michael Gilfix <[e-mail]>
+#
+# This module is open source; you can redistribute it and/or
+# modify it under the terms of the GPL or Artistic License.
+# These licenses are available at http://www.opensource.org
+#
+# This software must be used and distributed in accordance
+# with the law. The author claims no liability for its
+# misuse.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+#
+
+"""
+Blowfish Encryption
+
+This module is a pure python implementation of Bruce Schneier's
+encryption scheme 'Blowfish'. Blowish is a 16-round Feistel Network
+cipher and offers substantial speed gains over DES.
+
+The key is a string of length anywhere between 64 and 448 bits, or
+equivalently 8 and 56 bytes. The encryption and decryption functions operate
+on 64-bit blocks, or 8 byte strings.
+
+Send questions, comments, bugs my way:
+    Michael Gilfix <[e-mail]>
+    
+This version is modified by Kevin Mehall <[e-mail]> to accept the 
+S and P boxes directly, rather than computing them from a key
+"""
+
+__author__ = "Michael Gilfix <[e-mail]>"
+
+class Blowfish:
+
+	"""Blowfish encryption Scheme
+
+	This class implements the encryption and decryption
+	functionality of the Blowfish cipher.
+
+	Public functions:
+
+		def __init__ (self, key)
+			Creates an instance of blowfish using 'key'
+			as the encryption key. Key is a string of
+			length ranging from 8 to 56 bytes (64 to 448
+			bits). Once the instance of the object is
+			created, the key is no longer necessary.
+
+		def encrypt (self, data):
+			Encrypt an 8 byte (64-bit) block of text
+			where 'data' is an 8 byte string. Returns an
+			8-byte encrypted string.
+
+		def decrypt (self, data):
+			Decrypt an 8 byte (64-bit) encrypted block
+			of text, where 'data' is the 8 byte encrypted
+			string. Returns an 8-byte string of plaintext.
+
+		def cipher (self, xl, xr, direction):
+			Encrypts a 64-bit block of data where xl is
+			the upper 32-bits and xr is the lower 32-bits.
+			'direction' is the direction to apply the
+			cipher, either ENCRYPT or DECRYPT constants.
+			returns a tuple of either encrypted or decrypted
+			data of the left half and right half of the
+			64-bit block.
+
+	Private members:
+
+		def __round_func (self, xl)
+			Performs an obscuring function on the 32-bit
+			block of data 'xl', which is the left half of
+			the 64-bit block of data. Returns the 32-bit
+			result as a long integer.
+
+	"""
+
+	# Cipher directions
+	ENCRYPT = 0
+	DECRYPT = 1
+
+	# For the __round_func
+	modulus = long (2) ** 32
+
+	def __init__ (self, p_boxes, s_boxes):
+		self.p_boxes = p_boxes
+		self.s_boxes = s_boxes
+		
+
+	def cipher (self, xl, xr, direction):
+
+		if direction == self.ENCRYPT:
+			for i in range (16):
+				xl = xl ^ self.p_boxes[i]
+				xr = self.__round_func (xl) ^ xr
+				xl, xr = xr, xl
+			xl, xr = xr, xl
+			xr = xr ^ self.p_boxes[16]
+			xl = xl ^ self.p_boxes[17]
+		else:
+			for i in range (17, 1, -1):
+				xl = xl ^ self.p_boxes[i]
+				xr = self.__round_func (xl) ^ xr
+				xl, xr = xr, xl
+			xl, xr = xr, xl
+			xr = xr ^ self.p_boxes[1]
+			xl = xl ^ self.p_boxes[0]
+		return xl, xr
+
+	def __round_func (self, xl):
+		a = (xl & 0xFF000000) >> 24
+		b = (xl & 0x00FF0000) >> 16
+		c = (xl & 0x0000FF00) >> 8
+		d = xl & 0x000000FF
+
+		# Perform all ops as longs then and out the last 32-bits to
+		# obtain the integer
+		f = (long (self.s_boxes[0][a]) + long (self.s_boxes[1][b])) % self.modulus
+		f = f ^ long (self.s_boxes[2][c])
+		f = f + long (self.s_boxes[3][d])
+		f = (f % self.modulus) & 0xFFFFFFFF
+
+		return f
+
+	def encrypt (self, data):
+
+		if not len (data) == 8:
+			raise RuntimeError, "Attempted to encrypt data of invalid block length: %s" %len (data)
+
+		# Use big endianess since that's what everyone else uses
+		xl = ord (data[3]) | (ord (data[2]) << 8) | (ord (data[1]) << 16) | (ord (data[0]) << 24)
+		xr = ord (data[7]) | (ord (data[6]) << 8) | (ord (data[5]) << 16) | (ord (data[4]) << 24)
+
+		cl, cr = self.cipher (xl, xr, self.ENCRYPT)
+		chars = ''.join ([
+			chr ((cl >> 24) & 0xFF), chr ((cl >> 16) & 0xFF), chr ((cl >> 8) & 0xFF), chr (cl & 0xFF),
+			chr ((cr >> 24) & 0xFF), chr ((cr >> 16) & 0xFF), chr ((cr >> 8) & 0xFF), chr (cr & 0xFF)
+		])
+		return chars
+
+	def decrypt (self, data):
+
+		if not len (data) == 8:
+			raise RuntimeError, "Attempted to encrypt data of invalid block length: %s" %len (data)
+
+		# Use big endianess since that's what everyone else uses
+		cl = ord (data[3]) | (ord (data[2]) << 8) | (ord (data[1]) << 16) | (ord (data[0]) << 24)
+		cr = ord (data[7]) | (ord (data[6]) << 8) | (ord (data[5]) << 16) | (ord (data[4]) << 24)
+
+		xl, xr = self.cipher (cl, cr, self.DECRYPT)
+		chars = ''.join ([
+			chr ((xl >> 24) & 0xFF), chr ((xl >> 16) & 0xFF), chr ((xl >> 8) & 0xFF), chr (xl & 0xFF),
+			chr ((xr >> 24) & 0xFF), chr ((xr >> 16) & 0xFF), chr ((xr >> 8) & 0xFF), chr (xr & 0xFF)
+		])
+		return chars
+
+	def blocksize (self):
+		return 8
+
+	def key_length (self):
+		return 56
+
+	def key_bits (self):
+		return 56 * 8
+
+	

=== added file 'build/lib.linux-x86_64-2.7/pithos/pandora/fake.py'
--- build/lib.linux-x86_64-2.7/pithos/pandora/fake.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/pandora/fake.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,130 @@
+# -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
+### BEGIN LICENSE
+# Copyright (C) 2010 Kevin Mehall <[e-mail]>
+#This program is free software: you can redistribute it and/or modify it 
+#under the terms of the GNU General Public License version 3, as published 
+#by the Free Software Foundation.
+#
+#This program is distributed in the hope that it will be useful, but 
+#WITHOUT ANY WARRANTY; without even the implied warranties of 
+#MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+#PURPOSE.  See the GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License along 
+#with this program.  If not, see <http://www.gnu.org/licenses/>.
+### END LICENSE
+
+from pithos.pandora.pandora import *
+import gtk
+import logging
+
+class FakePandora(Pandora):
+    def __init__(self):
+        super(FakePandora, self).__init__()
+        self.counter = 0
+        self.show_fail_window()
+        logging.info("Using test mode")
+    
+    def count(self):
+        self.counter +=1
+        return self.counter
+        
+    def show_fail_window(self):
+        self.window = gtk.Window()
+        self.window.set_size_request(200, 100)
+        self.window.set_title("Pithos failure tester")
+        self.window.set_opacity(0.7)
+        self.auth_check = gtk.CheckButton("Authenticated")
+        self.time_check = gtk.CheckButton("Be really slow")
+        vbox = gtk.VBox()
+        self.window.add(vbox)
+        vbox.pack_start(self.auth_check)
+        vbox.pack_start(self.time_check)
+        self.window.show_all()
+
+    def maybe_fail(self):
+        if self.time_check.get_active():
+            logging.info("fake: Going to sleep for 10s")
+            time.sleep(10)
+        if not self.auth_check.get_active():
+            logging.info("fake: We're deauthenticated...")
+            raise PandoraAuthTokenInvalid("Auth token invalid", "AUTH_INVALID_TOKEN")
+
+    def set_authenticated(self):
+        self.auth_check.set_active(True)
+        
+    def xmlrpc_call(self, method, args=[], url_args=True, secure=False):
+        time.sleep(1)
+        if method != 'listener.authenticateListener':
+            self.maybe_fail()
+            
+        if method == 'listener.authenticateListener':
+            self.set_authenticated()
+            return {'webAuthToken': '123', 'listenerId':'456', 'authToken':'789'}
+        
+        elif method == 'station.getStations':
+            return [
+                {'stationId':'987', 'stationIdToken':'345434', 'isCreator':True, 'isQuickMix':False, 'stationName':"Test Station 1"},   
+                {'stationId':'321', 'stationIdToken':'453544', 'isCreator':True, 'isQuickMix':True, 'stationName':"Fake's QuickMix",
+                    'quickMixStationIds':['987', '343']},
+                {'stationId':'432', 'stationIdToken':'345485', 'isCreator':True, 'isQuickMix':False, 'stationName':"Test Station 2"},
+                {'stationId':'254', 'stationIdToken':'345415', 'isCreator':True, 'isQuickMix':False, 'stationName':"Test Station 4 - Out of Order"},
+                {'stationId':'343', 'stationIdToken':'345435', 'isCreator':True, 'isQuickMix':False, 'stationName':"Test Station 3"},   
+            ]
+        elif method == 'playlist.getFragment':
+            return [self.makeFakeSong(args) for i in range(4)]
+        elif method == 'music.search':
+            return {'artists': [
+                        {'score':90, 'musicId':'988', 'artistName':"artistName"},
+                    ],
+                    'songs':[
+                        {'score':80, 'musicId':'238', 'songTitle':"SongName", 'artistSummary':"ArtistName"},
+                    ],
+                   }
+        elif method == 'station.createStation':
+            return {'stationId':'999', 'stationIdToken':'345433', 'isCreator':True, 'isQuickMix':False, 'stationName':"Added Station"} 
+        elif method in ('station.setQuickMix',
+                        'station.addFeedback',
+                        'station.transformShared', 
+                        'station.setStationName',
+                        'station.removeStation',
+                        'listener.addTiredSong',
+                        'station.createBookmark',
+                        'station.createArtistBookmark',
+                     ):
+            return 1
+        else:
+            logging.error("Invalid method %s" % method)
+            
+    def connect(self, user, password):
+        self.listenerId = self.authToken = None
+        
+        user = self.xmlrpc_call('listener.authenticateListener', [user, password], [], secure=True)
+        
+        self.webAuthToken = user['webAuthToken']
+        self.listenerId = user['listenerId']
+        self.authToken = user['authToken']
+        
+        self.get_stations(self)
+            
+    def makeFakeSong(self, args):
+        c = self.count()
+        return {
+            'albumTitle':"AlbumName",
+            'artistSummary':"ArtistName",
+            'artistMusicId':'4324',
+            'audioURL':'http://kevinmehall.net/p/pithos/testfile.aac?val='+'0'*48,
+            'fileGain':0,
+            'identity':'5908540384',
+            'musicId':'4543',
+            'rating': 1 if c%3 == 0 else 0,
+            'stationId': args[0],
+            'songTitle': 'Test song %i'%c,
+            'userSeed': '54543',
+            'songDetailURL': 'http://kevinmehall.net/p/pithos/',
+            'albumDetailURL':'http://kevinmehall.net/p/pithos/',
+            'artRadio':'http://i.imgur.com/H3Z8x.jpg',
+            'songType':0,
+            'trackToken':12345,
+        }
+            

=== added file 'build/lib.linux-x86_64-2.7/pithos/pandora/pandora.py'
--- build/lib.linux-x86_64-2.7/pithos/pandora/pandora.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/pandora/pandora.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,348 @@
+# -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
+### BEGIN LICENSE
+# Copyright (C) 2010 Kevin Mehall <[e-mail]>
+#This program is free software: you can redistribute it and/or modify it 
+#under the terms of the GNU General Public License version 3, as published 
+#by the Free Software Foundation.
+#
+#This program is distributed in the hope that it will be useful, but 
+#WITHOUT ANY WARRANTY; without even the implied warranties of 
+#MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+#PURPOSE.  See the GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License along 
+#with this program.  If not, see <http://www.gnu.org/licenses/>.
+### END LICENSE
+import logging
+import time
+import urllib2, urllib
+import re
+import xml.etree.ElementTree as etree
+
+from pithos.pandora.xmlrpc import *
+from pithos.pandora.blowfish import Blowfish
+
+PROTOCOL_VERSION = "33"
+RPC_URL = "www.pandora.com/radio/xmlrpc/v"+PROTOCOL_VERSION+"?"
+USER_AGENT = "Mozilla/5.0 (X11; U; Linux i586; de; rv:5.0) Gecko/20100101 Firefox/5.0 (compatible; Pithos/0.3)"
+HTTP_TIMEOUT = 30
+AUDIO_FORMAT = 'aacplus'
+
+RATE_BAN = 'ban'
+RATE_LOVE = 'love'
+RATE_NONE = None
+
+PLAYLIST_VALIDITY_TIME = 60*60*3
+
+class PandoraError(IOError):
+    def __init__(self, message, status=None, submsg=None):
+        self.status = status
+        self.message = message
+        self.submsg = submsg
+        
+class PandoraAuthTokenInvalid(PandoraError): pass
+class PandoraNetError(PandoraError): pass
+class PandoraAPIVersionError(PandoraError): pass
+class PandoraTimeout(PandoraNetError): pass
+
+from pithos.pandora import pandora_keys
+
+blowfish_encode = Blowfish(pandora_keys.out_key_p, pandora_keys.out_key_s)
+
+def pad(s, l):
+    return s + "\0" * (l - len(s))
+
+def pandora_encrypt(s):
+    return "".join([blowfish_encode.encrypt(pad(s[i:i+8], 8)).encode('hex') for i in xrange(0, len(s), 8)])
+    
+blowfish_decode = Blowfish(pandora_keys.in_key_p, pandora_keys.in_key_s)
+
+def pandora_decrypt(s):
+    return "".join([blowfish_decode.decrypt(pad(s[i:i+16].decode('hex'), 8)) for i in xrange(0, len(s), 16)]).rstrip('\x08')
+
+
+def format_url_arg(v):
+    if v is True:
+        return 'true'
+    elif v is False:
+        return 'false'
+    elif isinstance(v, list):
+        return "%2C".join(v)
+    else:
+        return urllib.quote(str(v))
+
+class Pandora(object):
+    def __init__(self):
+        self.rid = self.listenerId = self.authToken = None
+        self.set_proxy(None)
+        self.set_audio_format(AUDIO_FORMAT)
+        
+    def xmlrpc_call(self, method, args=[], url_args=True, secure=False, includeTime=True):
+        if url_args is True:
+            url_args = args
+            
+        args = args[:]
+        
+        if includeTime:
+            args.insert(0, int(time.time()+self.time_offset))
+            
+        if self.authToken:
+            args.insert(1, self.authToken)
+            
+        xml = xmlrpc_make_call(method, args)
+        data = pandora_encrypt(xml)
+        
+        url_arg_strings = []
+        
+        if self.rid and includeTime:
+            url_arg_strings.append('rid=%s'%self.rid)
+        if self.listenerId:
+            url_arg_strings.append('lid=%s'%self.listenerId)
+        method = method[method.find('.')+1:] # method in URL is only last component
+        url_arg_strings.append('method=%s'%method)
+        count = 1
+        for i in url_args:
+            url_arg_strings.append("arg%i=%s"%(count, format_url_arg(i)))
+            count+=1
+        
+        if secure:
+            proto = 'https://'
+        else:
+            proto = 'http://'
+        
+        url = proto + RPC_URL + '&'.join(url_arg_strings)
+        
+        logging.debug(url)
+        logging.debug(xml)
+        
+        try:
+            req = urllib2.Request(url, data, {'User-agent': USER_AGENT, 'Content-type': 'text/xml'})
+            response = self.opener.open(req, timeout=HTTP_TIMEOUT)
+            text = response.read()
+        except urllib2.URLError as e:
+            logging.error("Network error: %s", e)
+            if e.reason[0] == 'timed out':
+                raise PandoraTimeout("Network error", submsg="Timeout")
+            else:
+                raise PandoraNetError("Network error", submsg=e.reason[1])
+            
+        logging.debug(text)
+       
+        tree = etree.fromstring(text)
+        
+        fault = tree.findtext('fault/value/struct/member/value')
+        if fault:
+            logging.error('fault: ' +  fault)
+            code, msg = fault.split('|')[2:]
+            if code == 'AUTH_INVALID_TOKEN':
+                raise PandoraAuthTokenInvalid(msg)
+            elif code == 'INCOMPATIBLE_VERSION':
+                raise PandoraAPIVersionError(msg)
+            elif code == 'OUT_OF_SYNC':
+                raise PandoraError("Out of sync", code,
+                    submsg="Correct your system's clock. If the problem persists, a Pithos update may be required")
+            elif code == 'AUTH_INVALID_USERNAME_PASSWORD':
+                raise PandoraError("Login Error", code, submsg="Invalid username or password")
+            else:
+                raise PandoraError("Pandora returned an error", code, "%s: %s"%(code, msg))
+        else:
+            return xmlrpc_parse(tree)
+
+    def set_audio_format(self, fmt):
+        self.audio_format = fmt
+     
+    def set_proxy(self, proxy):
+        if proxy:
+            proxy_handler = urllib2.ProxyHandler({'http': proxy})
+            self.opener = urllib2.build_opener(proxy_handler)  
+        else:
+            self.opener = urllib2.build_opener()     
+        
+    def connect(self, user, password):
+        self.rid = "%07iP"%(int(time.time()) % 10000000)
+        self.listenerId = self.authToken = None
+        
+        pandora_time = self.xmlrpc_call('misc.sync', [], [], secure=True, includeTime=False)
+        pandora_time = int(re.sub(r"\D", "", pandora_decrypt(pandora_time)))
+        self.time_offset =  pandora_time - time.time()
+            
+        user = self.xmlrpc_call('listener.authenticateListener', [user, password], [], secure=True)
+        
+        self.webAuthToken = user['webAuthToken']
+        self.listenerId = user['listenerId']
+        self.authToken = user['authToken']
+        
+        self.get_stations(self)
+        
+    def get_stations(self, *ignore):
+        stations = self.xmlrpc_call('station.getStations')
+        self.quickMixStationIds = None
+        self.stations = [Station(self, i) for i in stations]
+        
+        if self.quickMixStationIds:
+            for i in self.stations:
+                if i.id in self.quickMixStationIds:
+                    i.useQuickMix = True
+                    
+    def save_quick_mix(self):
+        stationIds = []
+        for i in self.stations:
+            if i.useQuickMix:
+                stationIds.append(i.id)
+        self.xmlrpc_call('station.setQuickMix', ['RANDOM', stationIds])
+         
+    def search(self, query):
+         results = self.xmlrpc_call('music.search', [query])
+         
+         l =  [SearchResult('artist', i) for i in results['artists']]
+         l += [SearchResult('song',   i) for i in results['songs']]
+         l.sort(key=lambda i: i.score, reverse=True)
+         
+         return l
+         
+    def create_station(self, reqType, id):
+        assert(reqType == 'mi' or requestType == 'sh') # music id or shared station id
+        d = self.xmlrpc_call('station.createStation', [reqType+id, ''])
+        station = Station(self, d)
+        self.stations.append(station)
+        return station
+        
+    def add_station_by_music_id(self, musicid):
+         return self.create_station('mi', musicid)
+         
+    def add_feedback(self, stationId, trackToken, rating):
+        logging.info("pandora: addFeedback")
+        if rating == RATE_NONE:
+            logging.error("Can't set rating to none")
+            return
+        rating_bool = True if rating == RATE_LOVE else False
+        self.xmlrpc_call('station.addFeedback', [stationId, trackToken, rating_bool])
+        
+    def get_station_by_id(self, id):
+        for i in self.stations:
+            if i.id == id:
+                return i
+
+    def get_feedback_id(self, stationId, musicId):
+        station = self.xmlrpc_call('station.getStation', [stationId])
+        feedback = station['feedback']
+        for i in feedback:
+            if musicId == i['musicId']:
+                return i['feedbackId']
+
+    def delete_feedback(self, feedbackId):
+        self.xmlrpc_call('station.deleteFeedback', [feedbackId])
+        
+class Station(object):
+    def __init__(self, pandora, d):
+        self.pandora = pandora
+        
+        self.id = d['stationId']
+        self.idToken = d['stationIdToken']
+        self.isCreator = d['isCreator']
+        self.isQuickMix = d['isQuickMix']
+        self.name = d['stationName']
+        self.useQuickMix = False
+        
+        if self.isQuickMix:
+            self.pandora.quickMixStationIds = d.get('quickMixStationIds', [])
+         
+    def transformIfShared(self):
+        if not self.isCreator:
+            logging.info("pandora: transforming station")
+            self.pandora.xmlrpc_call('station.transformShared', [self.id])
+            self.isCreator = True
+            
+    def get_playlist(self):
+        logging.info("pandora: Get Playlist")
+        playlist = self.pandora.xmlrpc_call('playlist.getFragment', [self.id, '0', '', '', self.pandora.audio_format, '0', '0'])
+        return [Song(self.pandora, i) for i in playlist]
+                  
+    @property
+    def info_url(self):
+        return 'http://www.pandora.com/stations/'+self.idToken
+        
+    def rename(self, new_name):
+        if new_name != self.name:
+            logging.info("pandora: Renaming station")
+            self.pandora.xmlrpc_call('station.setStationName', [self.id, new_name])
+            self.name = new_name
+        
+    def delete(self):
+        logging.info("pandora: Deleting Station")
+        self.pandora.xmlrpc_call('station.removeStation', [self.id])
+        
+class Song(object):
+    def __init__(self, pandora, d):
+        self.pandora = pandora
+        
+        self.album = d['albumTitle']
+        self.artist = d['artistSummary']
+        self.artistMusicId = d['artistMusicId']
+        self.audioUrl = d['audioURL'][:-48] + pandora_decrypt(d['audioURL'][-48:])
+        self.fileGain = d['fileGain']
+        self.identity = d['identity']
+        self.musicId = d['musicId']
+        self.trackToken = d['trackToken']
+        self.rating = RATE_LOVE if d['rating'] else RATE_NONE # banned songs won't play, so we don't care about them
+        self.stationId = d['stationId']
+        self.title = d['songTitle']
+        self.userSeed = d['userSeed']
+        self.songDetailURL = d['songDetailURL']
+        self.albumDetailURL = d['albumDetailURL']
+        self.artRadio = d['artRadio']
+        
+        self.tired=False
+        self.message=''
+        self.start_time = None
+        self.finished = False
+        self.playlist_time = time.time()
+        
+    @property
+    def station(self):
+        return self.pandora.get_station_by_id(self.stationId)
+    
+    @property
+    def feedbackId(self):
+        return self.pandora.get_feedback_id(self.stationId, self.musicId)
+
+    def rate(self, rating):
+        if self.rating != rating:
+            self.station.transformIfShared()
+            if rating == RATE_NONE:
+                self.pandora.delete_feedback(self.feedbackId)
+            else:
+                self.pandora.add_feedback(self.stationId, self.trackToken, rating)
+            self.rating = rating
+        
+    def set_tired(self):
+        if not self.tired:
+            self.pandora.xmlrpc_call('listener.addTiredSong', [self.identity])
+            self.tired = True
+            
+    def bookmark(self):
+        self.pandora.xmlrpc_call('station.createBookmark', [self.stationId, self.musicId])
+        
+    def bookmark_artist(self):
+        self.pandora.xmlrpc_call('station.createArtistBookmark', [self.artistMusicId])
+            
+    @property
+    def rating_str(self):
+        return self.rating
+        
+    def is_still_valid(self):
+        return (time.time() - self.playlist_time) < PLAYLIST_VALIDITY_TIME
+        
+class SearchResult(object):
+    def __init__(self, resultType, d):
+        self.resultType = resultType
+        self.score = d['score']
+        self.musicId = d['musicId']
+        
+        if resultType == 'song':
+            self.title = d['songTitle']
+            self.artist = d['artistSummary']
+        elif resultType == 'artist':
+            self.name = d['artistName']
+        
+        

=== added file 'build/lib.linux-x86_64-2.7/pithos/pandora/pandora_keys.py'
--- build/lib.linux-x86_64-2.7/pithos/pandora/pandora_keys.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/pandora/pandora_keys.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,362 @@
+#credit: ZigZagJoe
+
+out_key_p  = [0xD8A1A847, 0xBCDA04F4, 0x54684D7B, 0xCDFD2D53, 0xADAD96BA, 0x83F7C7D2,
+ 0x97A48912, 0xA9D594AD, 0x6B4F3733, 0x0657C13E, 0xFCAE0687, 0x700858E4,
+ 0x34601911, 0x2A9DC589, 0xE3D08D11, 0x29B2D6AB, 0xC9657084, 0xFB5B9AF0]
+
+out_key_s = [[0x4EE44D9D, 0xCCEEAB0F, 0xD86488F6, 0x25FDD9B7, 0xB0DE3A97, 0x66EADF2F,
+ 0xC0D3DCA4, 0xEE72A5FA, 0x54074DEC, 0xCBAD83AD, 0x4B1771A3, 0xD92AE545,
+ 0xB5FCE937, 0x26AD96D9, 0x5D615D68, 0xF2994B82, 0xE668D342, 0x61051D4C,
+ 0xCFB29CA4, 0x8B421D38, 0xDA3B4EB9, 0xD92D6A55, 0xF7D940C7, 0x99C4BC83,
+ 0xAB896E79, 0x77C7039B, 0x1215B24A, 0x0C0EBC0D, 0xE9F082B2, 0x6B7DFE9C,
+ 0x4A714E76, 0x91280D88, 0xA422A361, 0x3E674D4A, 0x6EBC2D42, 0x6838580B,
+ 0xBAE461AB, 0xE8FEDD17, 0xEFD6E5E0, 0x690D3E93, 0x32FADEB0, 0x1B99EE04,
+ 0xBE9FA7D9, 0x7997DFC6, 0xFD1B8025, 0x667B35D8, 0x2D909996, 0xFE487FF0,
+ 0x628BCFE1, 0xA534C620, 0x6644DEFE, 0x8BF9236D, 0xE943DD51, 0xF4615657,
+ 0x605D4F80, 0x2E02FC45, 0xD924D2D0, 0xFD4AB9E3, 0x5AEB18F0, 0x7A8D7C92,
+ 0x6CA40CA6, 0xD8AD4139, 0xCA5E7EC2, 0x69BE3C59, 0x554A4DD6, 0xBA474DD1,
+ 0xE113576B, 0xCB89A6BD, 0xF366EC0C, 0x876661AB, 0xD85E5381, 0x79A93327,
+ 0x5A4E5D92, 0xE3301F23, 0xF211DD61, 0x6F0140D0, 0xDBA134BF, 0x3C623008,
+ 0xD5FCE976, 0x6EDE648E, 0x814CF920, 0xB38878E1, 0x6232D49C, 0x2310373B,
+ 0xA8C6EBFC, 0xCD506842, 0x62BEF441, 0x1324C803, 0x69D1F137, 0x3907EE67,
+ 0x47967932, 0xC3C3F280, 0xC4B036B9, 0x5EC264B4, 0x9484AA3C, 0x5FEF9C53,
+ 0xC1B9030F, 0xE86C6BBA, 0x3AE49DAE, 0xBBAC421C, 0x54D06D99, 0xBA13A2B2,
+ 0x3132FA87, 0x2FDDB5E2, 0x4B751219, 0x5B59778F, 0xEFFA2E62, 0x3BD56164,
+ 0xE7EDFC1D, 0xCF4D5FDB, 0xC6310BDA, 0x0CAE8B8F, 0x53196C2F, 0xAC951D1F,
+ 0x32FD1D71, 0x7D9D5956, 0x2EA62C92, 0x9FA4A4C8, 0xE491DC41, 0x7E5F2507,
+ 0x4568300F, 0xF210AAA8, 0xB6980949, 0x017405E7, 0x5EBF3350, 0x44B863F6,
+ 0xDF96854A, 0xFA8A8390, 0x342BDFFA, 0x93096350, 0xCD0F0083, 0xBE295FDD,
+ 0x549AA9C9, 0x8554D31B, 0x2F2FE138, 0x30E8C78D, 0xED603733, 0x4B47F4C2,
+ 0x03D481DC, 0x8BE4479C, 0x9A307E98, 0x73CFC5DC, 0x71DE3DFB, 0x55DA2605,
+ 0x2CC97898, 0x13F0CC6F, 0x5F30FEE1, 0xF65D36D0, 0x99D05438, 0xB6A1DF23,
+ 0x2EA6EF9B, 0x12D3A110, 0xF1C89B1A, 0x522BAA1F, 0xE39AC7B3, 0xAFC153D1,
+ 0x2A565274, 0x51530B46, 0x1291387D, 0x15BC2B63, 0xA73AD01F, 0x13EBC4A7,
+ 0x849583D7, 0x4A9E1AE6, 0x430C9A05, 0xEB2A78FB, 0xFA3A817D, 0x6D1D7AE5,
+ 0xB99588F5, 0x6D2C571B, 0xF975441C, 0x1348927D, 0xB069BDE2, 0x0771A398,
+ 0x4B93EDCC, 0x3C167223, 0xC3BBCFDF, 0x40C406DA, 0x81C867B1, 0xEB20C3D2,
+ 0x2476ED54, 0xB581F042, 0x1160A8B8, 0xBCA1AD0F, 0xD8F18C9F, 0x708BC7C6,
+ 0x0579D83C, 0x29BAA2B8, 0x45B845EE, 0xA57F5579, 0xE52E4A8A, 0x48365478,
+ 0xC6CCBFB4, 0x2F53D280, 0x8E1FF972, 0xF4E02067, 0x3F878869, 0x5879FF3C,
+ 0x1EDFAB0F, 0xD4FE52E3, 0x630AC960, 0xABD69092, 0xFAA3BF43, 0xF1CA3317,
+ 0x9CFF48D2, 0x8FE33F83, 0x260C1DE3, 0x89DB0B0B, 0xF127E1E3, 0x7DA503FF,
+ 0x01C9A821, 0x30573A67, 0x8A567A2E, 0xE47B86CF, 0xB8709ADE, 0xB19ADD3A,
+ 0x46A37074, 0x134CE184, 0x1F73191B, 0xE22B39F6, 0xE9D35D3D, 0x996390AF,
+ 0xADBBCCDB, 0xC9312071, 0xD442107D, 0x0B50C70A, 0xB9B6CC8C, 0x60A51E0E,
+ 0xA1076443, 0x215F1292, 0x5A53C644, 0xEA96EA2E, 0xE9F3B4BC, 0xBA5F45D2,
+ 0x454B65D6, 0x2CF04D9C, 0x05EF1D0F, 0xCD1ABBEE, 0xE86697B0, 0xFB92F164,
+ 0xEBEDADBF, 0x69282B8D, 0x65C91F0D, 0x6215AB51, 0x87E7BDF6, 0xC663D502,
+ 0x6EF4864E, 0xDC3BDCC9, 0x97184DBB, 0xCD315EED, 0x64001E09, 0x6F7DE8CE,
+ 0x38435D03, 0x840B5C82, 0x23CDBC8A, 0x7FA0D4FB
+],[
+ 0xEBCBE20D, 0x09FADAEC, 0x98FF9F63, 0x16D0DFE1, 0x54B65FA8, 0x8C58D07C,
+ 0xEAACBEA0, 0xEA8BC5B7, 0xD343B8ED, 0x46D416FC, 0x0247DCBB, 0x527CA3F5,
+ 0x22DAF183, 0x6684CF7F, 0xA2D5D9F6, 0xC507E43B, 0x7B368AE6, 0xFC8179EC,
+ 0x47E959C4, 0xDADF15F2, 0x92E48145, 0xD9CFA8B3, 0x94F209E8, 0x10F93D6D,
+ 0x3BAAF7B5, 0x9E5009B4, 0xE7E66FD8, 0x10F6D58F, 0x1EAFFF4D, 0x0423FCE5,
+ 0xE860C60A, 0x7713B2B4, 0x7C5EEF7E, 0x430801CF, 0x46613A77, 0xFADEC916,
+ 0x58AB09B3, 0xEE05C51F, 0xD4C6331F, 0x9BCA1941, 0x15BF041F, 0xC3B04E8D,
+ 0x6CD037AF, 0x11C81E53, 0xB38393DF, 0xB1D07B52, 0x067D02F7, 0xA9E5798B,
+ 0x4E5C10A6, 0x790DD862, 0xDEA21AD1, 0x3C0C90BF, 0xB05D8240, 0xFEA81F59,
+ 0x832F19FF, 0x17190D1C, 0x03E07FDC, 0x43A6AEAC, 0xFE0C8A2E, 0x216813A6,
+ 0xF0428728, 0xC1D21DCF, 0x54109ACB, 0x68FB51BB, 0x3F5AEE69, 0x557FEA14,
+ 0x07965E16, 0x58E2A204, 0x6E765B0C, 0x3B8D920F, 0xDD712180, 0xDD0F67CA,
+ 0x37F9D475, 0x91815CCF, 0xC31A34BB, 0x8F710EF2, 0xF2DA2F82, 0x2A24931B,
+ 0x41CFF29F, 0x16C9BECF, 0x1AEB93FB, 0x090DF533, 0xC10D27B6, 0xF7EE2303,
+ 0xF82A0ED0, 0x57031132, 0x88AFF451, 0x574A8BFF, 0xF1ACA4F0, 0xDD556F49,
+ 0x90D7CF52, 0x4BCA4AA3, 0xC917557C, 0x4BB6B151, 0x52CD8251, 0x7C7ED836,
+ 0x3488ED59, 0xC50C6A0B, 0x675413ED, 0x6368583D, 0x98B61BAE, 0x1AF59261,
+ 0x46590022, 0xA4C70187, 0x4658F3EB, 0x80A61049, 0x8F120E7A, 0xBEAC09D8,
+ 0x195ACD49, 0x6BE1DE45, 0x6EF1E32D, 0xB8A4B816, 0xC18758B8, 0xCA7AD046,
+ 0xD475BFE1, 0xCC3AB8AF, 0x45AB9AD7, 0xC37C62AC, 0x9AAD7E2E, 0xB9D87862,
+ 0x28F3CD26, 0xA0577A0E, 0x75859ECE, 0x4A6E5B86, 0xE61E36B3, 0xA00E0CA4,
+ 0x3E2CC99C, 0x581DF442, 0xCE40B79B, 0x17BAB635, 0x73F1C282, 0x7C009CE0,
+ 0x1A8BBC5A, 0xBBB87ECD, 0x162ED0AC, 0x8DB76F5A, 0xD5AD1234, 0xD0D7A773,
+ 0x41CBDEFB, 0x7197AFF4, 0x5C60E777, 0x5D9141D4, 0xF43D5211, 0xA4F064D9,
+ 0x40C13CB3, 0xE9DE900D, 0xBF733203, 0xC00F2E89, 0x095D476F, 0x277A825D,
+ 0x4B6A61D3, 0xFF857740, 0xE34705C0, 0x65F8372C, 0x497AC161, 0x1231CA4A,
+ 0xFB385036, 0x24B36150, 0x6CB9FA2D, 0xCBAB3399, 0x3832629E, 0x1BB815EE,
+ 0x6AAA74C7, 0x8FFA22B8, 0x64093F28, 0x973BBA95, 0x831A8195, 0x48B2923D,
+ 0x9680C36E, 0x16BA5344, 0x1F190542, 0xBCB0DFCC, 0xCCC24623, 0xFA503EAD,
+ 0x7189956C, 0x80B3C715, 0xFA9F4685, 0x36CF833E, 0x19A53ADF, 0xA5A4BD79,
+ 0x187ADC8D, 0x8AEFA6B6, 0xF64FF62A, 0x88A590BA, 0xE30C75BE, 0xA3BFBCC7,
+ 0xAC669722, 0xC4AEAFF2, 0x822DC5FA, 0xAA73C1D5, 0x422EFD93, 0x946FE915,
+ 0xEF623E46, 0x24395A31, 0xF28FF488, 0xB4D7CA7E, 0x27703504, 0x9F390B73,
+ 0xA6999558, 0x8AE04A20, 0xDD6FE7DB, 0x55963137, 0xCFEF70BB, 0x708CA677,
+ 0x804CF78B, 0xD5AC1CA2, 0x88D7CCFC, 0x5FE056DF, 0x25B390EA, 0x11550845,
+ 0x15A58C0B, 0x7C3530A3, 0x24550544, 0xD395EDD0, 0xEB046782, 0x7E3CCE71,
+ 0x25A8640C, 0x96A955DE, 0x4BF7614E, 0x3014FD08, 0xE2AC1E2E, 0x7D3AB3C3,
+ 0xB63CB59C, 0x9E92D401, 0x859B2C44, 0x1F893940, 0xEE81B9BB, 0x7F430589,
+ 0xAF2CC2EC, 0x0FA273E2, 0x3E5C6FAA, 0xE580E6A9, 0x64D73FE6, 0xE7C5A28A,
+ 0x99B760BC, 0xC0FCBA71, 0xDB521C76, 0xDBC7C1F8, 0x4968CF63, 0xD4928D17,
+ 0x6DBBCC5F, 0x681EB668, 0xC326CEB9, 0x7C6B0EBB, 0xF071C193, 0x5CC6A08C,
+ 0xFA4B95EB, 0x0BED345D, 0x16854F61, 0x22ECDDA9, 0x77335F2D, 0xCC016EE5,
+ 0x4CE1D7F6, 0x32B1409B, 0x2197B046, 0x73CD94F3
+],[
+ 0x56D997EE, 0x92FA3097, 0xA1AF0D9D, 0x11FCBB9C, 0xA2673993, 0x3860F1CE,
+ 0xB2B70A39, 0x5BC90183, 0xBFA62ADC, 0x58E257F2, 0xD221A704, 0x0A876CE4,
+ 0xD7B0FCA9, 0x80D3D874, 0x696A6CFD, 0xB989EFF1, 0xEAA5F132, 0xA29ECB5D,
+ 0x674B7380, 0x0BAD725F, 0x59D55508, 0x8DB40E2A, 0x003EBD12, 0x871AD00E,
+ 0x7ACE20A9, 0xE670BA85, 0x43D53997, 0x79461049, 0x806C102B, 0xB21337BD,
+ 0x791483E8, 0x6ECA44EA, 0x959CF50D, 0x8D87166D, 0xFA939DF8, 0xB0E519DE,
+ 0x8C069B44, 0x0A47F71A, 0x8D7AD1CA, 0x24E6FEDD, 0xCEF2173E, 0xB46A57F1,
+ 0x9DD9C775, 0x549B2E5D, 0x67A37485, 0x38F7FC18, 0xA269F5A1, 0x1B04F14E,
+ 0x4550E006, 0x8F5E0E14, 0x5EB9992C, 0x88D780A5, 0x334FFA1E, 0x473A75C1,
+ 0x9D96E913, 0x7DB16188, 0xE699B708, 0x88D087FA, 0x06E44D4E, 0xCB29E519,
+ 0x68529AB8, 0xBC74B1FD, 0xDA074140, 0x557B9936, 0x80BB557E, 0x42522D24,
+ 0x909E967F, 0x7D578A28, 0x7F78EBD7, 0xB793DC4B, 0x08498F07, 0x8A77FC08,
+ 0xFFFDA0C1, 0x2ECA4123, 0xB63861DC, 0xD909606E, 0x29A545E4, 0xB37539D6,
+ 0x292FAC93, 0xBDC6C4F3, 0xDAC7CE05, 0x68201C9D, 0xE08DC67A, 0xE0FB0327,
+ 0x17554D62, 0x636D9040, 0x0612D29F, 0xAF250475, 0xB8961740, 0xBE3E4408,
+ 0x3AF166E6, 0x3B16CC87, 0x2DC77141, 0x3C874024, 0x0E409623, 0xC7576B7A,
+ 0x35CAF7DA, 0x0AA9AED6, 0x6C5F2CC0, 0x23AAB90F, 0x74A41C51, 0xDAA1B557,
+ 0x412EC422, 0xD9E55CF0, 0x7F6A804E, 0x9256A133, 0xF3FD2639, 0x42C9A68A,
+ 0xB20588E4, 0x33339C04, 0xCB9B9300, 0xCCA198E9, 0x849A2FFF, 0xF2B71118,
+ 0xD27C41DF, 0xF1453CD9, 0xEB94D640, 0x9CE6A69E, 0x1561C1BD, 0x8A8F7E07,
+ 0x1FA3989C, 0x601C3440, 0x95DE5ED8, 0xB2F2AE94, 0x831BA7C3, 0x6831E3ED,
+ 0x5C5C0BD8, 0x628A0E89, 0x2726D7A3, 0x82B6E434, 0xB729A5C7, 0x5AB563C2,
+ 0xA4119CE6, 0x4459E404, 0x0B3E858A, 0x080C2DF9, 0x6EBE3FFB, 0xC1D64BCE,
+ 0xB2C90336, 0x998AE507, 0xC152879A, 0x31B99F23, 0x37769978, 0xF5C78668,
+ 0x2B954114, 0x54169F1A, 0xBF9E6E7D, 0x41BEBC39, 0x35BC63BD, 0x77E91F12,
+ 0x89909690, 0xCB17B79D, 0xCCBF4A25, 0x3E5E653E, 0x3B4531F1, 0x31AF6109,
+ 0x027DC03F, 0x334AE2A7, 0x8A685A70, 0xD82C335D, 0x7D73C193, 0xF0311C79,
+ 0xE8091EAF, 0x64B12983, 0x85CEB9A6, 0x402AB7C9, 0xA95E4546, 0x85CE4FD7,
+ 0x21968004, 0x0846E117, 0xD290B888, 0xCE2888FC, 0xE2F318F1, 0x89B189DD,
+ 0x7A2D73BA, 0xE28937E5, 0x6D857435, 0x8A2F05FA, 0xA19B966F, 0x37EF297F,
+ 0xC50696F5, 0xA7C3DE1A, 0x988D3850, 0x24007793, 0xB94C792C, 0x4DA98736,
+ 0xA04EB570, 0x4AA44F84, 0x7124E7C6, 0x13B9026E, 0x27AC2D15, 0xFBB9AD93,
+ 0x2F94AA1C, 0x98587A3D, 0x9C9DB996, 0x7E3487D5, 0xA819272C, 0x32AA5E43,
+ 0xE0DB72F5, 0x4DB4853C, 0x7350C7EC, 0xB1626C73, 0x07130A5F, 0xC3DAA529,
+ 0xD6422735, 0x8559200D, 0x1046E85C, 0x326CFB54, 0xAD42DB6A, 0xAE4CC364,
+ 0xA49F5718, 0xF472F8A0, 0x3C002484, 0x013067BE, 0xC88A1317, 0x4C3C209B,
+ 0x7CBB8BB3, 0x41FB8DAF, 0x236591B3, 0xDC974A45, 0x8639E738, 0x97C38B19,
+ 0xD7FF5725, 0xE7094458, 0xF28B223F, 0xF73C878B, 0x7F7502D9, 0x52F7FD09,
+ 0x4A661B36, 0x62814D8E, 0xBBDD1D16, 0x002598D9, 0x56B17A84, 0x87A331B7,
+ 0x6C2898C2, 0xAFCBA795, 0x4EFEE9AE, 0xEAE3A4F1, 0xC3D4D9CD, 0x5EFD7C32,
+ 0xB1B31E64, 0x95245686, 0x21A7DA12, 0x7155E041, 0x7362B475, 0x36486BD5,
+ 0xA97E5D7C, 0x8871303B, 0x93199D52, 0x246F919E, 0x5A581359, 0x6AE746DD,
+ 0x3CA9098C, 0x56DA5714, 0xAA0B674A, 0x08C89A5D
+],[
+ 0x7DD47329, 0xF270A704, 0x71BF31DA, 0x3B57772E, 0xFBE90F4B, 0x87FC23F6,
+ 0xCF413D71, 0x4FFEA8EC, 0xEFBA20C2, 0xEB53E0C1, 0xFFE7633E, 0x854E28E8,
+ 0xFBFFE904, 0x8A7841BE, 0x94E99960, 0xA3E69064, 0x365C57AB, 0xBEE976CC,
+ 0x596B94C2, 0x8C5E90E2, 0x074B3C54, 0x89B5E926, 0xDF192C71, 0xAF631D85,
+ 0x67A8EDEC, 0x24BE4919, 0x81EB9C8A, 0xFDB13471, 0xEE61A4A1, 0x1EE368DE,
+ 0x8C55C255, 0xD273A000, 0x12A24DCD, 0x22A6708E, 0x6BB4C19A, 0xF2599FDE,
+ 0xE84B8A95, 0xDD578159, 0x1F666F1E, 0x483BBCE2, 0x46E340BA, 0x8B7D6490,
+ 0xE65BD77D, 0xA50F2282, 0x4B455D23, 0x9B5D486B, 0x95CEA1A3, 0x4B7A484A,
+ 0x2E16BE82, 0x096A8E05, 0x5494AF5E, 0x1EBA1525, 0x84FDB773, 0xD47CE143,
+ 0xC1254007, 0x1CE4CBBE, 0x8049402D, 0x114D7B59, 0x64D760AD, 0x6AEECE49,
+ 0x83DC9867, 0x36FF9C28, 0x6FFB709D, 0xB22F7301, 0x6E6CAD92, 0x0001F394,
+ 0xB560CDE7, 0xEA02FDDA, 0x40609266, 0x7F599B81, 0x1B8FD59A, 0xA562FF5C,
+ 0xA01750C6, 0x78A35114, 0x789F8094, 0xF46594B8, 0xFF3A12BE, 0x29DDEB50,
+ 0xE3CF5A2C, 0x8E440B20, 0xBFBF3DD8, 0x649DB58A, 0xC48A8A51, 0x97F139C3,
+ 0x0BB07943, 0x548C90BD, 0x8153FCF1, 0x13098DEF, 0x812EA492, 0xFC0AC487,
+ 0xC5EAE50A, 0x7A02481B, 0xC75279D7, 0x59CBC149, 0x6AB39416, 0x39331E1A,
+ 0x233BE50B, 0x7F09C1BD, 0xECC11E6E, 0xA6647D03, 0x06BD33AD, 0xD717C795,
+ 0xE07E2D67, 0x2688D40B, 0xE23E349F, 0x8C7F559E, 0x3BA698C2, 0xEB5FCD3C,
+ 0xE94E2DE5, 0x3C0FE4DF, 0x55454456, 0x12731019, 0x21AF58D7, 0x2555CE03,
+ 0x17BBC647, 0xF0C66012, 0xE02D87F8, 0x340DB0CE, 0x72A3766F, 0xE2724C51,
+ 0x3636A5FD, 0xC226C419, 0x1A5F0464, 0xA543817B, 0x0B850A8D, 0xD5A6F88B,
+ 0xCE3715B8, 0xB73918A2, 0x6AC92E61, 0x0FCD43EA, 0xF559EEDE, 0x3482C340,
+ 0x447D9924, 0xF95D6EB2, 0xB22E6C6F, 0x935740D2, 0x7C04B228, 0xB90ABD1A,
+ 0x8D9D01C9, 0x43B63B2D, 0xE0EBEDAC, 0x7C219604, 0x8479756F, 0xB67355FE,
+ 0xA056539B, 0xAF1D5A02, 0x6660BB07, 0xD1A0593C, 0x5AABEF47, 0x73802FC5,
+ 0xAADB5251, 0x92556CFF, 0x5BF44BDC, 0x4DC171CF, 0x1EE4E879, 0x516BC896,
+ 0xCDBB21EA, 0xF513BD04, 0x94267720, 0x6B29DAC1, 0x1D778D67, 0x9625EA42,
+ 0x23946BBC, 0xF23D2E0A, 0x001C2CFB, 0xEF121203, 0x963A0C2B, 0x1AAE960B,
+ 0x13F2D588, 0xAE6BFEAE, 0x77424AC8, 0x1E0B2A9F, 0x9074C626, 0x9BCDE764,
+ 0xF8539561, 0xC14A5B05, 0xD88D9FAE, 0x2C5C4C67, 0x2C63BAE5, 0x99CCF4CB,
+ 0x3563CA53, 0x0CE7A114, 0xCB8938D3, 0x7C61537F, 0xE717A35E, 0xB69D3832,
+ 0xE47931C3, 0xD5C9D409, 0x355E0B97, 0xC60EB27E, 0xB17978F6, 0x77CCBCEA,
+ 0x85AEFA12, 0x59DFA376, 0x36DB61D2, 0x96832915, 0xCC4411F3, 0xB81F1EF9,
+ 0x2C54E5E1, 0xDD3CE944, 0x02D92E29, 0x1D4795B1, 0x27F900B0, 0x97A516CC,
+ 0xA2DB2CC8, 0x3125B863, 0xBF44DC77, 0x211A0226, 0x3A98AB5F, 0x2612396E,
+ 0xA1BEF080, 0x708B7433, 0x5D457230, 0xED03C4EB, 0xA84D73AE, 0x89D5582D,
+ 0x95F0C7FA, 0xEF51B8C9, 0xF9DCA97D, 0xCB2E49FD, 0xC12B4ADD, 0x611C9AD5,
+ 0x35D1D7CE, 0xA77E13BE, 0x207C1B88, 0x0AC289D4, 0x4B553B81, 0x4940991A,
+ 0x23D9F9D5, 0xDFD93925, 0xB924E9D2, 0xBFA61D10, 0x861FDF0F, 0xBBD30811,
+ 0x953CE5DA, 0x92B48334, 0x5E5B44FC, 0x5B949533, 0x31A5D165, 0x99339641,
+ 0x2737671F, 0x512EB25C, 0x54408346, 0xA090A7FE, 0x1D9CA5F9, 0x470C19E4,
+ 0x720F936E, 0xA8628453, 0x364D29CC, 0x42E472DF, 0x54949196, 0x6C7C46EA,
+ 0x12797418, 0x7D775295, 0xC46A7C32, 0x69CE8560]]
+
+in_key_p = [0xD825B592, 0xA73D0737, 0x3F7C28AE, 0xF91F7116, 0xEF6B001E, 0xD38524FD,
+		0x547F01EC, 0xE9C9DF7C, 0x25DE8E97, 0x9F45FF21, 0x87479245, 0x74A5FE7A,
+		0x9D4A1EDB, 0x7EEFCA76, 0x58B117C2, 0x0E7F33BE, 0x1C840B7A, 0x15EEE858]
+
+
+in_key_s  = [[0x4A0BABBD, 0x46B75CE1, 0xDA4E60D7, 0x62DD8F22, 0x668D7291, 0x70330C71,
+		0x8ECE2964, 0xD4D1D24F, 0x2247D3FF, 0x33BD2D83, 0x2A7DF912, 0xB9E711C8,
+		0x0E6544DB, 0x3A45B663, 0x8A9AB3DB, 0xD1A18732, 0x12700956, 0x25D9E559,
+		0x9A425C80, 0xCE51C1BD, 0x73D8583D, 0x22B93DE3, 0x3FF39FAF, 0x3B2E11F8,
+		0xA29731D0, 0x4F2C315F, 0xB46182CA, 0xB28C562E, 0xC37A96D9, 0x8AF05087,
+		0x745FB822, 0xEBC3F308, 0x2F40C980, 0xE16657A1, 0xBDECD15A, 0xC9948113,
+		0xD13F34A9, 0x526A159F, 0xF5982C49, 0x55E2220D, 0x0EAA7A36, 0x90771A3B,
+		0x852D659D, 0xF42B33CE, 0xBC55AB70, 0xD58495F9, 0xA01A146A, 0x146E0960,
+		0xDCC3EAFB, 0x45561BA0, 0x978C2955, 0x040E66A1, 0x54A12BDC, 0x86EB78C4,
+		0x317B7AB9, 0xC1131F78, 0xBC67C341, 0xF8850A30, 0x26EBAEB3, 0xA21BAB96,
+		0xF252C98A, 0xE8B913F2, 0x9237DBF2, 0xC549F051, 0xB37EBAEB, 0xE1BBC775,
+		0xC1655D75, 0x630A0946, 0xAEE49047, 0x4EC591BF, 0xB155B99A, 0x2EEC5B73,
+		0xDE713B06, 0x12A634B7, 0x13CE8AB7, 0x938D6C99, 0x3596EEE0, 0x500F9066,
+		0xF6F80717, 0x40D95E18, 0xC1D47A2E, 0x8DEE1E05, 0xE37E36A2, 0x54C7FFD3,
+		0x4AFFB9CF, 0x214CF5B8, 0xAB68B547, 0xB7CC1821, 0x5C7DA859, 0xB2DA7DDF,
+		0x846494FA, 0x8CB04D15, 0x1A4A71A2, 0x5FF08D8A, 0x8768DF65, 0x924E2FE3,
+		0x04B8109A, 0xE418742A, 0x58CD8113, 0x0EF7AAC9, 0x92B0CF79, 0xB01FBED2,
+		0x4DE3CE22, 0x6B779E20, 0x1CF126CF, 0x1789A794, 0xA8463DA6, 0xF3CCE7AC,
+		0xD225730A, 0x2D1B121E, 0x3F2C0850, 0xE327010B, 0x56D95881, 0x8639B3AE,
+		0x01B3CAEB, 0x1F6F9304, 0x7D4BF367, 0xE4EC20D9, 0x6D05AA51, 0x882B710D,
+		0xFC409837, 0x65E212C6, 0xA4C94A87, 0xB11A90AE, 0xB575256C, 0x9C12AF15,
+		0x682F72EA, 0xC4C8CE09, 0x43F6C164, 0x4BD015D9, 0x9B9B1FCE, 0x9C108425,
+		0x40A8DF10, 0xB0BC8633, 0x974EBB7A, 0xDE6FCE1C, 0xE005634D, 0x708C699E,
+		0x7D5BFC2F, 0xBC8D5BD0, 0xF0CCE026, 0xB5F50E04, 0x84124BC7, 0x9A34780C,
+		0x34E8E954, 0x64E165A3, 0x3007959D, 0x8DA44C08, 0xAA10D841, 0x7E876AE0,
+		0xB6020431, 0x47F4EA6A, 0xF4825054, 0x16C42BDB, 0xD1965562, 0x3777B610,
+		0x74B5741E, 0xD60C40D9, 0x3A5EF183, 0x8716250D, 0x91797C4D, 0x01A28965,
+		0xF9161DBC, 0x44A9E602, 0xABECEF05, 0xAA90BA96, 0x76607DBD, 0x48BF5BB9,
+		0x25840A8A, 0xD1AC56A6, 0x6F9B4274, 0xC56846D3, 0x88CF0D6B, 0x324EEFC0,
+		0xEA8304DF, 0xA27E4A81, 0x9AAB617B, 0x3301C499, 0x50E8FF17, 0x67B48F3F,
+		0x5AFB3B82, 0xF316F7D3, 0xBA425BB4, 0x083E12F4, 0x1CFAB3DB, 0x78C088A9,
+		0x6EC83605, 0xB46D30E9, 0x7A45D4FE, 0x1A31BAD8, 0x29242D72, 0x71EFF75F,
+		0x6DCFAC98, 0x79A1261A, 0x3865EEF5, 0x619461A3, 0xC25A0231, 0x750472D2,
+		0x7B714CBD, 0x7E57A0B8, 0xB3A7319F, 0x3FDDBEAB, 0xC4A71E85, 0x44D38329,
+		0xA21B0851, 0xBD44AE96, 0xFA3AF1D0, 0x3D6766B9, 0xA6884E85, 0xD3C9A0C0,
+		0xCAE680FC, 0x41C31A2C, 0x091EDF2D, 0x9EA4E645, 0x1CA034CC, 0xE10DBA18,
+		0x922AA9DC, 0x2DC318CB, 0xC49D6F10, 0xEEE7A768, 0x8173DD96, 0x96552598,
+		0xAB254BF2, 0xA5BFDEE8, 0x898E4896, 0x049DCDBA, 0x57BDCC74, 0x0F3399A4,
+		0x63909424, 0x6FEF1E46, 0x36A47384, 0x51F036DE, 0xAE707EA0, 0xDA83353C,
+		0xFB9E7298, 0xF9DCF17E, 0x4F6FEF42, 0x2A41B840, 0x7DCD2662, 0x381FEF90,
+		0x1773E656, 0xF6029EC1, 0xB1592A3B, 0x10A656D4, 0x6DDB2E61, 0x8E02EDFE,
+		0xE32782EA, 0x973D37F5, 0x1594C629, 0x8B73C632, 0x1680A138, 0x3F5B1228,
+		0x8C29E932, 0x49D384A2, 0x02794495, 0x118FF2E5
+		],[
+		0xAE22E435, 0xBF7344EB, 0xFBF3614E, 0xB52AF67A, 0x15EC7E8B, 0x0615CD74,
+		0x310931B6, 0x069D7297, 0x455368A0, 0xEEB001F7, 0x0E925151, 0xDEB13D62,
+		0x939071EE, 0x0BD2D2D2, 0x22AFF084, 0xF3D5BA75, 0xE8B78473, 0xE164B152,
+		0x8DD31804, 0x1AABFA34, 0xF1837C1B, 0xF50D14CB, 0x44F64DC6, 0x25C4CAC7,
+		0x59A2FE4B, 0x0C9E6026, 0x96A8908C, 0x49C0551E, 0x6C952FD7, 0x24BAEAA2,
+		0x6B9DC320, 0x727310AD, 0x09873DE7, 0xA815543B, 0x106743C6, 0xF4CDF032,
+		0xFB0208AF, 0xD58B37B0, 0xB8916BBB, 0xF31DC932, 0xB2273875, 0x94BFDD76,
+		0x2165879B, 0xA652B81E, 0x584698E4, 0xB42AF09E, 0x4DFF38F3, 0x29845BD7,
+		0x14F3B627, 0x5ECA5580, 0xFBDDDBB3, 0xD8392CB3, 0xF6B4FBE5, 0xFDCF2025,
+		0x31B61951, 0x9E588D9D, 0x25A07E35, 0xDCA8D140, 0x8C973391, 0x70C83894,
+		0x1B2F0DC5, 0x248E1EA0, 0x0760336A, 0x8F8BB40F, 0x0D1A660E, 0x0D1640F6,
+		0xA32B1F16, 0x3809890F, 0x82F7F0EA, 0x6CCC940F, 0xB9F2C42E, 0xB661A456,
+		0x5901ECB5, 0x76B92DF6, 0x21DB5718, 0xE23F3AED, 0xF94A8A63, 0x89F64664,
+		0x7335C780, 0x9FF900EB, 0xAC5D42D8, 0xF6049DC4, 0xB99BED2A, 0x3FE7D758,
+		0xDB69E89D, 0xCC9C3333, 0x382BB23F, 0xB07FB181, 0x9B20B744, 0x4E4ECE5D,
+		0xED8E3B98, 0x4AB66852, 0x78BCC661, 0xC1D8A28C, 0x71E08EB0, 0x9ECAE411,
+		0xA4FD636D, 0xA064969A, 0x185B05EC, 0x54896D93, 0x8110F40B, 0xD4D7E57C,
+		0x1E928C46, 0xF9CE1F29, 0x3E72FB51, 0xA79C044C, 0xADB9445E, 0x4AA394F9,
+		0x129534D2, 0xDF211944, 0x6267B4DA, 0xF534A6F8, 0xD45D2B3E, 0x5F1894E4,
+		0xCC27E376, 0xFE866D4F, 0x956E7C8E, 0x0A630CE7, 0x4734673B, 0xBF8AB871,
+		0x432C515F, 0xA2D7B37F, 0xCF48F9F8, 0x31F7209B, 0xB6E792D9, 0x5E136600,
+		0xF583A945, 0xAAD4705F, 0xE8E30373, 0xA5E5AB27, 0xCAC6FA4A, 0x48F3A109,
+		0xB21A697B, 0x45B9B7F0, 0x2E7BB193, 0x9603F1BB, 0xE0BA7A40, 0xCE7EB62E,
+		0x334B24C5, 0x0261817E, 0x4EB792AB, 0xB85BC2B6, 0x6D47D0D9, 0xD2A1433B,
+		0x7523942B, 0x39BF5CE7, 0x72223B25, 0xC28F0913, 0xC01CFE44, 0x500F27E5,
+		0x055379CB, 0x786C7B08, 0x7C75295A, 0x6294932D, 0xF1B01EF0, 0xE79358F6,
+		0x89C4E49F, 0xE7F73D07, 0xEF6FE437, 0xF2CDA93F, 0xB0994E68, 0xADF6AC19,
+		0x00925578, 0x06454AF8, 0xCE4628AB, 0x9F983E8C, 0x393E59A4, 0x3896C188,
+		0x6A0A5EF5, 0xBA378BF3, 0xD27590ED, 0xCFD20FF9, 0x1728237A, 0x8DABD973,
+		0xE22C9842, 0x29A1264B, 0xFFC8569C, 0x17DDEBAA, 0xF9D62958, 0x11028197,
+		0xC42BD84F, 0x6F81854B, 0x061FD297, 0xD26BA792, 0x63F71BAA, 0xAD36BDCC,
+		0x06262269, 0x5711A1F5, 0xAA746143, 0x75242F8D, 0x5817A84D, 0x639ED1B6,
+		0x6D18D6C4, 0x4FFEFE01, 0x0689F6D4, 0x5997D712, 0xD761CF5B, 0x9211216C,
+		0x5D8006F3, 0xDDE24FEA, 0x1E60F66B, 0x18D41ABC, 0xDC72B4CB, 0x9FBCBA7D,
+		0xEAA807C5, 0x700B7E32, 0xCF4173D6, 0xE354A49E, 0x12EB5466, 0x63DCC4E4,
+		0x1DC24D6E, 0x1C9F2A83, 0x3DF6F311, 0xFFA91651, 0x3A1A9645, 0x30D568A4,
+		0xC51A55B4, 0xEE032227, 0x0F0A28AC, 0x4516C9B2, 0xD7323F98, 0x547C3B78,
+		0x5BCA33E1, 0xF28A15C2, 0xDFFEFAAD, 0xD6E87BBD, 0xE820C21D, 0xFB1C97C3,
+		0xE40869F7, 0xD4A167F0, 0x79A2EFFC, 0xD67A0D93, 0xE862FF06, 0x54BCFB17,
+		0x3420A670, 0x9219126B, 0x54930637, 0x55E84ED3, 0xA8C4D3C6, 0xFC2C2BD2,
+		0x73B116F0, 0xE7A2900C, 0x801E1978, 0xC6741B16, 0xFADB0E61, 0xB5315FC8,
+		0x76D1E2BD, 0x2C3452EB, 0x9F42E977, 0xBBE3B7FF, 0x3E5A0B7F, 0x4E1E865A,
+		0x24D40A06, 0x202F6EDB, 0x9BAEBAFA, 0x6272D57D
+		],[
+		0x72B35463, 0xF3AD17A4, 0x5631E69E, 0x407BBD75, 0x3508A084, 0x88AAF1CE,
+		0x4B04905F, 0x2F2FEBE0, 0x09AA8992, 0xDE1EA57A, 0x1FDBFAFD, 0x3827C109,
+		0x764DFD38, 0x5C4A2FB0, 0xA1E90138, 0xF4814033, 0xD086FC2A, 0xB388B360,
+		0xFEA5D332, 0x47202A75, 0xCD25CB9A, 0xA351B744, 0xB7F4A6B6, 0xEE1658C0,
+		0x5016807B, 0x12574F7A, 0xB517B43C, 0x741262F5, 0x6F00F349, 0xDAA44579,
+		0xE58B8090, 0x6FC04F54, 0x8451D14A, 0x84C352B4, 0x710C2858, 0x0FE8F84C,
+		0xAF5E81F8, 0x0865497B, 0x552638F9, 0x3109EBED, 0x13C29D74, 0x276CB543,
+		0x8CA65E96, 0xE983C198, 0xB85CDC58, 0xB522FBCD, 0x21506FF9, 0x8C703690,
+		0x322A3026, 0xB87B9BA5, 0x49FF5C4F, 0x3B3E927D, 0xCC9E8227, 0x064CEA69,
+		0x88F21343, 0x4EDCB6EC, 0x0F7DA6B8, 0x2ABCEF9C, 0x86866163, 0xBF4B1B4F,
+		0x94E0E0E7, 0x8CFE5DF6, 0x4A8D073B, 0x43916370, 0xBCED0841, 0x2D8EF63A,
+		0xFEFC6AE8, 0x7A3284CD, 0x51FAE69D, 0x34996231, 0x15599997, 0x5A8D2DF2,
+		0xDC8F5265, 0x2B23915D, 0xAC578846, 0x0B9BC885, 0xE5AEF368, 0xE352A2EB,
+		0x67330720, 0xFD176A18, 0x78BB578F, 0xB5422A51, 0x68F35707, 0x47570020,
+		0x8A4F5321, 0xB6774AB5, 0x06CE136C, 0xADED4447, 0xAE8A1FEE, 0xB97BAB2D,
+		0x95B81706, 0x493E002C, 0x0D9DC930, 0xF70BF46D, 0x229C90F8, 0xAF450341,
+		0x12B799C0, 0x98656508, 0x8C8D6417, 0x491D1ED4, 0x1AF33256, 0xF3275DE1,
+		0x08454958, 0x321A8D4E, 0x4F516FE5, 0x1D076087, 0x94311B59, 0xED369CB9,
+		0x4FF94F65, 0x87129FB4, 0x8D065220, 0x7B11F2D5, 0x976138B0, 0x030962FB,
+		0x8E68ED5F, 0xE26B5272, 0x045BCBEB, 0x9350F121, 0x522DDFEB, 0x1EEB70B2,
+		0xCC2EABF8, 0x22BA4ED7, 0x30B0C3BC, 0x64DF8A4C, 0xF58B3FF2, 0x56B3BBE6,
+		0x3E71A700, 0x65D765C7, 0x87A50635, 0x9156084B, 0x85CD7CAA, 0x7BFF8FFF,
+		0x7B79A939, 0x69277DCA, 0x5A7C5DF2, 0x37886A35, 0x177CA1B3, 0x96871FD4,
+		0xB869BA3D, 0x1C2697A1, 0xD59109DD, 0x6B870F45, 0xC9ADBA95, 0xDB8323D8,
+		0x0A777311, 0x25E2DF2D, 0x18C684D7, 0x645521B0, 0x58ABD6FC, 0x7EC9EF2D,
+		0x11B4DB17, 0xAE1A2EE9, 0x84E961A4, 0x1627F703, 0x8C23EC6D, 0xF0A8A31C,
+		0x8E53A703, 0xB1131710, 0x5723CF12, 0x991DF0FF, 0xA30498B8, 0x02EF0D79,
+		0x2B3DD3EF, 0xD38C2931, 0xE5745386, 0xF41AE34F, 0x10499E3C, 0xF79569CE,
+		0x8ED71CA2, 0x98B0DC30, 0x9F6E5321, 0x42EB67BA, 0x2742BCEC, 0x8DF9EF50,
+		0xAAA09BA7, 0xF9695506, 0xA294E5EF, 0xDC12C945, 0x0F7A7CEA, 0x9E19DD96,
+		0xABD27434, 0xD26E3C3F, 0x13B45FF0, 0xCF8379E7, 0xF85FF493, 0x985079D6,
+		0xBDB81502, 0xA2C60C5C, 0x22B632AC, 0x3D3986EE, 0x45825465, 0xAEEB58F9,
+		0xF283D84B, 0x80517003, 0x942B1C72, 0xE3E70F85, 0x3F8E843D, 0x7454E06D,
+		0x31B2159B, 0x568A8365, 0x23DCC43E, 0x37871B58, 0x60C69863, 0xD1889242,
+		0x520946C2, 0x929B3286, 0xD95FED2C, 0x2A208340, 0x928DF232, 0xC028DF59,
+		0x0D35A23F, 0x00EDC91C, 0x3979AED9, 0xAA29C007, 0x84BA7B37, 0x7E3CA9CB,
+		0x54F00B03, 0x61691F7C, 0x5834387D, 0x770BB788, 0xB162F9C0, 0x43618701,
+		0x9E059974, 0x06E5F826, 0x0CF7163D, 0xBBE0FE4D, 0x7F106BA3, 0x71A5CDA3,
+		0x7044BD36, 0x54DB9C6D, 0xCEB6C2E7, 0x4DE29FAE, 0x136CB930, 0xEA408A55,
+		0x7ADB6970, 0xC89057DA, 0x70B27C55, 0xFD9DD49F, 0x71945289, 0x29F6F8CA,
+		0xDFD414FF, 0x3A073C7A, 0x610CB803, 0xF63DB2F3, 0xDAB51606, 0x1D98C2CB,
+		0x8EAED1E3, 0x2713BE03, 0xA7740897, 0x4184FD27, 0xF4FB8A06, 0x42B5EE24,
+		0x16CC60A1, 0x58C7FA50, 0x0D3A4CB4, 0x40C16EFA
+		],[
+		0xF0B6672A, 0x2FBFF845, 0xF8DAE2E1, 0x1E62ADD9, 0xE386B139, 0xCE326446,
+		0x1F85E0A2, 0x876AC684, 0xF89F69ED, 0xB9C1F96B, 0x0F350297, 0x5D5C5727,
+		0xE4D11EDE, 0xCB7964CC, 0xE1646E44, 0x413DB994, 0x50169691, 0x2A75843F,
+		0xE56CE654, 0x307C49E8, 0xABBF759E, 0x18E30B64, 0x1DBD8903, 0xED9C2D59,
+		0x2DDFF02B, 0x6EF2C41D, 0x3FF08CED, 0x5C4B7F31, 0xB26984CA, 0xB0B1EFEA,
+		0x9C11734E, 0x680B8B66, 0xDC671C46, 0x2F8DD9C2, 0xCACF3975, 0xC3F6D8DB,
+		0x38DDF820, 0x421E0652, 0x9FBE5AFA, 0xB4F43AE3, 0x957FC205, 0xFFA58375,
+		0x55286205, 0x7EE974B5, 0x31DECAF4, 0x3E7425ED, 0xACD2BC1B, 0xFBB39E17,
+		0xE99CE668, 0xC3DE689F, 0xE8BC3A39, 0xC327F086, 0xB3F2E894, 0x13CDC849,
+		0xA7D8DACF, 0x2987F368, 0x7FC52A15, 0x2C0DE867, 0xC39020AE, 0x6B9A5BEB,
+		0x1116EB0C, 0x56FAD5FD, 0xE13E5C39, 0x167F6C42, 0x1462F7F4, 0x5D1875F4,
+		0x82A56F78, 0x2DFB88E6, 0xD0191186, 0x0850D44A, 0xCEFA0FC4, 0x3FB97E0B,
+		0x3225B980, 0x3D33D41F, 0x595FA8D5, 0x3FB1945B, 0x94D5E9FA, 0xDDEF2BCB,
+		0x4C35A2D9, 0xCF328015, 0x7DEEB93C, 0xF76A0735, 0x6CBE97D8, 0xE1E32FD2,
+		0x72537C1C, 0x6946111C, 0x689A0958, 0x2A82EBAD, 0x5A70B4F6, 0xCA2C98CF,
+		0x500B4CB5, 0xE4F72532, 0x317ABF2E, 0x9B16512E, 0x612F8F0B, 0xBF323BE6,
+		0x7A9A4827, 0xE401B548, 0x4776626E, 0xCB602107, 0xEC189B17, 0x94A36CB9,
+		0x00C86686, 0xDA12464F, 0x0172E4EC, 0x9779E7E2, 0x45349B40, 0x7286BCE1,
+		0x1913C435, 0x8BF1E440, 0x16BB54D3, 0xE700E633, 0xF524785A, 0xB27F3F09,
+		0x25B6406D, 0xA19BF68C, 0x3B144DA2, 0x816B70C0, 0xFF86B5D6, 0x1E75EBB3,
+		0x57B4F242, 0x46771F2A, 0x53776C5F, 0x6257CECD, 0x27D7A26B, 0x74AD749F,
+		0x0E8DF172, 0xFA7C4A26, 0x8F978578, 0xF3265767, 0xA08160FB, 0x8A13431D,
+		0x22213265, 0x4A018EF2, 0x526BB8F8, 0x5FC7F38C, 0xFAB62CD2, 0x50EF8674,
+		0x3E4FC6E1, 0x08553D35, 0x2BCC6BD6, 0x06D22116, 0x25F16EE8, 0xB51D172B,
+		0x8E657082, 0xD102410A, 0x6B8DE05D, 0x22AEA76E, 0x0B692D8D, 0xC5E7C0F1,
+		0xB3499478, 0xAB3AE1FF, 0xC16DCFB5, 0xB5F67469, 0x31C015AE, 0x7807E2FF,
+		0x67E17C48, 0x56BB3693, 0xB11ABE01, 0x4AC2383A, 0x54D6BFDF, 0xBA1F540E,
+		0xF4CEFE7B, 0x7F9CD102, 0x82C1AB14, 0x4D32978E, 0xE3832FE2, 0x1E63A9AA,
+		0xCB1BB7CB, 0x478E6C6D, 0xD8C0CB68, 0xB907DA30, 0x05BC439C, 0x79872F07,
+		0x74040F93, 0x5EE6EABD, 0xC700C640, 0xE2740CF2, 0x7D9611A6, 0x28C34433,
+		0x9519AF00, 0xACAE30BA, 0xD1ED6770, 0x72557C82, 0x50D9BCCD, 0xBCDEE88E,
+		0x97E36EFF, 0xCC382EF8, 0x71B71FC2, 0x6EED0311, 0x17B065C2, 0x38BE59A6,
+		0x6D47222A, 0x9940BBDD, 0x342463F0, 0x98723D62, 0x59EC6C09, 0x13E077BB,
+		0x6CDD2887, 0x763D4A95, 0x51D7A260, 0x7615C8BF, 0x7BAA1B0D, 0x85E2F0B8,
+		0x29A14FB7, 0x90BC2A4F, 0x15A17CE1, 0x95BBC7DA, 0x98384B5B, 0x964E6B18,
+		0x1341FD22, 0x64BC571D, 0x856E353D, 0x92846808, 0xBDBC4F81, 0x11C5A93F,
+		0x9B00D8AB, 0xE9C7F68C, 0x002C42BE, 0x79B7F2E8, 0xCC450F36, 0x106D1921,
+		0x8306ECBF, 0xB3E092E3, 0xFB4A2813, 0xC46D7B9F, 0x7CF4F348, 0x1BEB4962,
+		0xFEC844F2, 0xD5FE7D0A, 0xF28A1872, 0xA0E433FE, 0x5EDB808D, 0x01591BE1,
+		0xDB4E08F3, 0x298A0DFB, 0xC638BB36, 0x59F96184, 0xA344CD21, 0x39BAFAD3,
+		0x83112A1C, 0x1892FC88, 0x856E9D5C, 0x13FD4F16, 0x81802AB7, 0x79FB698E,
+		0xAB8AF3E1, 0x986C72C1, 0xF1565939, 0x332EFF7D, 0xD0D7746C, 0xDCF7CA0E,
+		0x61E6931A, 0xF582D866, 0x2C3410D9, 0x21D70463]]

=== added file 'build/lib.linux-x86_64-2.7/pithos/pandora/xmlrpc.py'
--- build/lib.linux-x86_64-2.7/pithos/pandora/xmlrpc.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/pandora/xmlrpc.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,63 @@
+# -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
+### BEGIN LICENSE
+# Copyright (C) 2010 Kevin Mehall <[e-mail]>
+#This program is free software: you can redistribute it and/or modify it 
+#under the terms of the GNU General Public License version 3, as published 
+#by the Free Software Foundation.
+#
+#This program is distributed in the hope that it will be useful, but 
+#WITHOUT ANY WARRANTY; without even the implied warranties of 
+#MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+#PURPOSE.  See the GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License along 
+#with this program.  If not, see <http://www.gnu.org/licenses/>.
+### END LICENSE
+
+from cgi import escape
+
+def xmlrpc_value(v):
+    if isinstance(v, str):
+        return "<value><string>%s</string></value>"%escape(v)
+    elif v is True:
+        return "<value><boolean>1</boolean></value>"
+    elif v is False:
+        return "<value><boolean>0</boolean></value>"
+    elif isinstance(v, int) or isinstance(v, long):
+        return "<value><int>%i</int></value>"%v
+    elif isinstance(v, list):
+        return "<value><array><data>%s</data></array></value>"%("".join([xmlrpc_value(i) for i in v]))
+    else:
+        raise ValueError("Can't encode %s of type %s to XMLRPC"%(v, type(v)))
+        
+def xmlrpc_make_call(method, args):
+    args = "".join(["<param>%s</param>"%xmlrpc_value(i) for i in args])
+    return "<?xml version=\"1.0\"?><methodCall><methodName>%s</methodName><params>%s</params></methodCall>"%(method, args)
+
+def xmlrpc_parse_value(tree):
+    b = tree.findtext('boolean')
+    if b is not None:
+        return bool(int(b))
+    i = tree.findtext('int')
+    if i is not None:
+        return int(i)
+    a = tree.find('array')
+    if a is not None:
+        return xmlrpc_parse_array(a)
+    s = tree.find('struct')
+    if s is not None:
+        return xmlrpc_parse_struct(s)
+    return tree.text
+ 
+def xmlrpc_parse_struct(tree):
+    d = {}
+    for member in tree.findall('member'):
+        name = member.findtext('name')
+        d[name] = xmlrpc_parse_value(member.find('value'))
+    return d
+    
+def xmlrpc_parse_array(tree):
+    return [xmlrpc_parse_value(item) for item in tree.findall('data/value')]
+
+def xmlrpc_parse(tree):
+    return xmlrpc_parse_value(tree.find('params/param/value'))

=== added file 'build/lib.linux-x86_64-2.7/pithos/pithosconfig.py'
--- build/lib.linux-x86_64-2.7/pithos/pithosconfig.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/pithosconfig.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,66 @@
+# -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
+### BEGIN LICENSE
+# Copyright (C) 2010 Kevin Mehall <[e-mail]>
+#This program is free software: you can redistribute it and/or modify it 
+#under the terms of the GNU General Public License version 3, as published 
+#by the Free Software Foundation.
+#
+#This program is distributed in the hope that it will be useful, but 
+#WITHOUT ANY WARRANTY; without even the implied warranties of 
+#MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+#PURPOSE.  See the GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License along 
+#with this program.  If not, see <http://www.gnu.org/licenses/>.
+### END LICENSE
+
+# where your project will head for your data (for instance, images and ui files)
+# by default, this is ../data, relative your trunk layout
+__pithos_data_directory__ = '/usr/local/share/pithos/'
+__license__ = 'GPL-3'
+
+VERSION = '0.3.14'
+
+
+import os
+
+class project_path_not_found(Exception):
+    pass
+
+valid_audio_formats = [
+    'aacplus',
+    'mp3',
+    'mp3-hifi',
+]
+
+def get_data_file(*path_segments):
+    """Get the full path to a data file.
+
+    Returns the path to a file underneath the data directory (as defined by
+    `get_data_path`). Equivalent to os.path.join(get_data_path(),
+    *path_segments).
+    """
+    return os.path.join(getdatapath(), *path_segments)
+
+def getdatapath():
+    """Retrieve pithos data path
+
+    This path is by default <pithos_lib_path>/../data/ in trunk
+    and /usr/share/pithos in an installed version but this path
+    is specified at installation time.
+    """
+
+    # get pathname absolute or relative
+    if __pithos_data_directory__.startswith('/'):
+        pathname = __pithos_data_directory__
+    else:
+        pathname = os.path.dirname(__file__) + '/' + __pithos_data_directory__
+
+    abs_data_path = os.path.abspath(pathname)
+    if os.path.exists(abs_data_path):
+        return abs_data_path
+    else:
+        raise project_path_not_found
+
+if __name__=='__main__':
+    print VERSION

=== added file 'build/lib.linux-x86_64-2.7/pithos/plugin.py'
--- build/lib.linux-x86_64-2.7/pithos/plugin.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/plugin.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,98 @@
+#!/usr/bin/python
+# -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
+### BEGIN LICENSE
+# Copyright (C) 2010 Kevin Mehall <[e-mail]>
+#This program is free software: you can redistribute it and/or modify it 
+#under the terms of the GNU General Public License version 3, as published 
+#by the Free Software Foundation.
+#
+#This program is distributed in the hope that it will be useful, but 
+#WITHOUT ANY WARRANTY; without even the implied warranties of 
+#MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+#PURPOSE.  See the GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License along 
+#with this program.  If not, see <http://www.gnu.org/licenses/>.
+### END LICENSE
+
+import logging
+import glob
+import os
+
+class PithosPlugin(object):
+    _PITHOS_PLUGIN = True # used to find the plugin class in a module
+    preference = None
+    def __init__(self, name, window):
+        self.name = name
+        self.window = window
+        self.prepared = False
+        self.enabled = False
+        
+    def enable(self):
+        if not self.prepared:
+            self.error = self.on_prepare()
+            self.prepared = True
+        if not self.error and not self.enabled:
+            logging.info("Enabling module %s"%(self.name))
+            self.on_enable()
+            self.enabled = True
+            
+    def disable(self):
+        if self.enabled:
+            logging.info("Disabling module %s"%(self.name))
+            self.on_disable()
+            self.enabled = False
+        
+    def on_prepare(self):
+        pass
+        
+    def on_enable(self):
+        pass
+        
+    def on_disable(self):
+        pass
+
+class ErrorPlugin(PithosPlugin):
+    def __init__(self, name, error):
+        logging.error("Error loading plugin %s: %s"%(name, error))
+        self.prepared = True
+        self.error = error
+        self.name = name
+        self.enabled = False
+        
+def load_plugin(name, window):
+    try:
+        module = __import__('pithos.plugins.'+name)
+        module = getattr(module.plugins, name)
+        
+    except ImportError as e:
+        return ErrorPlugin(name, e.message)
+        
+    # find the class object for the actual plugin
+    for key, item in module.__dict__.iteritems():
+        if hasattr(item, '_PITHOS_PLUGIN') and key != "PithosPlugin":
+            plugin_class = item
+            break
+    else:
+        return ErrorPlugin(name, "Could not find module class")
+        
+    return plugin_class(name, window)
+
+def load_plugins(window):
+    plugins = window.plugins
+    prefs = window.preferences
+    
+    plugins_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "plugins")
+    discovered_plugins = [ fname.replace(".py", "") for fname in glob.glob1(plugins_dir, "*.py") if not fname.startswith("__") ]
+    
+    for name in discovered_plugins:
+        if not name in plugins:
+            plugin = plugins[name] = load_plugin(name, window)
+        else:
+            plugin = plugins[name]
+
+        if plugin.preference and prefs.get(plugin.preference, False):
+            plugin.enable()
+        else:
+            plugin.disable()
+        

=== added directory 'build/lib.linux-x86_64-2.7/pithos/plugins'
=== added file 'build/lib.linux-x86_64-2.7/pithos/plugins/__init__.py'
=== added file 'build/lib.linux-x86_64-2.7/pithos/plugins/mediakeys.py'
--- build/lib.linux-x86_64-2.7/pithos/plugins/mediakeys.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/plugins/mediakeys.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,68 @@
+# -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
+### BEGIN LICENSE
+# Copyright (C) 2010 Kevin Mehall <[e-mail]>
+#This program is free software: you can redistribute it and/or modify it 
+#under the terms of the GNU General Public License version 3, as published 
+#by the Free Software Foundation.
+#
+#This program is distributed in the hope that it will be useful, but 
+#WITHOUT ANY WARRANTY; without even the implied warranties of 
+#MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+#PURPOSE.  See the GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License along 
+#with this program.  If not, see <http://www.gnu.org/licenses/>.
+### END LICENSE
+
+from pithos.plugin import PithosPlugin
+import dbus
+import logging
+
+APP_ID = 'Pithos'
+
+class MediaKeyPlugin(PithosPlugin):
+    preference = 'enable_mediakeys'
+    
+    def bind_dbus(self):
+        try:
+            bus = dbus.Bus(dbus.Bus.TYPE_SESSION)
+            mk = bus.get_object("org.gnome.SettingsDaemon","/org/gnome/SettingsDaemon/MediaKeys")
+            mk.GrabMediaPlayerKeys(APP_ID, 0, dbus_interface='org.gnome.SettingsDaemon.MediaKeys')
+            mk.connect_to_signal("MediaPlayerKeyPressed", self.mediakey_pressed)
+            logging.info("Bound media keys with DBUS")
+            self.method = 'dbus'
+            return True
+        except dbus.DBusException:
+            return False
+            
+    def mediakey_pressed(self, app, action):
+       if app == APP_ID:
+            if action == 'Play':
+                self.window.playpause()
+            elif action == 'Next':
+                self.window.next_song()
+            elif action == 'Stop':
+                self.window.user_pause()
+            elif action == 'Previous':
+                self.window.bring_to_top()
+            
+    def bind_keybinder(self):
+        try:
+            import keybinder
+        except:
+            return False
+        
+        keybinder.bind('XF86AudioPlay', self.window.playpause, None)
+        keybinder.bind('XF86AudioStop', self.window.user_pause, None)
+        keybinder.bind('XF86AudioNext', self.window.next_song, None)
+        keybinder.bind('XF86AudioPrev', self.window.bring_to_top, None)
+        
+        logging.info("Bound media keys with keybinder")
+        self.method = 'keybinder'
+        return True
+        
+    def on_enable(self):
+        self.bind_dbus() or self.bind_keybinder() or logging.error("Could not bind media keys")     
+        
+    def on_disable(self):
+        logging.error("Not implemented: Can't disable media keys")

=== added file 'build/lib.linux-x86_64-2.7/pithos/plugins/notification_icon.py'
--- build/lib.linux-x86_64-2.7/pithos/plugins/notification_icon.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/plugins/notification_icon.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,144 @@
+#!/usr/bin/python
+# -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
+### BEGIN LICENSE
+# Copyright (C) 2010 Kevin Mehall <[e-mail]>
+#This program is free software: you can redistribute it and/or modify it 
+#under the terms of the GNU General Public License version 3, as published 
+#by the Free Software Foundation.
+#
+#This program is distributed in the hope that it will be useful, but 
+#WITHOUT ANY WARRANTY; without even the implied warranties of 
+#MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+#PURPOSE.  See the GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License along 
+#with this program.  If not, see <http://www.gnu.org/licenses/>.
+### END LICENSE
+
+import gtk
+from pithos.pithosconfig import get_data_file
+from pithos.plugin import PithosPlugin
+
+# Check if appindicator is available on the system
+try:
+    import appindicator
+    indicator_capable = True
+except:
+    indicator_capable = False
+
+class PithosNotificationIcon(PithosPlugin):    
+    preference = 'show_icon'
+            
+    def on_prepare(self):
+        if indicator_capable:
+            self.ind = appindicator.Indicator("pithos", \
+                                  "pithos-mono", \
+                                   appindicator.CATEGORY_APPLICATION_STATUS, \
+                                   get_data_file('media'))
+    
+    def on_enable(self):
+        self.visible = True
+        self.delete_callback_handle = self.window.connect("delete-event", self.toggle_visible)
+        self.state_callback_handle = self.window.connect("play-state-changed", self.play_state_changed)
+        self.song_callback_handle = self.window.connect("song-changed", self.song_changed)
+        
+        if indicator_capable:
+            self.ind.set_status(appindicator.STATUS_ACTIVE)      
+        else:
+            self.statusicon = gtk.status_icon_new_from_file(get_data_file('media', 'icon.png'))
+            self.statusicon.connect('activate', self.toggle_visible)
+        
+        self.build_context_menu()
+       
+    def build_context_menu(self):
+        menu = gtk.Menu()
+        
+        def button(text, action, icon=None):
+            if icon == 'check':
+                item = gtk.CheckMenuItem(text)
+                item.set_active(True)
+            elif icon:
+                item = gtk.ImageMenuItem(text)
+                item.set_image(gtk.image_new_from_stock(icon, gtk.ICON_SIZE_MENU))
+            else:
+                item = gtk.MenuItem(text)
+            item.connect('activate', action) 
+            item.show()
+            menu.append(item)
+            return item
+        
+        if indicator_capable:
+            # We have to add another entry for show / hide Pithos window
+            self.visible_check = button("Show Pithos", self._toggle_visible, 'check')
+            self.visible_check.set_active(not self.window.startPaused) #SMASHER816
+        
+        self.playpausebtn = button("Pause", self.window.playpause, gtk.STOCK_MEDIA_PAUSE)
+        button("Skip",  self.window.next_song,                     gtk.STOCK_MEDIA_NEXT)
+        button("Love",  (lambda *i: self.window.love_song()),      gtk.STOCK_ABOUT)
+        button("Ban",   (lambda *i: self.window.ban_song()),       gtk.STOCK_CANCEL)
+        button("Tired", (lambda *i: self.window.tired_song()),     gtk.STOCK_JUMP_TO)
+        button("Quit",  self.window.quit,                          gtk.STOCK_QUIT )
+
+        # connect our new menu to the statusicon or the appindicator
+        if indicator_capable:
+            self.ind.set_menu(menu)
+        else:
+            self.statusicon.connect('popup-menu', self.context_menu, menu)
+            
+        self.menu = menu
+
+
+    def play_state_changed(self, window, playing):
+        """ play or pause and rotate the text """
+        
+        button = self.playpausebtn
+        if not playing:
+            button.set_label("Play")
+            button.set_image(gtk.image_new_from_stock(gtk.STOCK_MEDIA_PLAY, gtk.ICON_SIZE_MENU))
+
+        else:
+            button.set_label("Pause")
+            button.set_image(gtk.image_new_from_stock(gtk.STOCK_MEDIA_PAUSE, gtk.ICON_SIZE_MENU))
+            
+        if indicator_capable: # menu needs to be reset to get updated icon
+            self.ind.set_menu(self.menu)
+
+    def song_changed(self, window, song):
+        if not indicator_capable:
+            self.statusicon.set_tooltip("%s by %s"%(song.title, song.artist))
+        
+    def _toggle_visible(self, *args):
+        if self.visible:
+            self.window.hide()
+        else:
+            self.window.bring_to_top()
+        
+        self.visible = not self.visible
+        
+    def toggle_visible(self, *args):
+        if hasattr(self, 'visible_check'):
+            self.visible_check.set_active(not self.visible)
+        else:
+            self._toggle_visible()
+        
+        return True
+
+    def context_menu(self, widget, button, time, data=None): 
+       if button == 3: 
+           if data: 
+               data.show_all() 
+               data.popup(None, None, None, 3, time)
+    
+    def on_disable(self):
+        if indicator_capable:
+            self.ind.set_status(appindicator.STATUS_PASSIVE)
+        else:
+            self.statusicon.set_visible(False)
+            
+        self.window.disconnect(self.delete_callback_handle)
+        self.window.disconnect(self.state_callback_handle)
+        self.window.disconnect(self.song_callback_handle)
+        
+        # Pithos window needs to be reconnected to on_destro()
+        self.window.connect('delete-event',self.window.on_destroy)
+

=== added file 'build/lib.linux-x86_64-2.7/pithos/plugins/notify.py'
--- build/lib.linux-x86_64-2.7/pithos/plugins/notify.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/plugins/notify.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,61 @@
+# -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
+### BEGIN LICENSE
+# Copyright (C) 2010 Kevin Mehall <[e-mail]>
+#This program is free software: you can redistribute it and/or modify it 
+#under the terms of the GNU General Public License version 3, as published 
+#by the Free Software Foundation.
+#
+#This program is distributed in the hope that it will be useful, but 
+#WITHOUT ANY WARRANTY; without even the implied warranties of 
+#MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+#PURPOSE.  See the GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License along 
+#with this program.  If not, see <http://www.gnu.org/licenses/>.
+### END LICENSE
+
+import pynotify, gtk
+from cgi import escape
+from pithos.plugin import PithosPlugin
+from pithos.pithosconfig import get_data_file
+
+class NotifyPlugin(PithosPlugin):
+    preference = 'notify'
+    
+    def on_prepare(self):
+        pynotify.init('pithos')
+        self.notification = pynotify.Notification("Pithos","Pithos")
+        
+    def on_enable(self):
+        self.song_callback_handle = self.window.connect("song-changed", self.song_changed)
+        self.state_changed_handle = self.window.connect("user-changed-play-state", self.playstate_changed)
+        
+    def set_for_song(self, song):
+        self.notification.clear_hints()
+        msg = escape("by %s from %s"%(song.artist, song.album))
+        self.notification.update(song.title, msg, 'audio-x-generic')
+        
+    def song_changed(self, window,  song):
+        if not self.window.is_active():
+            self.set_for_song(song)
+            if song.art_pixbuf:
+                #logging.debug("has albumart", song.art_pixbuf, song.art_pixbuf.get_width())
+                self.notification.set_icon_from_pixbuf(song.art_pixbuf)
+            else:
+                self.notification.props.icon_name = get_data_file('media/pithos-mono.png')
+            self.notification.show()
+            
+    def playstate_changed(self, window, state):
+        if not self.window.is_active():
+            self.set_for_song(window.current_song)
+            if state:
+                self.notification.props.icon_name = 'gtk-media-play-ltr'
+            else:
+                self.notification.props.icon_name = 'gtk-media-pause'
+            
+            self.notification.show()
+            
+        
+    def on_disable(self):
+        self.window.disconnect(self.song_callback_handle)
+        self.window.disconnect(self.state_changed_handle)

=== added file 'build/lib.linux-x86_64-2.7/pithos/plugins/screensaver_pause.py'
--- build/lib.linux-x86_64-2.7/pithos/plugins/screensaver_pause.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/plugins/screensaver_pause.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,62 @@
+# -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
+### BEGIN LICENSE
+# Copyright (C) 2010 Kevin Mehall <[e-mail]>
+#This program is free software: you can redistribute it and/or modify it 
+#under the terms of the GNU General Public License version 3, as published 
+#by the Free Software Foundation.
+#
+#This program is distributed in the hope that it will be useful, but 
+#WITHOUT ANY WARRANTY; without even the implied warranties of 
+#MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+#PURPOSE.  See the GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License along 
+#with this program.  If not, see <http://www.gnu.org/licenses/>.
+### END LICENSE
+
+from pithos.plugin import PithosPlugin
+import dbus
+import logging
+
+
+class ScreenSaverPausePlugin(PithosPlugin):
+    preference = 'enable_screensaverpause'
+    
+    def bind_session_bus(self):
+        try:
+            self.session_bus = dbus.SessionBus()
+            return True
+        except dbus.DBusException:
+            return False
+        
+    def on_enable(self):
+        self.bind_session_bus() or logging.error("Could not bind session bus")
+        self.connect_events() or logging.error("Could not connect events")
+
+    def on_disable(self):
+        self.disconnect_events()
+        self.session_bus = None
+
+    def connect_events(self):
+        try:
+            self.session_bus.add_signal_receiver(self.playPause, 'ActiveChanged', 'org.gnome.ScreenSaver')
+            return True
+        except dbus.DBusException:
+            logging.info("Enable failed")
+            return False
+
+    def disconnect_events(self):
+        try:
+            self.session_bus.remove_signal_receiver(self.playPause, 'ActiveChanged', 'org.gnome.ScreenSaver')
+            return True
+        except dbus.DBusException:
+            return False
+            
+    
+    def playPause(self,state):
+        if not state:
+            if self.wasplaying:
+                self.window.user_play()
+        else:
+            self.wasplaying = self.window.playing
+            self.window.pause()

=== added file 'build/lib.linux-x86_64-2.7/pithos/plugins/scrobble.py'
--- build/lib.linux-x86_64-2.7/pithos/plugins/scrobble.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/plugins/scrobble.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,141 @@
+#!/usr/bin/python
+# -*- coding: utf-8; tab-width: 4; indent-tabs-mode: nil; -*-
+### BEGIN LICENSE
+# Copyright (C) 2010 Kevin Mehall <[e-mail]>
+#This program is free software: you can redistribute it and/or modify it 
+#under the terms of the GNU General Public License version 3, as published 
+#by the Free Software Foundation.
+#
+#This program is distributed in the hope that it will be useful, but 
+#WITHOUT ANY WARRANTY; without even the implied warranties of 
+#MERCHANTABILITY, SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR 
+#PURPOSE.  See the GNU General Public License for more details.
+#
+#You should have received a copy of the GNU General Public License along 
+#with this program.  If not, see <http://www.gnu.org/licenses/>.
+### END LICENSE
+
+from pithos import pylast
+import webbrowser
+import logging
+from pithos.gobject_worker import GObjectWorker
+from pithos.plugin import PithosPlugin
+
+#getting an API account: http://www.last.fm/api/account
+API_KEY = '997f635176130d5d6fe3a7387de601a8'
+API_SECRET = '3243b876f6bf880b923a3c9fb955720c'
+
+#client id, client version info: http://www.last.fm/api/submissions#1.1
+CLIENT_ID = 'pth'
+CLIENT_VERSION = '1.0'
+
+_worker = None
+def get_worker():
+    # so it can be shared between the plugin and the authorizer
+    global _worker
+    if not _worker:
+        _worker = GObjectWorker()
+    return _worker
+
+class LastfmPlugin(PithosPlugin):
+    preference='lastfm_key'
+    
+    def on_prepare(self):
+        self.worker = get_worker()
+
+    def on_enable(self):
+        self.connect(self.window.preferences['lastfm_key'])
+        self.song_ended_handle = self.window.connect('song-ended', self.song_ended)
+        self.song_changed_handle = self.window.connect('song-changed', self.song_changed)
+        
+    def on_disable(self):
+        self.window.disconnect(self.song_ended_handle)
+        self.window.disconnect(self.song_rating_changed_handle)
+        self.window.disconnect(self.song_changed_handle)
+        
+    def song_ended(self, window, song):
+        self.scrobble(song)
+        
+    def connect(self, session_key):
+        self.network = pylast.get_lastfm_network(
+            api_key=API_KEY, api_secret=API_SECRET,
+            session_key = session_key
+        )
+        self.scrobbler = self.network.get_scrobbler(CLIENT_ID, CLIENT_VERSION)
+     
+    def song_changed(self, window, song):
+        self.worker.send(self.scrobbler.report_now_playing, (song.artist, song.title, song.album))
+        
+    def send_rating(self, song, rating):
+        if song.rating:
+            track = self.network.get_track(song.artist, song.title)
+            if rating == 'love':
+                self.worker.send(track.love)
+            elif rating == 'ban':
+                self.worker.send(track.ban)
+            logging.info("Sending song rating to last.fm")
+
+    def scrobble(self, song):
+        if song.duration > 30 and (song.position > 240 or song.position > song.duration/2):
+            logging.info("Scrobbling song")
+            mode = pylast.SCROBBLE_MODE_PLAYED
+            source = pylast.SCROBBLE_SOURCE_PERSONALIZED_BROADCAST
+            self.worker.send(self.scrobbler.scrobble, (song.artist, song.title, int(song.start_time), source, mode, song.duration, song.album))            
+
+
+class LastFmAuth:
+    def __init__(self, d,  prefname, button):
+        self.button = button
+        self.dict = d
+        self.prefname = prefname
+        
+        self.auth_url= False
+        self.set_button_text()
+        self.button.connect('clicked', self.clicked)
+    
+    @property
+    def enabled(self):
+        return self.dict[self.prefname]
+    
+    def setkey(self, key):
+        self.dict[self.prefname] = key
+        self.set_button_text()
+        
+    def set_button_text(self):
+        self.button.set_sensitive(True)
+        if self.auth_url:
+            self.button.set_label("Click once authorized on web site")
+        elif self.enabled:
+            self.button.set_label("Disable")
+        else:
+            self.button.set_label("Authorize")
+            
+    def clicked(self, *ignore):
+        if self.auth_url:
+            def err(e):
+                logging.error(e)
+                self.set_button_text()
+
+            get_worker().send(self.sg.get_web_auth_session_key, (self.auth_url,), self.setkey, err) 
+            self.button.set_label("Checking...")
+            self.button.set_sensitive(False)
+            self.auth_url = False
+                
+        elif self.enabled:
+            self.setkey(False)
+        else:
+            self.network = pylast.get_lastfm_network(api_key=API_KEY, api_secret=API_SECRET)
+            self.sg = pylast.SessionKeyGenerator(self.network)
+            
+            def callback(url):
+                self.auth_url = url
+                self.set_button_text()
+                webbrowser.open(self.auth_url)
+            
+            get_worker().send(self.sg.get_web_auth_url, (), callback)
+            self.button.set_label("Connecting...")
+            self.button.set_sensitive(False)
+            
+            
+            
+        

=== added file 'build/lib.linux-x86_64-2.7/pithos/pylast.py'
--- build/lib.linux-x86_64-2.7/pithos/pylast.py	1970-01-01 00:00:00 +0000
+++ build/lib.linux-x86_64-2.7/pithos/pylast.py	2012-03-11 20:43:36 +0000
@@ -0,0 +1,3702 @@
+# -*- coding: utf-8 -*-
+#
+# pylast - A Python interface to Last.fm (and other API compatible social networks)
+# Copyright (C) 2008-2009  Amr Hassan
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+# USA
+#
+# http://code.google.com/p/pylast/
+    
+__version__ = '0.4'
+__author__ = 'Amr Hassan'
+__copyright__ = "Copyright (C) 2008-2009  Amr Hassan"
+__license__ = "gpl"
+__email__ = '[e-mail]'
+
+import hashlib
+import httplib
+import urllib
+import threading
+from xml.dom import minidom
+import xml.dom
+import time
+import shelve
+import tempfile
+import sys
+import htmlentitydefs
+
+try:
+    import collections
+except ImportError:
+    pass
+
+STATUS_INVALID_SERVICE = 2
+STATUS_INVALID_METHOD = 3
+STATUS_AUTH_FAILED = 4
+STATUS_INVALID_FORMAT = 5
+STATUS_INVALID_PARAMS = 6
+STATUS_INVALID_RESOURCE = 7
+STATUS_TOKEN_ERROR = 8
+STATUS_INVALID_SK = 9
+STATUS_INVALID_API_KEY = 10
+STATUS_OFFLINE = 11
+STATUS_SUBSCRIBERS_ONLY = 12
+STATUS_INVALID_SIGNATURE = 13
+STATUS_TOKEN_UNAUTHORIZED = 14
+STATUS_TOKEN_EXPIRED = 15
+
+EVENT_ATTENDING = '0'
+EVENT_MAYBE_ATTENDING = '1'
+EVENT_NOT_ATTENDING = '2'
+
+PERIOD_OVERALL = 'overall'
+PERIOD_7DAYS = "7day"
+PERIOD_3MONTHS = '3month'
+PERIOD_6MONTHS = '6month'
+PERIOD_12MONTHS = '12month'
+
+DOMAIN_ENGLISH = 0
+DOMAIN_GERMAN = 1
+DOMAIN_SPANISH = 2
+DOMAIN_FRENCH = 3
+DOMAIN_ITALIAN = 4
+DOMAIN_POLISH = 5
+DOMAIN_PORTUGUESE = 6
+DOMAIN_SWEDISH = 7
+DOMAIN_TURKISH = 8
+DOMAIN_RUSSIAN = 9
+DOMAIN_JAPANESE = 10
+DOMAIN_CHINESE = 11
+
+COVER_SMALL = 0
+COVER_MEDIUM = 1
+COVER_LARGE = 2
+COVER_EXTRA_LARGE = 3
+COVER_MEGA = 4
+
+IMAGES_ORDER_POPULARITY = "popularity"
+IMAGES_ORDER_DATE = "dateadded"
+
+
+USER_MALE = 'Male'
+USER_FEMALE = 'Female'
+
+SCROBBLE_SOURCE_USER = "P"
+SCROBBLE_SOURCE_NON_PERSONALIZED_BROADCAST = "R"
+SCROBBLE_SOURCE_PERSONALIZED_BROADCAST = "E"
+SCROBBLE_SOURCE_LASTFM = "L"
+SCROBBLE_SOURCE_UNKNOWN = "U"
+
+SCROBBLE_MODE_PLAYED = ""
+SCROBBLE_MODE_LOVED = "L"
+SCROBBLE_MODE_BANNED = "B"
+SCROBBLE_MODE_SKIPPED = "S"
+
+"""
+A list of the implemented webservices (from http://www.last.fm/api/intro)
+=====================================
+# Album
+
+    * album.addTags            DONE
+    * album.getInfo            DONE
+    * album.getTags            DONE
+    * album.removeTag        DONE
+    * album.search             DONE
+
+# Artist
+
+    * artist.addTags         DONE
+    * artist.getEvents         DONE
+    * artist.getImages         DONE
+    * artist.getInfo         DONE
+    * artist.getPodcast     TODO
+    * artist.getShouts         DONE
+    * artist.getSimilar     DONE
+    * artist.getTags         DONE
+    * artist.getTopAlbums     DONE
+    * artist.getTopFans     DONE
+    * artist.getTopTags     DONE
+    * artist.getTopTracks     DONE
+    * artist.removeTag         DONE
+    * artist.search         DONE
+    * artist.share             DONE
+    * artist.shout             DONE
+
+# Auth
+
+    * auth.getMobileSession DONE
+    * auth.getSession         DONE
+    * auth.getToken         DONE
+
+# Event
+
+    * event.attend             DONE
+    * event.getAttendees     DONE
+    * event.getInfo            DONE
+    * event.getShouts         DONE
+    * event.share             DONE
+    * event.shout             DONE
+
+# Geo
+
+    * geo.getEvents
+    * geo.getTopArtists
+    * geo.getTopTracks
+
+# Group
+
+    * group.getMembers                DONE
+    * group.getWeeklyAlbumChart        DONE
+    * group.getWeeklyArtistChart    DONE
+    * group.getWeeklyChartList        DONE
+    * group.getWeeklyTrackChart        DONE
+
+# Library
+
+    * library.addAlbum        DONE
+    * library.addArtist        DONE
+    * library.addTrack        DONE
+    * library.getAlbums        DONE
+    * library.getArtists    DONE
+    * library.getTracks        DONE
+
+# Playlist
+
+    * playlist.addTrack    DONE
+    * playlist.create    DONE
+    * playlist.fetch    DONE
+
+# Radio
+
+    * radio.getPlaylist
+    * radio.tune
+
+# Tag
+
+    * tag.getSimilar    DONE
+    * tag.getTopAlbums    DONE
+    * tag.getTopArtists    DONE
+    * tag.getTopTags    DONE
+    * tag.getTopTracks    DONE
+    * tag.getWeeklyArtistChart    DONE
+    * tag.getWeeklyChartList    DONE
+    * tag.search    DONE
+
+# Tasteometer
+
+    * tasteometer.compare    DONE
+
+# Track
+
+    * track.addTags    DONE
+    * track.ban    DONE
+    * track.getInfo    DONE
+    * track.getSimilar    DONE
+    * track.getTags    DONE
+    * track.getTopFans    DONE
+    * track.getTopTags    DONE
+    * track.love    DONE
+    * track.removeTag    DONE
+    * track.search    DONE
+    * track.share    DONE
+
+# User
+
+    * user.getEvents    DONE
+    * user.getFriends    DONE
+    * user.getInfo    DONE
+    * user.getLovedTracks    DONE
+    * user.getNeighbours    DONE
+    * user.getPastEvents    DONE
+    * user.getPlaylists    DONE
+    * user.getRecentStations    TODO
+    * user.getRecentTracks    DONE
+    * user.getRecommendedArtists    DONE
+    * user.getRecommendedEvents    DONE
+    * user.getShouts    DONE
+    * user.getTopAlbums    DONE
+    * user.getTopArtists    DONE
+    * user.getTopTags    DONE
+    * user.getTopTracks    DONE
+    * user.getWeeklyAlbumChart    DONE
+    * user.getWeeklyArtistChart    DONE
+    * user.getWeeklyChartList    DONE
+    * user.getWeeklyTrackChart    DONE
+    * user.shout    DONE
+
+# Venue
+
+    * venue.getEvents    DONE
+    * venue.getPastEvents    DONE
+    * venue.search    DONE
+"""
+
+class Network(object):
+    """
+        A music social network website that is Last.fm or one exposing a Last.fm compatible API
+    """
+    
+    def __init__(self, name, homepage, ws_server, api_key, api_secret, session_key, submission_server, username, password_hash,
+                    domain_names, urls):
+        """
+            name: the name of the network
+            homepage: the homepage url
+            ws_server: the url of the webservices server
+            api_key: a provided API_KEY
+            api_secret: a provided API_SECRET
+            session_key: a generated session_key or None
+            submission_server: the url of the server to which tracks are submitted (scrobbled)
+            username: a username of a valid user
+            password_hash: the output of pylast.md5(password) where password is the user's password thingy
+            domain_names: a dict mapping each DOMAIN_* value to a string domain name
+            urls: a dict mapping types to urls
+            
+            if username and password_hash were provided and not session_key, session_key will be
+            generated automatically when needed.
+            
+            Either a valid session_key or a combination of username and password_hash must be present for scrobbling.
+            
+            You should use a preconfigured network object through a get_*_network(...) method instead of creating an object
+            of this class, unless you know what you're doing.
+        """
+            
+        self.ws_server = ws_server
+        self.submission_server = submission_server
+        self.name = name
+        self.homepage = homepage
+        self.api_key = api_key
+        self.api_secret = api_secret
+        self.session_key = session_key
+        self.username = username
+        self.password_hash = password_hash
+        self.domain_names = domain_names
+        self.urls = urls
+        
+        self.cache_backend = None
+        self.proxy_enabled = False
+        self.proxy = None
+        self.last_call_time = 0
+        
+        #generate a session_key if necessary
+        if (self.api_key and self.api_secret) and not self.session_key and (self.username and self.password_hash):
+            sk_gen = SessionKeyGenerator(self)
+            self.session_key = sk_gen.get_session_key(self.username, self.password_hash)
+    
+    def get_artist(self, artist_name):
+        """
+            Return an Artist object
+        """
+        
+        return Artist(artist_name, self)
+    
+    def get_track(self, artist, title):
+        """
+            Return a Track object
+        """
+        
+        return Track(artist, title, self)
+    
+    def get_album(self, artist, title):
+        """
+            Return an Album object
+        """
+        
+        return Album(artist, title, self)
+    
+    def get_authenticated_user(self):
+        """
+            Returns the authenticated user
+        """
+        
+        return AuthenticatedUser(self)
+    
+    def get_country(self, country_name):
+        """
+            Returns a country object
+        """
+        
+        return Country(country_name, self)
+    
+    def get_group(self, name):
+        """
+            Returns a Group object
+        """
+        
+        return Group(name, self)
+    
+    def get_user(self, username):
+        """
+            Returns a user object
+        """
+        
+        return User(username, self)
+    
+    def get_tag(self, name):
+        """
+            Returns a tag object
+        """
+        
+        return Tag(name, self)
+    
+    def get_scrobbler(self, client_id, client_version):
+        """
+            Returns a Scrobbler object used for submitting tracks to the server
+            
+            Quote from http://www.last.fm/api/submissions:
+            ========
+            Client identifiers are used to provide a centrally managed database of 
+            the client versions, allowing clients to be banned if they are found to 
+            be behaving undesirably. The client ID is associated with a version 
+            number on the server, however these are only incremented if a client is 
+            banned and do not have to reflect the version of the actual client application.
+
+            During development, clients which have not been allocated an identifier should 
+            use the identifier tst, with a version number of 1.0. Do not distribute code or
+            client implementations which use this test identifier. Do not use the identifiers
+            used by other clients.
+            =========
+            
+            To obtain a new client identifier please contact:
+                * Last.fm: [e-mail]
+                * # TODO: list others
+            
+            ...and provide us with the name of your client and its homepage address. 
+        """
+        
+        return Scrobbler(self, client_id, client_version)
+    
+    def _get_language_domain(self, domain_language):
+        """
+            Returns the mapped domain name of the network to a DOMAIN_* value
+        """
+        
+        if domain_language in self.domain_names:
+            return self.domain_names[domain_language]
+    
+    def _get_url(self, domain, type):
+        return "http://%s/%s" %(self._get_language_domain(domain), self.urls[type])
+    
+    def _get_ws_auth(self):
+        """
+            Returns a (API_KEY, API_SECRET, SESSION_KEY) tuple.
+        """
+        return (self.api_key, self.api_secret, self.session_key)
+
+    def _delay_call(self):
+        """
+            Makes sure that web service calls are at least a second apart
+        """
+        
+        # delay time in seconds
+        DELAY_TIME = 1.0
+        now = time.time()
+            
+        if (now - self.last_call_time) < DELAY_TIME:
+            time.sleep(1)
+        
+        self.last_call_time = now
+        
+    def create_new_playlist(self, title, description):
+        """
+            Creates a playlist for the authenticated user and returns it
+                title: The title of the new playlist.
+                description: The description of the new playlist.
+        """
+        
+        params = {}
+        params['title'] = _unicode(title)
+        params['description'] = _unicode(description)
+        
+        doc = _Request(self, 'playlist.create', params).execute(False)
+        
+        e_id = doc.getElementsByTagName("id")[0].firstChild.data
+        user = doc.getElementsByTagName('playlists')[0].getAttribute('user')
+        
+        return Playlist(user, e_id, self)
+
+    def get_top_tags(self, limit=None):
+        """Returns a sequence of the most used tags as a sequence of TopItem objects."""
+        
+        doc = _Request(self, "tag.getTopTags").execute(True)
+        seq = []
+        for node in doc.getElementsByTagName("tag"):
+            tag = Tag(_extract(node, "name"), self)
+            weight = _number(_extract(node, "count"))
+            
+            if len(seq) < limit:
+                seq.append(TopItem(tag, weight))
+        
+        return seq
+
+    def enable_proxy(self, host, port):
+        """Enable a default web proxy"""
+        
+        self.proxy = [host, _number(port)]
+        self.proxy_enabled = True
+
+    def disable_proxy(self):
+        """Disable using the web proxy"""
+        
+        self.proxy_enabled = False
+
+    def is_proxy_enabled(self):
+        """Returns True if a web proxy is enabled."""
+        
+        return self.proxy_enabled
+
+    def _get_proxy(self):
+        """Returns proxy details."""
+        
+        return self.proxy
+        
+    def enable_caching(self, file_path = None):
+        """Enables caching request-wide for all cachable calls.
+        In choosing the backend used for caching, it will try _SqliteCacheBackend first if
+        the module sqlite3 is present. If not, it will fallback to _ShelfCacheBackend which uses shelve.Shelf objects.
+        
+        * file_path: A file path for the backend storage file. If 
+        None set, a temp file would probably be created, according the backend.
+        """
+        
+        if not file_path:
+            file_path = tempfile.mktemp(prefix="pylast_tmp_")
+        
+        self.cache_backend = _ShelfCacheBackend(file_path)
+            
+    def disable_caching(self):
+        """Disables all caching features."""
+
+        self.cache_backend = None
+
+    def is_caching_enabled(self):
+        """Returns True if caching is enabled."""
+        
+        return not (self.cache_backend == None)
+
+    def _get_cache_backend(self):
+        
+        return self.cache_backend
+        
+    def search_for_album(self, album_name):
+        """Searches for an album by its name. Returns a AlbumSearch object.
+        Use get_next_page() to retreive sequences of results."""
+        
+        return AlbumSearch(album_name, self)
+
+    def search_for_artist(self, artist_name):
+        """Searches of an artist by its name. Returns a ArtistSearch object.
+        Use get_next_page() to retreive sequences of results."""
+        
+        return ArtistSearch(artist_name, self)
+
+    def search_for_tag(self, tag_name):
+        """Searches of a tag by its name. Returns a TagSearch object.
+        Use get_next_page() to retreive sequences of results."""
+        
+        return TagSearch(tag_name, self)
+
+    def search_for_track(self, artist_name, track_name):
+        """Searches of a track by its name and its artist. Set artist to an empty string if not available.
+        Returns a TrackSearch object.
+        Use get_next_page() to retreive sequences of results."""
+        
+        return TrackSearch(artist_name, track_name, self)
+
+    def search_for_venue(self, venue_name, country_name):
+        """Searches of a venue by its name and its country. Set country_name to an empty string if not available.
+        Returns a VenueSearch object.
+        Use get_next_page() to retreive sequences of results."""
+
+        return VenueSearch(venue_name, country_name, self)
+        
+    def get_track_by_mbid(self, mbid):
+        """Looks up a track by its MusicBrainz ID"""
+        
+        params = {"mbid": _unicode(mbid)}
+        
+        doc = _Request(self, "track.getInfo", params).execute(True)
+        
+        return Track(_extract(doc, "name", 1), _extract(doc, "name"), self)
+
+    def get_artist_by_mbid(self, mbid):
+        """Loooks up an artist by its MusicBrainz ID"""
+        
+        params = {"mbid": _unicode(mbid)}
+        
+        doc = _Request(self, "artist.getInfo", params).execute(True)
+        
+        return Artist(_extract(doc, "name"), self)
+
+    def get_album_by_mbid(self, mbid):
+        """Looks up an album by its MusicBrainz ID"""
+        
+        params = {"mbid": _unicode(mbid)}
+        
+        doc = _Request(self, "album.getInfo", params).execute(True)
+        
+        return Album(_extract(doc, "artist"), _extract(doc, "name"), self)
+
+def get_lastfm_network(api_key="", api_secret="", session_key = "", username = "", password_hash = ""):
+    """
+    Returns a preconfigured Network object for Last.fm
+    
+    api_key: a provided API_KEY
+    api_secret: a provided API_SECRET
+    session_key: a generated session_key or None
+    username: a username of a valid user
+    password_hash: the output of pylast.md5(password) where password is the user's password
+    
+    if username and password_hash were provided and not session_key, session_key will be
+    generated automatically when needed.
+            
+    Either a valid session_key or a combination of username and password_hash must be present for scrobbling.
+    
+    Most read-only webservices only require an api_key and an api_secret, see about obtaining them from:
+    http://www.last.fm/api/account
+    """
+    
+    return Network (
+                    name = "Last.fm",
+                    homepage = "http://last.fm",
+                    ws_server = ("ws.audioscrobbler.com", "/2.0/"),
+                    api_key = api_key,
+                    api_secret = api_secret,
+                    session_key = session_key,
+                    submission_server = "http://post.audioscrobbler.com:80/",
+                    username = username,
+                    password_hash = password_hash,
+                    domain_names = {
+                        DOMAIN_ENGLISH: 'www.last.fm',
+                        DOMAIN_GERMAN: 'www.lastfm.de',
+                        DOMAIN_SPANISH: 'www.lastfm.es',
+                        DOMAIN_FRENCH: 'www.lastfm.fr',
+                        DOMAIN_ITALIAN: 'www.lastfm.it',
+                        DOMAIN_POLISH: 'www.lastfm.pl',
+                        DOMAIN_PORTUGUESE: 'www.lastfm.com.br',
+                        DOMAIN_SWEDISH: 'www.lastfm.se',
+                        DOMAIN_TURKISH: 'www.lastfm.com.tr',
+                        DOMAIN_RUSSIAN: 'www.lastfm.ru',
+                        DOMAIN_JAPANESE: 'www.lastfm.jp',
+                        DOMAIN_CHINESE: 'cn.last.fm',
+                        },
+                    urls = {
+                        "album": "music/%(artist)s/%(album)s",
+                        "artist": "music/%(artist)s",
+                        "event": "event/%(id)s",
+                        "country": "place/%(country_name)s",
+                        "playlist": "user/%(user)s/library/playlists/%(appendix)s",
+                        "tag": "tag/%(name)s",
+                        "track": "music/%(artist)s/_/%(title)s",
+                        "group": "group/%(name)s",
+                        "user": "user/%(name)s",
+                        }
+                    )
+
+def get_librefm_network(api_key="", api_secret="", session_key = "", username = "", password_hash = ""):
+    """
+    Returns a preconfigured Network object for Libre.fm
+    
+    api_key: a provided API_KEY
+    api_secret: a provided API_SECRET
+    session_key: a generated session_key or None
+    username: a username of a valid user
+    password_hash: the output of pylast.md5(password) where password is the user's password
+    
+    if username and password_hash were provided and not session_key, session_key will be
+    generated automatically when needed.
+    """
+    
+    return Network (
+                    name = "Libre.fm",
+                    homepage = "http://alpha.dev.libre.fm",
+                    ws_server = ("alpha.dev.libre.fm", "/2.0/"),
+                    api_key = api_key,
+                    api_secret = api_secret,
+                    session_key = session_key,
+                    submission_server = "http://turtle.libre.fm:80/",
+                    username = username,
+                    password_hash = password_hash,
+                    domain_names = {
+                        DOMAIN_ENGLISH: "alpha.dev.libre.fm",
+                        DOMAIN_GERMAN: "alpha.dev.libre.fm",
+                        DOMAIN_SPANISH: "alpha.dev.libre.fm",
+                        DOMAIN_FRENCH: "alpha.dev.libre.fm",
+                        DOMAIN_ITALIAN: "alpha.dev.libre.fm",
+                        DOMAIN_POLISH: "alpha.dev.libre.fm",
+                        DOMAIN_PORTUGUESE: "alpha.dev.libre.fm",
+                        DOMAIN_SWEDISH: "alpha.dev.libre.fm",
+                        DOMAIN_TURKISH: "alpha.dev.libre.fm",
+                        DOMAIN_RUSSIAN: "alpha.dev.libre.fm",
+                        DOMAIN_JAPANESE: "alpha.dev.libre.fm",
+                        DOMAIN_CHINESE: "alpha.dev.libre.fm",
+                        },
+                    urls = {
+                        "album": "artist/%(artist)s/album/%(album)s",
+                        "artist": "artist/%(artist)s",
+                        "event": "event/%(id)s",
+                        "country": "place/%(country_name)s",
+                        "playlist": "user/%(user)s/library/playlists/%(appendix)s",
+                        "tag": "tag/%(name)s",
+                        "track": "music/%(artist)s/_/%(title)s",
+                        "group": "group/%(name)s",
+                        "user": "user/%(name)s",
+                        }
+                    )
+
+class _ShelfCacheBackend(object):
+    """Used as a backend for caching cacheable requests."""
+    def __init__(self, file_path = None):
+        self.shelf = shelve.open(file_path)
+    
+    def get_xml(self, key):
+        return self.shelf[key]
+    
+    def set_xml(self, key, xml_string):
+        self.shelf[key] = xml_string
+    
+    def has_key(self, key):
+        return key in self.shelf.keys()
+        
+class _ThreadedCall(threading.Thread):
+    """Facilitates calling a function on another thread."""
+    
+    def __init__(self, sender, funct, funct_args, callback, callback_args):
+        
+        threading.Thread.__init__(self)
+        
+        self.funct = funct
+        self.funct_args = funct_args
+        self.callback = callback
+        self.callback_args = callback_args
+        
+        self.sender = sender
+    
+    def run(self):
+        
+        output = []
+        
+        if self.funct:
+            if self.funct_args:
+                output = self.funct(*self.funct_args)
+            else:
+                output = self.funct()
+                
+        if self.callback:
+            if self.callback_args:
+                self.callback(self.sender, output, *self.callback_args)
+            else:
+                self.callback(self.sender, output)
+    
+class _Request(object):
+    """Representing an abstract web service operation."""
+    
+    def __init__(self, network, method_name, params = {}):
+        
+        self.params = params
+        self.network = network
+        
+        (self.api_key, self.api_secret, self.session_key) = network._get_ws_auth()
+        
+        self.params["api_key"] = self.api_key
+        self.params["method"] = method_name
+        
+        if network.is_caching_enabled():
+            self.cache = network._get_cache_backend()
+        
+        if self.session_key:
+            self.params["sk"] = self.session_key
+            self.sign_it()
+    
+    def sign_it(self):
+        """Sign this request."""
+        
+        if not "api_sig" in self.params.keys():
+            self.params['api_sig'] = self._get_signature()
+    
+    def _get_signature(self):
+        """Returns a 32-character hexadecimal md5 hash of the signature string."""
+        
+        keys = self.params.keys()[:]
+        
+        keys.sort()
+        
+        string = ""
+        
+        for name in keys:
+            string += name
+            string += self.params[name]
+        
+        string += self.api_secret
+        
+        return md5(string)
+    
+    def _get_cache_key(self):
+        """The cache key is a string of concatenated sorted names and values."""
+        
+        keys = self.params.keys()
+        keys.sort()
+        
+        cache_key = str()
+        
+        for key in keys:
+            if key != "api_sig" and key != "api_key" and key != "sk":
+                cache_key += key + _string(self.params[key])
+        
+        return hashlib.sha1(cache_key).hexdigest()
+    
+    def _get_cached_response(self):
+        """Returns a file object of the cached response."""
+        
+        if not self._is_cached():
+            response = self._download_response()
+            self.cache.set_xml(self._get_cache_key(), response)
+        
+        return self.cache.get_xml(self._get_cache_key())
+    
+    def _is_cached(self):
+        """Returns True if the request is already in cache."""
+        
+        return self.cache.has_key(self._get_cache_key())
+        
+    def _download_response(self):
+        """Returns a response body string from the server."""
+        
+        # Delay the call if necessary
+        #self.network._delay_call()    # enable it if you want.
+        
+        data = []
+        for name in self.params.keys():
+            data.append('='.join((name, urllib.quote_plus(_string(self.params[name])))))
+        data = '&'.join(data)
+        
+        headers = {
+            "Content-type": "application/x-www-form-urlencoded",
+            'Accept-Charset': 'utf-8',
+            'User-Agent': "pylast" + '/' + __version__
+            }        
+        
+        (HOST_NAME, HOST_SUBDIR) = self.network.ws_server
+        
+        if self.network.is_proxy_enabled():
+            conn = httplib.HTTPConnection(host = self._get_proxy()[0], port = self._get_proxy()[1])
+            conn.request(method='POST', url="http://" + HOST_NAME + HOST_SUBDIR, 
+                body=data, headers=headers)
+        else:
+            conn = httplib.HTTPConnection(host=HOST_NAME)
+            conn.request(method='POST', url=HOST_SUBDIR, body=data, headers=headers)
+        
+        response = conn.getresponse()
+        response_text = _unicode(response.read())
+        self._check_response_for_errors(response_text)
+        return response_text
+        
+    def execute(self, cacheable = False):
+        """Returns the XML DOM response of the POST Request from the server"""
+        
+        if self.network.is_caching_enabled() and cacheable:
+            response = self._get_cached_response()
+        else:
+            response = self._download_response()
+        
+        return minidom.parseString(_string(response))
+    
+    def _check_response_for_errors(self, response):
+        """Checks the response for errors and raises one if any exists."""
+        
+        doc = minidom.parseString(_string(response))
+        e = doc.getElementsByTagName('lfm')[0]
+        
+        if e.getAttribute('status') != "ok":
+            e = doc.getElementsByTagName('error')[0]
+            status = e.getAttribute('code')
+            details = e.firstChild.data.strip()
+            raise WSError(self.network, status, details)
+
+class SessionKeyGenerator(object):
+    """Methods of generating a session key:
+    1) Web Authentication:
+        a. network = get_*_network(API_KEY, API_SECRET)
+        b. sg = SessionKeyGenerator(network)
+        c. url = sg.get_web_auth_url()
+        d. Ask the user to open the url and authorize you, and wait for it.
+        e. session_key = sg.get_web_auth_session_key(url)
+    2) Username and Password Authentication:
+        a. network = get_*_network(API_KEY, API_SECRET)
+        b. username = raw_input("Please enter your username: ")
+        c. password_hash = pylast.md5(raw_input("Please enter your password: ")
+        d. session_key = SessionKeyGenerator(network).get_session_key(username, password_hash)
+    
+    A session key's lifetime is infinie, unless the user provokes the rights of the given API Key.
+    
+    If you create a Network object with just a API_KEY and API_SECRET and a username and a password_hash, a
+    SESSION_KEY will be automatically generated for that network and stored in it so you don't have to do this
+    manually, unless you want to.
+    """
+    
+    def __init__(self, network):        
+        self.network = network
+        self.web_auth_tokens = {}
+    
+    def _get_web_auth_token(self):
+        """Retrieves a token from the network for web authentication.
+        The token then has to be authorized from getAuthURL before creating session.
+        """
+        
+        request = _Request(self.network, 'auth.getToken')
+        
+        # default action is that a request is signed only when
+        # a session key is provided.
+        request.sign_it()
+        
+        doc = request.execute()
+        
+        e = doc.getElementsByTagName('token')[0]
+        return e.firstChild.data
+    
+    def get_web_auth_url(self):
+        """The user must open this page, and you first, then call get_web_auth_session_key(url) after that."""
+        
+        token = self._get_web_auth_token()
+        
+        url = '%(homepage)s/api/auth/?api_key=%(api)s&token=%(token)s' % \
+            {"homepage": self.network.homepage, "api": self.network.api_key, "token": token}
+        
+        self.web_auth_tokens[url] = token
+        
+        return url
+
+    def get_web_auth_session_key(self, url):
+        """Retrieves the session key of a web authorization process by its url."""
+        
+        if url in self.web_auth_tokens.keys():
+            token = self.web_auth_tokens[url]
+        else:
+            token = ""    #that's gonna raise a WSError of an unauthorized token when the request is executed.
+        
+        request = _Request(self.network, 'auth.getSession', {'token': token})
+        
+        # default action is that a request is signed only when
+        # a session key is provided.
+        request.sign_it()
+        
+        doc = request.execute()
+        
+        return doc.getElementsByTagName('key')[0].firstChild.data
+    
+    def get_session_key(self, username, password_hash):
+        """Retrieve a session key with a username and a md5 hash of the user's password."""
+        
+        params = {"username": username, "authToken": md5(username + password_hash)}
+        request = _Request(self.network, "auth.getMobileSession", params)
+        
+        # default action is that a request is signed only when
+        # a session key is provided.
+        request.sign_it()
+        
+        doc = request.execute()
+        
+        return _extract(doc, "key")
+
+def _namedtuple(name, children):
+    """
+        collections.namedtuple is available in (python >= 2.6)
+    """
+    
+    v = sys.version_info
+    if v[1] >= 6 and v[0] < 3:
+        return collections.namedtuple(name, children)
+    else:
+        def fancydict(*args):
+            d = {}
+            i = 0
+            for child in children:
+                d[child.strip()] = args[i]
+                i += 1
+            return d
+        
+        return fancydict
+
+TopItem = _namedtuple("TopItem", ["item", "weight"])
+SimilarItem = _namedtuple("SimilarItem", ["item", "match"])
+LibraryItem = _namedtuple("LibraryItem", ["item", "playcount", "tagcount"])
+PlayedTrack = _namedtuple("PlayedTrack", ["track", "playback_date", "timestamp"])
+LovedTrack = _namedtuple("LovedTrack", ["track", "date", "timestamp"])
+ImageSizes = _namedtuple("ImageSizes", ["original", "large", "largesquare", "medium", "small", "extralarge"])
+Image = _namedtuple("Image", ["title", "url", "dateadded", "format", "owner", "sizes", "votes"])
+Shout = _namedtuple("Shout", ["body", "author", "date"])
+
+def _string_output(funct):
+    def r(*args):
+        return _string(funct(*args))
+        
+    return r
+
+def _pad_list(given_list, desired_length, padding = None):
+    """
+        Pads a list to be of the desired_length.
+    """
+    
+    while len(given_list) < desired_length:
+        given_list.append(padding)
+    
+    return given_list
+
+class _BaseObject(object):
+    """An abstract webservices object."""
+    
+    network = None
+    
+    def __init__(self, network):
+        self.network = network
+    
+    def _request(self, method_name, cacheable = False, params = None):
+        if not params:
+            params = self._get_params()
+            
+        return _Request(self.network, method_name, params).execute(cacheable)
+    
+    def _get_params(self):
+        """Returns the most common set of parameters between all objects."""
+        
+        return {}
+    
+    def __hash__(self):
+        return hash(self.network) + \
+            hash(str(type(self)) + "".join(self._get_params().keys() + self._get_params().values()).lower())
+
+class _Taggable(object):
+    """Common functions for classes with tags."""
+    
+    def __init__(self, ws_prefix):
+        self.ws_prefix = ws_prefix
+    
+    def add_tags(self, *tags):
+        """Adds one or several tags.
+        * *tags: Any number of tag names or Tag objects. 
+        """
+        
+        for tag in tags:
+            self._add_tag(tag)    
+    
+    def _add_tag(self, tag):
+        """Adds one or several tags.
+        * tag: one tag name or a Tag object.
+        """
+        
+        if isinstance(tag, Tag):
+            tag = tag.get_name()
+        
+        params = self._get_params()
+        params['tags'] = _unicode(tag)
+        
+        self._request(self.ws_prefix + '.addTags', False, params)
+    
+    def _remove_tag(self, single_tag):
+        """Remove a user's tag from this object."""
+        
+        if isinstance(single_tag, Tag):
+            single_tag = single_tag.get_name()
+        
+        params = self._get_params()
+        params['tag'] = _unicode(single_tag)
+        
+        self._request(self.ws_prefix + '.removeTag', False, params)
+
+    def get_tags(self):
+        """Returns a list of the tags set by the user to this object."""
+        
+        # Uncacheable because it can be dynamically changed by the user.
+        params = self._get_params()
+        
+        doc = self._request(self.ws_prefix + '.getTags', False, params)
+        tag_names = _extract_all(doc, 'name')
+        tags = []
+        for tag in tag_names:
+            tags.append(Tag(tag, self.network))
+        
+        return tags
+    
+    def remove_tags(self, *tags):
+        """Removes one or several tags from this object.
+        * *tags: Any number of tag names or Tag objects. 
+        """
+        
+        for tag in tags:
+            self._remove_tag(tag)
+    
+    def clear_tags(self):
+        """Clears all the user-set tags. """
+        
+        self.remove_tags(*(self.get_tags()))
+    
+    def set_tags(self, *tags):
+        """Sets this object's tags to only those tags.
+        * *tags: any number of tag names.
+        """
+        
+        c_old_tags = []
+        old_tags = []
+        c_new_tags = []
+        new_tags = []
+        
+        to_remove = []
+        to_add = []
+        
+        tags_on_server = self.get_tags()
+        
+        for tag in tags_on_server:
+            c_old_tags.append(tag.get_name().lower())
+            old_tags.append(tag.get_name())
+        
+        for tag in tags:
+            c_new_tags.append(tag.lower())
+            new_tags.append(tag)
+        
+        for i in range(0, len(old_tags)):
+            if not c_old_tags[i] in c_new_tags:
+                to_remove.append(old_tags[i])
+        
+        for i in range(0, len(new_tags)):
+            if not c_new_tags[i] in c_old_tags:
+                to_add.append(new_tags[i])
+        
+        self.remove_tags(*to_remove)
+        self.add_tags(*to_add)
+        
+    def get_top_tags(self, limit = None):
+        """Returns a list of the most frequently used Tags on this object."""
+        
+        doc = self._request(self.ws_prefix + '.getTopTags', True)
+        
+        elements = doc.getElementsByTagName('tag')
+        seq = []
+        
+        for element in elements:
+            if limit and len(seq) >= limit:
+                break
+            tag_name = _extract(element, 'name')
+            tagcount = _extract(element, 'count')
+            
+            seq.append(TopItem(Tag(tag_name, self.network), tagcount))
+        
+        return seq
+        
+class WSError(Exception):
+    """Exception related to the Network web service"""
+    
+    def __init__(self, network, status, details):
+        self.status = status
+        self.details = details
+        self.network = network
+
+    @_string_output
+    def __str__(self):
+        return self.details
+    
+    def get_id(self):
+        """Returns the exception ID, from one of the following:
+            STATUS_INVALID_SERVICE = 2
+            STATUS_INVALID_METHOD = 3
+            STATUS_AUTH_FAILED = 4
+            STATUS_INVALID_FORMAT = 5
+            STATUS_INVALID_PARAMS = 6
+            STATUS_INVALID_RESOURCE = 7
+            STATUS_TOKEN_ERROR = 8
+            STATUS_INVALID_SK = 9
+            STATUS_INVALID_API_KEY = 10
+            STATUS_OFFLINE = 11
+            STATUS_SUBSCRIBERS_ONLY = 12
+            STATUS_TOKEN_UNAUTHORIZED = 14
+            STATUS_TOKEN_EXPIRED = 15
+        """
+        
+        return self.status
+
+class Album(_BaseObject, _Taggable):
+    """An album."""
+    
+    title = None
+    artist = None
+    
+    def __init__(self, artist, title, network):
+        """
+        Create an album instance.
+        # Parameters:
+            * artist: An artist name or an Artist object.
+            * title: The album title.
+        """
+        
+        _BaseObject.__init__(self, network)
+        _Taggable.__init__(self, 'album')
+        
+        if isinstance(artist, Artist):
+            self.artist = artist
+        else:
+            self.artist = Artist(artist, self.network)
+        
+        self.title = title
+
+    @_string_output
+    def __repr__(self):
+        return u"%s - %s" %(self.get_artist().get_name(), self.get_title())
+    
+    def __eq__(self, other):
+        return (self.get_title().lower() == other.get_title().lower()) and (self.get_artist().get_name().lower() == other.get_artist().get_name().lower())
+    
+    def __ne__(self, other):
+        return (self.get_title().lower() != other.get_title().lower()) or (self.get_artist().get_name().lower() != other.get_artist().get_name().lower())
+    
+    def _get_params(self):
+        return {'artist': self.get_artist().get_name(), 'album': self.get_title(), }
+    
+    def get_artist(self):
+        """Returns the associated Artist object."""
+        
+        return self.artist
+    
+    def get_title(self):
+        """Returns the album title."""
+        
+        return self.title
+    
+    def get_name(self):
+        """Returns the album title (alias to Album.get_title)."""
+        
+        return self.get_title()
+    
+    def get_release_date(self):
+        """Retruns the release date of the album."""
+        
+        return _extract(self._request("album.getInfo", cacheable = True), "releasedate")
+    
+    def get_cover_image(self, size = COVER_EXTRA_LARGE):
+        """
+        Returns a uri to the cover image
+        size can be one of:
+            COVER_MEGA
+            COVER_EXTRA_LARGE
+            COVER_LARGE
+            COVER_MEDIUM
+            COVER_SMALL
+        """
+        
+        return _extract_all(self._request("album.getInfo", cacheable = True), 'image')[size]
+    
+    def get_id(self):
+        """Returns the ID"""
+        
+        return _extract(self._request("album.getInfo", cacheable = True), "id")
+    
+    def get_playcount(self):
+        """Returns the number of plays on the network"""
+        
+        return _number(_extract(self._request("album.getInfo", cacheable = True), "playcount"))
+    
+    def get_listener_count(self):
+        """Returns the number of liteners on the network"""
+        
+        return _number(_extract(self._request("album.getInfo", cacheable = True), "listeners"))
+    
+    def get_top_tags(self, limit=None):
+        """Returns a list of the most-applied tags to this album."""
+        
+        doc = self._request("album.getInfo", True)
+        e = doc.getElementsByTagName("toptags")[0]
+        
+        seq = []
+        for name in _extract_all(e, "name"):
+            if len(seq) < limit:
+                seq.append(Tag(name, self.network))
+        
+        return seq
+
+    def get_tracks(self):
+        """Returns the list of Tracks on this album."""
+        
+        uri = 'lastfm://playlist/album/%s' %self.get_id()
+        
+        return XSPF(uri, self.network).get_tracks()
+    
+    def get_mbid(self):
+        """Returns the MusicBrainz id of the album."""
+        
+        return _extract(self._request("album.getInfo", cacheable = True), "mbid")
+        
+    def get_url(self, domain_name = DOMAIN_ENGLISH):
+        """Returns the url of the album page on the network. 
+        # Parameters:
+        * domain_name str: The network's language domain. Possible values:
+            o DOMAIN_ENGLISH
+            o DOMAIN_GERMAN
+            o DOMAIN_SPANISH
+            o DOMAIN_FRENCH
+            o DOMAIN_ITALIAN
+            o DOMAIN_POLISH
+            o DOMAIN_PORTUGUESE
+            o DOMAIN_SWEDISH
+            o DOMAIN_TURKISH
+            o DOMAIN_RUSSIAN
+            o DOMAIN_JAPANESE
+            o DOMAIN_CHINESE
+        """
+        
+        artist = _url_safe(self.get_artist().get_name())
+        album = _url_safe(self.get_title())
+        
+        return self.network._get_url(domain_name, "album") %{'artist': artist, 'album': album}
+    
+    def get_wiki_published_date(self):
+        """Returns the date of publishing this version of the wiki."""
+        
+        doc = self._request("album.getInfo", True)
+        
+        if len(doc.getElementsByTagName("wiki")) == 0:
+            return
+        
+        node = doc.getElementsByTagName("wiki")[0]
+        
+        return _extract(node, "published")
+    
+    def get_wiki_summary(self):
+        """Returns the summary of the wiki."""
+        
+        doc = self._request("album.getInfo", True)
+        
+        if len(doc.getElementsByTagName("wiki")) == 0:
+            return
+        
+        node = doc.getElementsByTagName("wiki")[0]
+        
+        return _extract(node, "summary")
+    
+    def get_wiki_content(self):
+        """Returns the content of the wiki."""
+        
+        doc = self._request("album.getInfo", True)
+        
+        if len(doc.getElementsByTagName("wiki")) == 0:
+            return
+        
+        node = doc.getElementsByTagName("wiki")[0]
+        
+        return _extract(node, "content")
+
+class Artist(_BaseObject, _Taggable):
+    """An artist."""
+    
+    name = None
+    
+    def __init__(self, name, network):
+        """Create an artist object.
+        # Parameters:
+            * name str: The artist's name.
+        """
+        
+        _BaseObject.__init__(self, network)
+        _Taggable.__init__(self, 'artist')
+        
+        self.name = name
+
+    @_string_output
+    def __repr__(self):
+        return self.get_name()
+    
+    def __eq__(self, other):
+        return self.get_name().lower() == other.get_name().lower()
+    
+    def __ne__(self, other):
+        return self.get_name().lower() != other.get_name().lower()
+    
+    def _get_params(self):
+        return {'artist': self.get_name()}
+    
+    def get_name(self):
+        """Returns the name of the artist."""
+        
+        return self.name
+    
+    def get_cover_image(self, size = COVER_LARGE):
+        """
+        Returns a uri to the cover image
+        size can be one of:
+            COVER_MEGA
+            COVER_EXTRA_LARGE
+            COVER_LARGE
+            COVER_MEDIUM
+            COVER_SMALL
+        """
+        
+        return _extract_all(self._request("artist.getInfo", True), "image")[size]
+    
+    def get_playcount(self):
+        """Returns the number of plays on the network."""
+        
+        return _number(_extract(self._request("artist.getInfo", True), "playcount"))
+
+    def get_mbid(self):
+        """Returns the MusicBrainz ID of this artist."""
+        
+        doc = self._request("artist.getInfo", True)
+        
+        return _extract(doc, "mbid")
+        
+    def get_listener_count(self):
+        """Returns the number of liteners on the network."""
+        
+        return _number(_extract(self._request("artist.getInfo", True), "listeners"))
+    
+    def is_streamable(self):
+        """Returns True if the artist is streamable."""
+        
+        return bool(_number(_extract(self._request("artist.getInfo", True), "streamable")))
+    
+    def get_bio_published_date(self):
+        """Returns the date on which the artist's biography was published."""
+        
+        return _extract(self._request("artist.getInfo", True), "published")
+    
+    def get_bio_summary(self):
+        """Returns the summary of the artist's biography."""
+        
+        return _extract(self._request("artist.getInfo", True), "summary")
+    
+    def get_bio_content(self):
+        """Returns the content of the artist's biography."""
+        
+        return _extract(self._request("artist.getInfo", True), "content")
+    
+    def get_upcoming_events(self):
+        """Returns a list of the upcoming Events for this artist."""
+        
+        doc = self._request('artist.getEvents', True)
+        
+        ids = _extract_all(doc, 'id')
+        
+        events = []
+        for e_id in ids:
+            events.append(Event(e_id, self.network))
+        
+        return events
+    
+    def get_similar(self, limit = None):
+        """Returns the similar artists on the network."""
+        
+        params = self._get_params()
+        if limit:
+            params['limit'] = _unicode(limit)
+        
+        doc = self._request('artist.getSimilar', True, params)
+        
+        names = _extract_all(doc, "name")
+        matches = _extract_all(doc, "match")
+        
+        artists = []
+        for i in range(0, len(names)):
+            artists.append(SimilarItem(Artist(names[i], self.network), _number(matches[i])))
+        
+        return artists
+
+    def get_top_albums(self):
+        """Retuns a list of the top albums."""
+        
+        doc = self._request('artist.getTopAlbums', True)
+        
+        seq = []
+        
+        for node in doc.getElementsByTagName("album"):
+            name = _extract(node, "name")
+            artist = _extract(node, "name", 1)
+            playcount = _extract(node, "playcount")
+            
+            seq.append(TopItem(Album(artist, name, self.network), playcount))
+        
+        return seq
+        
+    def get_top_tracks(self):
+        """Returns a list of the most played Tracks by this artist."""
+        
+        doc = self._request("artist.getTopTracks", True)
+        
+        seq = []
+        for track in doc.getElementsByTagName('track'):
+            
+            title = _extract(track, "name")
+            artist = _extract(track, "name", 1)
+            playcount = _number(_extract(track, "playcount"))
+            
+            seq.append( TopItem(Track(artist, title, self.network), playcount) )
+        
+        return seq
+    
+    def get_top_fans(self, limit = None):
+        """Returns a list of the Users who played this artist the most.
+        # Parameters:
+            * limit int: Max elements.
+        """
+        
+        doc = self._request('artist.getTopFans', True)
+        
+        seq = []
+        
+        elements = doc.getElementsByTagName('user')
+        
+        for element in elements:
+            if limit and len(seq) >= limit:
+                break
+                
+            name = _extract(element, 'name')
+            weight = _number(_extract(element, 'weight'))
+            
+            seq.append(TopItem(User(name, self.network), weight))
+        
+        return seq
+
+    def share(self, users, message = None):
+        """Shares this artist (sends out recommendations). 
+        # Parameters:
+            * users [User|str,]: A list that can contain usernames, emails, User objects, or all of them.
+            * message str: A message to include in the recommendation message. 
+        """
+        
+        #last.fm currently accepts a max of 10 recipient at a time
+        while(len(users) > 10):
+            section = users[0:9]
+            users = users[9:]
+            self.share(section, message)
+        
+        nusers = []
+        for user in users:
+            if isinstance(user, User):
+                nusers.append(user.get_name())
+            else:
+                nusers.append(user)
+        
+        params = self._get_params()
+        recipients = ','.join(nusers)
+        params['recipient'] = recipients
+        if message: params['message'] = _unicode(message)
+        
+        self._request('artist.share', False, params)
+    
+    def get_url(self, domain_name = DOMAIN_ENGLISH):
+        """Returns the url of the artist page on the network. 
+        # Parameters:
+        * domain_name: The network's language domain. Possible values:
+          o DOMAIN_ENGLISH
+          o DOMAIN_GERMAN
+          o DOMAIN_SPANISH
+          o DOMAIN_FRENCH
+          o DOMAIN_ITALIAN
+          o DOMAIN_POLISH
+          o DOMAIN_PORTUGUESE
+          o DOMAIN_SWEDISH
+          o DOMAIN_TURKISH
+          o DOMAIN_RUSSIAN
+          o DOMAIN_JAPANESE
+          o DOMAIN_CHINESE 
+        """
+        
+        artist = _url_safe(self.get_name())
+        
+        return self.network._get_url(domain_name, "artist") %{'artist': artist}
+    
+    def get_images(self, order=IMAGES_ORDER_POPULARITY, limit=None):
+        """
+            Returns a sequence of Image objects
+            if limit is None it will return all
+            order can be IMAGES_ORDER_POPULARITY or IMAGES_ORDER_DATE
+        """
+        
+        images = []
+        
+        params = self._get_params()
+        params["order"] = order
+        nodes = _collect_nodes(limit, self, "artist.getImages", True, params)
+        for e in nodes:
+            if _extract(e, "name"):
+                user = User(_extract(e, "name"), self.network)
+            else:
+                user = None
+                
+            images.append(Image(
+                            _extract(e, "title"),
+                            _extract(e, "url"),
+                            _extract(e, "dateadded"),
+                            _extract(e, "format"),
+                            user,
+                            ImageSizes(*_extract_all(e, "size")),
+                            (_extract(e, "thumbsup"), _extract(e, "thumbsdown"))
+                            )
+                        )
+        return images
+
+    def get_shouts(self, limit=50):
+        """
+            Returns a sequqence of Shout objects
+        """
+        
+        shouts = []
+        for node in _collect_nodes(limit, self, "artist.getShouts", False):
+            shouts.append(Shout(
+                                _extract(node, "body"),
+                                User(_extract(node, "author"), self.network),
+                                _extract(node, "date")
+                                )
+                            )
+        return shouts
+    
+    def shout(self, message):
+        """
+            Post a shout
+        """
+        
+        params = self._get_params()
+        params["message"] = message
+        
+        self._request("artist.Shout", False, params)
+        
+
+class Event(_BaseObject):
+    """An event."""
+    
+    id = None
+    
+    def __init__(self, event_id, network):
+        _BaseObject.__init__(self, network)
+        
+        self.id = _unicode(event_id)
+    
+    @_string_output
+    def __repr__(self):
+        return "Event #" + self.get_id()
+    
+    def __eq__(self, other):
+        return self.get_id() == other.get_id()
+    
+    def __ne__(self, other):
+        return self.get_id() != other.get_id()
+    
+    def _get_params(self):
+        return {'event': self.get_id()}
+    
+    def attend(self, attending_status):
+        """Sets the attending status.
+        * attending_status: The attending status. Possible values:
+          o EVENT_ATTENDING
+          o EVENT_MAYBE_ATTENDING
+          o EVENT_NOT_ATTENDING 
+        """
+        
+        params = self._get_params()
+        params['status'] = _unicode(attending_status)
+        
+        self._request('event.attend', False, params)
+    
+    def get_attendees(self):
+        """
+            Get a list of attendees for an event
+        """
+        
+        doc = self._request("event.getAttendees", False)
+        
+        users = []
+        for name in _extract_all(doc, "name"):
+            users.append(User(name, self.network))
+        
+        return users
+        
+    def get_id(self):
+        """Returns the id of the event on the network. """
+        
+        return self.id
+    
+    def get_title(self):
+        """Returns the title of the event. """
+        
+        doc = self._request("event.getInfo", True)
+        
+        return _extract(doc, "title")
+    
+    def get_headliner(self):
+        """Returns the headliner of the event. """
+        
+        doc = self._request("event.getInfo", True)
+        
+        return Artist(_extract(doc, "headliner"), self.network)
+    
+    def get_artists(self):
+        """Returns a list of the participating Artists. """
+        
+        doc = self._request("event.getInfo", True)
+        names = _extract_all(doc, "artist")
+        
+        artists = []
+        for name in names:
+            artists.append(Artist(name, self.network))
+        
+        return artists
+    
+    def get_venue(self):
+        """Returns the venue where the event is held."""
+        
+        doc = self._request("event.getInfo", True)
+        
+        v = doc.getElementsByTagName("venue")[0]
+        venue_id = _number(_extract(v, "id"))
+        
+        return Venue(venue_id, self.network)
+    
+    def get_start_date(self):
+        """Returns the date when the event starts."""
+        
+        doc = self._request("event.getInfo", True)
+        
+        return _extract(doc, "startDate")
+        
+    def get_description(self):
+        """Returns the description of the event. """
+        
+        doc = self._request("event.getInfo", True)
+        
+        return _extract(doc, "description")
+    
+    def get_cover_image(self, size = COVER_LARGE):
+        """
+        Returns a uri to the cover image
+        size can be one of:
+            COVER_MEGA
+            COVER_EXTRA_LARGE
+            COVER_LARGE
+            COVER_MEDIUM
+            COVER_SMALL
+        """
+        
+        doc = self._request("event.getInfo", True)
+        
+        return _extract_all(doc, "image")[size]
+    
+    def get_attendance_count(self):
+        """Returns the number of attending people. """
+        
+        doc = self._request("event.getInfo", True)
+        
+        return _number(_extract(doc, "attendance"))
+    
+    def get_review_count(self):
+        """Returns the number of available reviews for this event. """
+        
+        doc = self._request("event.getInfo", True)
+        
+        return _number(_extract(doc, "reviews"))
+    
+    def get_url(self, domain_name = DOMAIN_ENGLISH):
+        """Returns the url of the event page on the network. 
+        * domain_name: The network's language domain. Possible values:
+          o DOMAIN_ENGLISH
+          o DOMAIN_GERMAN
+          o DOMAIN_SPANISH
+          o DOMAIN_FRENCH
+          o DOMAIN_ITALIAN
+          o DOMAIN_POLISH
+          o DOMAIN_PORTUGUESE
+          o DOMAIN_SWEDISH
+          o DOMAIN_TURKISH
+          o DOMAIN_RUSSIAN
+          o DOMAIN_JAPANESE
+          o DOMAIN_CHINESE 
+        """
+        
+        return self.network._get_url(domain_name, "event") %{'id': self.get_id()}
+
+    def share(self, users, message = None):
+        """Shares this event (sends out recommendations). 
+          * users: A list that can contain usernames, emails, User objects, or all of them.
+          * message: A message to include in the recommendation message. 
+        """
+        
+        #last.fm currently accepts a max of 10 recipient at a time
+        while(len(users) > 10):
+            section = users[0:9]
+            users = users[9:]
+            self.share(section, message)
+        
+        nusers = []
+        for user in users:
+            if isinstance(user, User):
+                nusers.append(user.get_name())
+            else:
+                nusers.append(user)
+        
+        params = self._get_params()
+        recipients = ','.join(nusers)
+        params['recipient'] = recipients
+        if message: params['message'] = _unicode(message)
+        
+        self._request('event.share', False, params)
+
+    def get_shouts(self, limit=50):
+        """
+            Returns a sequqence of Shout objects
+        """
+        
+        shouts = []
+        for node in _collect_nodes(limit, self, "event.getShouts", False):
+            shouts.append(Shout(
+                                _extract(node, "body"),
+                                User(_extract(node, "author"), self.network),
+                                _extract(node, "date")
+                                )
+                            )
+        return shouts
+    
+    def shout(self, message):
+        """
+            Post a shout
+        """
+        
+        params = self._get_params()
+        params["message"] = message
+        
+        self._request("event.Shout", False, params)
+        
+class Country(_BaseObject):
+    """A country at Last.fm."""
+    
+    name = None
+    
+    def __init__(self, name, network):
+        _BaseObject.__init__(self, network)
+        
+        self.name = name
+    
+    @_string_output
+    def __repr__(self):
+        return self.get_name()
+    
+    def __eq__(self, other):
+        return self.get_name().lower() == other.get_name().lower()
+    
+    def __ne__(self, other):
+        return self.get_name() != other.get_name()
+    
+    def _get_params(self):
+        return {'country': self.get_name()}
+    
+    def _get_name_from_code(self, alpha2code):
+        # TODO: Have this function lookup the alpha-2 code and return the country name.
+        
+        return alpha2code
+    
+    def get_name(self):
+        """Returns the country name. """
+        
+        return self.name
+    
+    def get_top_artists(self):
+        """Returns a sequence of the most played artists."""
+        
+        doc = self._request('geo.getTopArtists', True)
+        
+        seq = []
+        for node in doc.getElementsByTagName("artist"):
+            name = _extract(node, 'name')
+            playcount = _extract(node, "playcount")
+        
+            seq.append(TopItem(Artist(name, self.network), playcount))
+        
+        return seq
+    
+    def get_top_tracks(self):
+        """Returns a sequence of the most played tracks"""
+        
+        doc = self._request("geo.getTopTracks", True)
+        
+        seq = []
+        
+        for n in doc.getElementsByTagName('track'):
+            
+            title = _extract(n, 'name')
+            artist = _extract(n, 'name', 1)
+            playcount = _number(_extract(n, "playcount"))
+            
+            seq.append( TopItem(Track(artist, title, self.network), playcount))
+        
+        return seq
+    
+    def get_url(self, domain_name = DOMAIN_ENGLISH):
+        """Returns the url of the event page on the network. 
+        * domain_name: The network's language domain. Possible values:
+          o DOMAIN_ENGLISH
+          o DOMAIN_GERMAN
+          o DOMAIN_SPANISH
+          o DOMAIN_FRENCH
+          o DOMAIN_ITALIAN
+          o DOMAIN_POLISH
+          o DOMAIN_PORTUGUESE
+          o DOMAIN_SWEDISH
+          o DOMAIN_TURKISH
+          o DOMAIN_RUSSIAN
+          o DOMAIN_JAPANESE
+          o DOMAIN_CHINESE 
+        """
+        
+        country_name = _url_safe(self.get_name())
+        
+        return self.network._get_url(domain_name, "country") %{'country_name': country_name}
+
+
+class Library(_BaseObject):
+    """A user's Last.fm library."""
+    
+    user = None
+    
+    def __init__(self, user, network):
+        _BaseObject.__init__(self, network)
+        
+        if isinstance(user, User):
+            self.user = user
+        else:
+            self.user = User(user, self.network)
+        
+        self._albums_index = 0
+        self._artists_index = 0
+        self._tracks_index = 0
+    
+    @_string_output
+    def __repr__(self):
+        return repr(self.get_user()) + "'s Library"
+    
+    def _get_params(self):
+        return {'user': self.user.get_name()}
+    
+    def get_user(self):
+        """Returns the user who owns this library."""
+        
+        return self.user
+    
+    def add_album(self, album):
+        """Add an album to this library."""
+        
+        params = self._get_params()
+        params["artist"] = album.get_artist.get_name()
+        params["album"] = album.get_name()
+        
+        self._request("library.addAlbum", False, params)
+    
+    def add_artist(self, artist):
+        """Add an artist to this library."""
+        
+        params = self._get_params()
+        params["artist"] = artist.get_name()
+        
+        self._request("library.addArtist", False, params)
+    
+    def add_track(self, track):
+        """Add a track to this library."""
+        
+        params = self._get_params()
+        params["track"] = track.get_title()
+        
+        self._request("library.addTrack", False, params)
+    
+    def get_albums(self, limit=50):
+        """
+        Returns a sequence of Album objects
+        if limit==None it will return all (may take a while)
+        """
+        
+        seq = []
+        for node in _collect_nodes(limit, self, "library.getAlbums", True):
+            name = _extract(node, "name")
+            artist = _extract(node, "name", 1)
+            playcount = _number(_extract(node, "playcount"))
+            tagcount = _number(_extract(node, "tagcount"))
+            
+            seq.append(LibraryItem(Album(artist, name, self.network), playcount, tagcount))
+        
+        return seq
+    
+    def get_artists(self, limit=50):
+        """
+        Returns a sequence of Album objects
+        if limit==None it will return all (may take a while)
+        """
+        
+        seq = []
+        for node in _collect_nodes(limit, self, "library.getArtists", True):
+            name = _extract(node, "name")
+            
+            playcount = _number(_extract(node, "playcount"))
+            tagcount = _number(_extract(node, "tagcount"))
+            
+            seq.append(LibraryItem(Artist(name, self.network), playcount, tagcount))
+        
+        return seq
+
+    def get_tracks(self, limit=50):
+        """
+        Returns a sequence of Album objects
+        if limit==None it will return all (may take a while)
+        """
+        
+        seq = []
+        for node in _collect_nodes(limit, self, "library.getTracks", True):
+            name = _extract(node, "name")
+            artist = _extract(node, "name", 1)
+            playcount = _number(_extract(node, "playcount"))
+            tagcount = _number(_extract(node, "tagcount"))
+            
+            seq.append(LibraryItem(Track(artist, name, self.network), playcount, tagcount))
+        
+        return seq
+            
+
+class Playlist(_BaseObject):
+    """A Last.fm user playlist."""
+    
+    id = None
+    user = None
+    
+    def __init__(self, user, id, network):
+        _BaseObject.__init__(self, network)
+        
+        if isinstance(user, User):
+            self.user = user
+        else:
+            self.user = User(user, self.network)
+        
+        self.id = _unicode(id)
+    
+    @_string_output
+    def __repr__(self):
+        return repr(self.user) + "'s playlist # " + repr(self.id)
+        
+    def _get_info_node(self):
+        """Returns the node from user.getPlaylists where this playlist's info is."""
+        
+        doc = self._request("user.getPlaylists", True)
+        
+        for node in doc.getElementsByTagName("playlist"):
+            if _extract(node, "id") == str(self.get_id()):
+                return node
+    
+    def _get_params(self):
+        return {'user': self.user.get_name(), 'playlistID': self.get_id()}
+    
+    def get_id(self):
+        """Returns the playlist id."""
+        
+        return self.id
+    
+    def get_user(self):
+        """Returns the owner user of this playlist."""
+        
+        return self.user
+    
+    def get_tracks(self):
+        """Returns a list of the tracks on this user playlist."""
+        
+        uri = u'lastfm://playlist/%s' %self.get_id()
+        
+        return XSPF(uri, self.network).get_tracks()
+    
+    def add_track(self, track):
+        """Adds a Track to this Playlist."""
+        
+        params = self._get_params()
+        params['artist'] = track.get_artist().get_name()
+        params['track'] = track.get_title()
+        
+        self._request('playlist.addTrack', False, params)
+    
+    def get_title(self):
+        """Returns the title of this playlist."""
+        
+        return _extract(self._get_info_node(), "title")
+    
+    def get_creation_date(self):
+        """Returns the creation date of this playlist."""
+        
+        return _extract(self._get_info_node(), "date")
+    
+    def get_size(self):
+        """Returns the number of tracks in this playlist."""
+        
+        return _number(_extract(self._get_info_node(), "size"))
+    
+    def get_description(self):
+        """Returns the description of this playlist."""
+        
+        return _extract(self._get_info_node(), "description")
+    
+    def get_duration(self):
+        """Returns the duration of this playlist in milliseconds."""
+        
+        return _number(_extract(self._get_info_node(), "duration"))
+    
+    def is_streamable(self):
+        """Returns True if the playlist is streamable.
+        For a playlist to be streamable, it needs at least 45 tracks by 15 different artists."""
+        
+        if _extract(self._get_info_node(), "streamable") == '1':
+            return True
+        else:
+            return False
+    
+    def has_track(self, track):
+        """Checks to see if track is already in the playlist.
+        * track: Any Track object.
+        """
+        
+        return track in self.get_tracks()
+
+    def get_cover_image(self, size = COVER_LARGE):
+        """
+        Returns a uri to the cover image
+        size can be one of:
+            COVER_MEGA
+            COVER_EXTRA_LARGE
+            COVER_LARGE
+            COVER_MEDIUM
+            COVER_SMALL
+        """
+        
+        return _extract(self._get_info_node(), "image")[size]
+    
+    def get_url(self, domain_name = DOMAIN_ENGLISH):
+        """Returns the url of the playlist on the network. 
+        * domain_name: The network's language domain. Possible values:
+          o DOMAIN_ENGLISH
+          o DOMAIN_GERMAN
+          o DOMAIN_SPANISH
+          o DOMAIN_FRENCH
+          o DOMAIN_ITALIAN
+          o DOMAIN_POLISH
+          o DOMAIN_PORTUGUESE
+          o DOMAIN_SWEDISH
+          o DOMAIN_TURKISH
+          o DOMAIN_RUSSIAN
+          o DOMAIN_JAPANESE
+          o DOMAIN_CHINESE 
+        """
+        
+        english_url = _extract(self._get_info_node(), "url")
+        appendix = english_url[english_url.rfind("/") + 1:]
+        
+        return self.network._get_url(domain_name, "playlist") %{'appendix': appendix, "user": self.get_user().get_name()}
+        
+
+class Tag(_BaseObject):
+    """A Last.fm object tag."""
+    
+    # TODO: getWeeklyArtistChart (too lazy, i'll wait for when someone requests it)
+    
+    name = None
+    
+    def __init__(self, name, network):
+        _BaseObject.__init__(self, network)
+        
+        self.name = name
+    
+    def _get_params(self):
+        return {'tag': self.get_name()}
+    
+    @_string_output
+    def __repr__(self):
+        return self.get_name()
+    
+    def __eq__(self, other):
+        return self.get_name().lower() == other.get_name().lower()
+    
+    def __ne__(self, other):
+        return self.get_name().lower() != other.get_name().lower()
+    
+    def get_name(self):
+        """Returns the name of the tag. """
+        
+        return self.name
+
+    def get_similar(self):
+        """Returns the tags similar to this one, ordered by similarity. """
+        
+        doc = self._request('tag.getSimilar', True)
+        
+        seq = []
+        names = _extract_all(doc, 'name')
+        for name in names:
+            seq.append(Tag(name, self.network))
+        
+        return seq
+    
+    def get_top_albums(self):
+        """Retuns a list of the top albums."""
+        
+        doc = self._request('tag.getTopAlbums', True)
+        
+        seq = []
+        
+        for node in doc.getElementsByTagName("album"):
+            name = _extract(node, "name")
+            artist = _extract(node, "name", 1)
+            playcount = _extract(node, "playcount")
+            
+            seq.append(TopItem(Album(artist, name, self.network), playcount))
+        
+        return seq
+        
+    def get_top_tracks(self):
+        """Returns a list of the most played Tracks by this artist."""
+        
+        doc = self._request("tag.getTopTracks", True)
+        
+        seq = []
+        for track in doc.getElementsByTagName('track'):
+            
+            title = _extract(track, "name")
+            artist = _extract(track, "name", 1)
+            playcount = _number(_extract(track, "playcount"))
+            
+            seq.append( TopItem(Track(artist, title, self.network), playcount) )
+        
+        return seq
+    
+    def get_top_artists(self):
+        """Returns a sequence of the most played artists."""
+        
+        doc = self._request('tag.getTopArtists', True)
+        
+        seq = []
+        for node in doc.getElementsByTagName("artist"):
+            name = _extract(node, 'name')
+            playcount = _extract(node, "playcount")
+        
+            seq.append(TopItem(Artist(name, self.network), playcount))
+        
+        return seq
+    
+    def get_weekly_chart_dates(self):
+        """Returns a list of From and To tuples for the available charts."""
+        
+        doc = self._request("tag.getWeeklyChartList", True)
+        
+        seq = []
+        for node in doc.getElementsByTagName("chart"):
+            seq.append( (node.getAttribute("from"), node.getAttribute("to")) )
+        
+        return seq
+    
+    def get_weekly_artist_charts(self, from_date = None, to_date = None):
+        """Returns the weekly artist charts for the week starting from the from_date value to the to_date value."""
+        
+        params = self._get_params()
+        if from_date and to_date:
+            params["from"] = from_date
+            params["to"] = to_date
+        
+        doc = self._request("tag.getWeeklyArtistChart", True, params)
+        
+        seq = []
+        for node in doc.getElementsByTagName("artist"):
+            item = Artist(_extract(node, "name"), self.network)
+            weight = _number(_extract(node, "weight"))
+            seq.append(TopItem(item, weight))
+        
+        return seq
+    
+    def get_url(self, domain_name = DOMAIN_ENGLISH):
+        """Returns the url of the tag page on the network. 
+        * domain_name: The network's language domain. Possible values:
+          o DOMAIN_ENGLISH
+          o DOMAIN_GERMAN
+          o DOMAIN_SPANISH
+          o DOMAIN_FRENCH
+          o DOMAIN_ITALIAN
+          o DOMAIN_POLISH
+          o DOMAIN_PORTUGUESE
+          o DOMAIN_SWEDISH
+          o DOMAIN_TURKISH
+          o DOMAIN_RUSSIAN
+          o DOMAIN_JAPANESE
+          o DOMAIN_CHINESE 
+        """
+        
+        name = _url_safe(self.get_name())
+        
+        return self.network._get_url(domain_name, "tag") %{'name': name}
+
+class Track(_BaseObject, _Taggable):
+    """A Last.fm track."""
+    
+    artist = None
+    title = None
+    
+    def __init__(self, artist, title, network):
+        _BaseObject.__init__(self, network)
+        _Taggable.__init__(self, 'track')
+        
+        if isinstance(artist, Artist):
+            self.artist = artist
+        else:
+            self.artist = Artist(artist, self.network)
+        
+        self.title = title
+
+    @_string_output
+    def __repr__(self):
+        return self.get_artist().get_name() + ' - ' + self.get_title()
+
+    def __eq__(self, other):
+        return (self.get_title().lower() == other.get_title().lower()) and (self.get_artist().get_name().lower() == other.get_artist().get_name().lower())
+    
+    def __ne__(self, other):
+        return (self.get_title().lower() != other.get_title().lower()) or (self.get_artist().get_name().lower() != other.get_artist().get_name().lower())
+    
+    def _get_params(self):
+        return {'artist': self.get_artist().get_name(), 'track': self.get_title()}
+            
+    def get_artist(self):
+        """Returns the associated Artist object."""
+        
+        return self.artist
+    
+    def get_title(self):
+        """Returns the track title."""
+        
+        return self.title
+    
+    def get_name(self):
+        """Returns the track title (alias to Track.get_title)."""
+        
+        return self.get_title()
+    
+    def get_id(self):
+        """Returns the track id on the network."""
+        
+        doc = self._request("track.getInfo", True)
+        
+        return _extract(doc, "id")
+    
+    def get_duration(self):
+        """Returns the track duration."""
+        
+        doc = self._request("track.getInfo", True)
+        
+        return _number(_extract(doc, "duration"))
+    
+    def get_mbid(self):
+        """Returns the MusicBrainz ID of this track."""
+        
+        doc = self._request("track.getInfo", True)
+        
+        return _extract(doc, "mbid")
+        
+    def get_listener_count(self):
+        """Returns the listener count."""