root/trunk/rockfm.py

#!/usr/bin/python

import sys
import datetime
import time
import re
import getpass
import os.path
from optparse import OptionParser
from rockfm import rockbox
from rockfm import Scrobbler
from rockfm import rockfm

current_version = '0.4'

def setup_args():
    parser = OptionParser(usage='%prog [options]\nrock.fm -- ' +
        'submit your songs played in rockbox to last.fm',
        version='rock.fm %s' % current_version)

    parser.add_option('-c', '--config', action='store', type='string',
        dest='conf_file', help='Location of the configuration file')
    parser.add_option('-n', '--no-config', action='store_true',
        dest='no_conf', help='Do not use a configuration file')
    parser.add_option('-d', '--directory', action='store', type='string',
        dest='log_dir', help='Directory of the scrobbler log file',
        default=None)
    parser.add_option('-D', '--dry-run', '--pretend', action='store_true',
        dest='pretend', help="Don't actually contact the servers")
    parser.add_option('-f', '--file', action='store', type='string',
        dest='log_file', help='Scrobbler log file', default=None)
    parser.add_option('-u', '--username', action='store', type='string',
        dest='username', help='Last.fm username')
    parser.add_option('-P', '--password', action='store', type='string',
        dest='password', help='Last.fm password (plaintext)')
    parser.add_option('-p', '--prompt', action='store_true',
        dest='prompt_pw', help='Prompt for a password to be entered')
    parser.add_option('-U', '--utc-offset', action='store', type='float',
        default=100.0, dest='utc_offset',
        help='Override UTC offset autodetection')
    parser.add_option('-m', '--max', action='store', type='int', default=1,
        dest='max_subs', help='Maximum songs to submit in one request')
    parser.add_option('-b', '--backup-dir', action='store', type='string',
        dest='backup_dir', help='Create a backup of the log file ' +
        'in the given directory')
    parser.add_option('-g', '--gui', action='store_true', default=True,
        dest='use_gui', help='Use the GUI interface')
    parser.add_option('-N', '--no-gui', action='store_false',
        dest='use_gui', help="Don't use the GUI interface")
    parser.add_option('-v', '--verbose', action='count',
        dest='verbose', help='Print status updates to the screen. ' +
        'Use twice for extra verbosity')

    return parser

def show_gui(scrobbler,conf,args):
    """Processes the logic of the GUI"""
    # if we can't load PyQt4, exit
    try:
        import rockfm.ui.RockApp
    except ImportError, error:
        sys.stderr.write('ImportError: %s' % (error))
        sys.exit(6)

    # calling the RockApp exits the app when closed
    app = rockfm.ui.RockApp(scrobbler,conf,args)

if __name__ == '__main__':
    # parse command line options, and exit if given a bad one
    try:
        parser = setup_args()
        (options, args) = parser.parse_args()
    except Exception, strerr:
        sys.stderr.write('Error parsing arguments: %s' % strerr)
        sys.exit(1)

    # create the new scrobbler object
    scrobbler = Scrobbler.Scrobbler('rb2', '0.1', options.username,
        options.password)

    # look for a conf file in standard locations
    if options.no_conf is not False and options.conf_file is None:
        for conf_loc in ('~/.config/rockfm', '~/.rockfm',
            '~/rockfm/rockfm.conf', '/usr/share/rockfm/rockfm.conf',
            '/usr/local/share/rockfm/rockfm.conf', '/etc/rockfm.conf'):
            if os.path.exists(os.path.expanduser(conf_loc)):
                options.conf_file = os.path.expanduser(conf_loc)
                break

    scrobbler.pretend = options.pretend
    conf_settings = {}
    if options.log_file is not None or options.log_dir is not None:
        forced_log = True
    else:
        forced_log = False

    if not options.no_conf and options.conf_file is not None:
        conf_settings = rockfm.read_config(options.conf_file)

        # set the required arguments
        if options.username is None:
            try:
                scrobbler.username = conf_settings['username']
            except KeyError: pass

        if options.password is None and options.prompt_pw is not True:
            try:
                scrobbler.set_md5_pw(conf_settings['password'])
            except KeyError: pass

        if options.log_file is None and options.log_dir is None:
            if not conf_settings.has_key('log_file'):
                try:
                    options.log_file = conf_settings['log_dir'] + \
                                    '/.scrobbler.log'
                except KeyError: pass
            else:
                options.log_file = conf_settings['log_file']

        # try the rest of them. pass on exceptions, since we expect
        # them if the key has not been set in the config function
        if options.utc_offset is None:
            try:
                options.utc_offset = conf_settings['utc_offset']
            except: pass

        if options.max_subs is None:
            try:
                options.max_subs = int(conf_settings['max_submit'])
            except: pass

        if options.use_gui is None:
            try:
                if int(conf_settings['gui']) > 0:
                    options.use_gui = True
                else:
                    options.use_gui = False
            except: pass

        if options.verbose is None:
            try:
                if int(conf_settings['verbose']) == 1:
                    scrobbler.set_verbose(True, False, use_gui)
                elif int(conf_settings['verbose']) > 1:
                    scrobbler.set_verbose(True, True, use_gui)
            except: pass

    if options.log_dir is not None and options.log_file is None:
        options.log_file = options.log_dir + '/.scrobbler.log'

    # backup the log file
    if options.backup_dir is not None and options.log_file is not None and \
        options.use_gui is not True:
        try:
            if scrobbler.verbose:
                sys.stdout.write('Copying scrobbler log file from %s to %s' %
                    (options.log_file, options.backup_dir))
            rockbox.backup_log(options.log_file, options.backup_dir)
        except IOError, err:
            sys.stderr.write('Could not backup log file: %s\n' % err)

        # exit gracefully if this was the only intention
        if scrobbler.username == None or options.prompt_pw is None:
            sys.exit(0)

    if options.use_gui:
        conf_settings['log_file'] = options.log_file
        conf_settings['file'] = options.conf_file
        conf_settings['forced_log'] = forced_log
        show_gui(scrobbler,conf_settings,[])

    if options.prompt_pw:
        while scrobbler.password == '' or scrobbler.password is None:
            scrobbler.password = getpass.getpass('Password: ')

    # show usage if log file, username, or password are not present
    # and no configuration file exists
    if (options.log_file is None or scrobbler.username is None or
        scrobbler.password is None) and options.use_gui is False:
        parser.print_help()
        sys.exit(2)

    scrobbler.set_max_submit(options.max_subs)
    if options.verbose == 1:
        scrobbler.set_verbose(True, False)
    elif options.verbose > 1:
        scrobbler.set_verbose(True, True)

    # compute the utc offset, if not given
    if options.utc_offset == 100.0:
        local = time.time()
        utc = time.mktime(time.gmtime(local))
        options.utc_offset = local - utc
        if scrobbler.verbose:
            print 'Guessing UTC offset:', options.utc_offset, 'seconds:', \
                options.utc_offset / 3600, 'hours'
    else:
        # set the utc offset to seconds
        if options.utc_offset > -12.0 and options.utc_offset < 13.0:
            options.utc_offset = options.utc_offset * 3600

    (header,log_array) = rockbox.read_log(options.log_file)
    for entry in log_array:
        artist, album, track, track_num, length, status, time = entry
        if status == 'L' and int(length) > 30:
            corrected_time = float(time) - float(options.utc_offset)
            if scrobbler.vv:
                print 'changed from', datetime.datetime.utcfromtimestamp(
                    float(time)),
                print 'to', datetime.datetime.utcfromtimestamp(float(
                    corrected_time))
            scrobbler.queue_song(artist, track, album, '', length,
                corrected_time)

    handshake_succeeded = False
    while not handshake_succeeded:
        try:
            handshake_succeeded = rockfm.handshake(scrobbler)
        except Scrobbler.HandshakeFrequencyError, error:
            sys.stderr.write('Handshake frequency error: %s\n' % error)
            sys.exit(3)
        except Scrobbler.UnknownHandshakeError, error:
            sys.stderr.write('Unknown handshake error: %s\n' % error)
            sys.exit(3)

    while len(scrobbler.queue) > 0:
        try:
            scrobbler.submit_queue()
        except Scrobbler.BadAuthError:
            try:
                sys.stderr.write('BadAuth error: attempting re-handshake\n')
                rockfm.handshake(scrobbler)
            except Scrobbler.HandshakeFrequencyError, error:
                sys.stderr.write('%s\n' % error)
                sys.exit(3)
            except Scrobbler.UnknownHandshakeError, error:
                sys.stderr.write('%s\n' % error)
                sys.exit(3)
        except Scrobbler.SubmitError, error:
            sys.stderr.write('Error during submit phase: %s\n' % (error))
        except IOError, error:
            sys.stderr.write('IOError: %s\n' % (error))

    if not scrobbler.pretend:
        rockbox.reset_log(options.log_file, header, scrobbler,
            options.utc_offset)