python-build/pythonbrew

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import sys
import urllib
import errno
import re
import shutil
import filecmp
import subprocess
import stat
from optparse import OptionParser

VERSION = "0.2"
if os.environ.has_key("PYTHONBREW_ROOT"):
    ROOT = os.environ["PYTHONBREW_ROOT"]
else:
    ROOT = "%s/python/pythonbrew" % os.environ["HOME"]
PYTHONDLSITE = "http://www.python.org/ftp/python/%s/%s"
EZSETUPDLSITE = "http://peak.telecommunity.com/dist/ez_setup.py"

PATH_PYTHONS = "%s/pythons" % ROOT
PATH_BUILD = "%s/build" % ROOT
PATH_DISTS = "%s/dists" % ROOT
PATH_ETC = "%s/etc" % ROOT

parser = OptionParser(usage="%prog COMMAND [OPTIONS]",
                      version=VERSION,
                      add_help_option=False)
parser.add_option(
    '-h', '--help',
    dest='help',
    action='store_true',
    help='Show help')
parser.disable_interspersed_args()

command_dict = {}
def add_command(command):
    command_dict[command.name] = command

def size_format(b):
    kb = 1000
    mb = kb*kb
    b = float(b)
    if b >= mb:
        return "%.1fMb" % (b/mb)
    if b >= kb:
        return "%.1fKb" % (b/kb)
    return "%.0fB" % (b)

class Download(object):
    def __init__(self):
        self._msg = ""
        self._last_msg = ""
        self._bytes = 0.0
    
    def download(self, msg, url, path):
        self._msg = msg
        self._bytes = 0
        urllib.urlretrieve(url, path, self._download_progress)
        print " downloaded."
    
    def _download_progress(self, block, blockbytes, maxbytes):
        self._bytes += float(blockbytes)
        if self._bytes >= maxbytes:
            self._bytes = maxbytes
        percent = (self._bytes / maxbytes) * 100
        max_size = size_format(maxbytes)
        now_size = size_format(self._bytes)
        now_msg = "\rDownloading %s (%s): %3i%%  %s" % (self._msg, max_size, percent, now_size)
        padding = " " * (len(self._last_msg) - len(now_msg))
        sys.stdout.write("%s%s" % (now_msg, padding))
        sys.stdout.flush()
        self._last_msg = now_msg

class Command(object):
    name = None
    usage = None
    summary = ""
    
    def __init__(self):
        self.parser = OptionParser(usage=self.usage,
                                   prog='%s %s' % (os.path.basename(sys.argv[0]), self.name))
        
    def run(self, args):
        options, args = self.parser.parse_args(args)
        self.run_command(options, args[1:])
        
    def _makedirs(self, name):
        try:
            os.makedirs( name )
        except OSError, (e, es):
            if errno.EEXIST != e:
                raise
    
    def _symlink(self, src, dst):
        try:
            os.symlink(src, dst)
        except:
            pass
        
    def _unlink(self, name):
        try:
            os.unlink(name)
        except OSError, (e, es):
            if errno.ENOENT != e:
                raise

    def _clean_switch_symlink(self):
        for root, dirs, files in os.walk("%s/bin/" % ROOT):
            for f in files:
                if f == "pythonbrew":
                    continue
                self._unlink("%s%s" % (root, f))

class HelpCommand(Command):
    name = "help"
    usage = "%prog [COMMAND]"
    summary = "Show available commands"
    
    def run_command(self, options, args):
        if args:
            command = args[0]
            if command not in command_dict:
                parser.error("Unknown command: `%s`" % command)
                return
            command = command_dict[command]
            command.parser.print_help()
            return
        parser.print_help()
        print
        print "Commands available:"
        commands = [command_dict[key] for key in sorted(command_dict.keys())]
        for command in commands:
            print "  %s: %s" % (command.name, command.summary)
        print
        print "Further Instructions:"
        print "  http://github.com/utahta/pythonbrew"

class InitCommand(Command):
    name = "init"
    usage = "%prog"
    summary = "Run this once to setup the pythonbrew directory ready for installing pythons into."
        
    def run_command(self, options, args):
        self._makedirs(PATH_PYTHONS)
        self._makedirs(PATH_BUILD)
        self._makedirs(PATH_DISTS)
        self._makedirs(PATH_ETC)
        
        os.system("echo 'export PATH=%s/bin:%s/current/bin:${PATH}' > %s/bashrc" % (ROOT, PATH_PYTHONS, PATH_ETC))
        os.system("echo 'setenv PATH %s/bin:%s/current/bin:$PATH' > %s/cshrc" % (ROOT, PATH_PYTHONS, PATH_ETC))
        m = re.search("(t?csh)", os.environ.get("SHELL"))
        if m:
            shrc = "cshrc"
            yourshrc = m.group(1)+"rc"
        else:
            shrc = yourshrc = "bashrc"
        print """
Pythonbrew environment initiated, required directories are created under

    """+ROOT+"""
    
Well-done! Congratulations! Please add the following line to the end
of your ~/."""+yourshrc+"""

    source """+PATH_ETC+"""/"""+shrc+"""

After that, exit this shell, start a new one, and install some fresh
pythons:

    pythonbrew install Python-2.6.6
    pythonbrew install Python-2.5.5

For further instructions, simply run:

    pythonbrew

The default help messages will popup and tell you what to do!

Enjoy pythonbrew at $HOME!!
INSTRUCTION"""

class InstallCommand(Command):
    name = "install"
    usage = "%prog [OPTIONS] PACKAGE_NAMES"
    summary = "Build and install the given version of python."
    
    def __init__(self):
        super(InstallCommand, self).__init__()
        self.parser.add_option(
            "-f", "--force",
            dest="force",
            action="store_true",
            default=False,
            help="Force installation of a Python."
        )
        self.parser.add_option(
            "-b", "--build-options",
            dest="build_options",
            default="",
            help="Set configure options."
        )
        self.parser.add_option(
            "-n", "--no-setuptools",
            dest="no_setuptools",
            action="store_true",
            default=False,
            help="Skip installation of setuptools."
        )
    
    def run_command(self, options, args):
        if args:
            # Install Python
            self._install_python(args[0], options)
        else:
            # Install pythonbrew
            executable = os.path.abspath(sys.argv[0])
            target = "%s/bin/pythonbrew" % ROOT
            if os.path.isfile(executable) and os.path.isfile(target):
                if filecmp.cmp(executable, target):
                    print """You are already running the installed pythonbrew:
        
    """ + executable;
                    return
            self._makedirs("%s/bin" % ROOT)
            shutil.copy(executable, target)
            os.chmod(target, 0755)
            print """The pythonbrew is installed as:
    
    """+target+"""

You may trash the downloaded """+executable+""" from now on.

Next, if this is the first time you've run pythonbrew installation, run:

    """+target+""" init

And follow the instruction on screen."""
    
    def _install_python(self, dist, options):
        m = re.search("^Python-(\d\.\d\d?(\.\d\d?)?)$", dist)
        if not m:
            print "Unknown package: `%s`" % dist
            return
        dist_version = m.group(1)
        dist_tgz = "%s.tgz" % dist
        download_path = "%s/%s" % (PATH_DISTS, dist_tgz)
        
        dl = Download()
        dl.download(
            dist_tgz,
            PYTHONDLSITE % (dist_version, dist_tgz),
            download_path
        )
        # iffy...
        if os.path.getsize( "%s" % (download_path) ) < 1000000:
            print "[ERROR] File not found (probably):%s/dists/%s" % (ROOT, dist_tgz)
            return
        
        build_options = "--prefix=%s/pythons/%s %s" % (ROOT, dist, options.build_options)
        print "Installing %s into %s/pythons/%s" % (dist, ROOT, dist);
        
        cmd = []
        cmd.append("cd %s/build" % ROOT)
        cmd.append("tar zxf %s/dists/%s" % (ROOT, dist_tgz))
        cmd.append("cd %s" % dist)
        cmd.append("./configure %s" % (build_options))
        if options.force:
            cmd.append("make")
            cmd.append("make install")
        else:
            cmd.append("make clean")
            cmd.append("make")
            cmd.append("make test && make install")
        cmd = ";".join(cmd)
        print cmd
        try:
            retcode = subprocess.call("%s >> %s/build.log 2>&1" % (cmd, ROOT), shell=True)
        except OSError, (e, es):
            retcode = -1
        if retcode != 0:
            print """Installing """+dist+""" failed. See """+ROOT+"""/build.log to see why.

    pythonbrew install --force """+dist
            return
        # install ez_setup
        self._install_ez_setup(dist, options.no_setuptools)
        print """Installed """+dist+""" successfully. Run the following command to switch to it.

    pythonbrew switch """+dist
    
    def _install_ez_setup(self, pydist, no_setuptools):
        if no_setuptools:
            print "Skip installation setuptools."
            return
        dist = EZSETUPDLSITE
        dist = dist[dist.rfind("/")+1:]
        
        dl = Download()
        dl.download(dist, EZSETUPDLSITE, "%s/%s" % (PATH_DISTS, dist))
        
        os.system("%s/%s/bin/python %s/%s" % (PATH_PYTHONS, pydist, PATH_DISTS, dist))
        if os.path.isfile("%s/%s/bin/easy_install" % (PATH_PYTHONS, pydist)):
            os.system("%s/%s/bin/easy_install pip" % (PATH_PYTHONS, pydist))

class InstalledCommand(Command):
    name = "installed"
    usage = "%prog"
    summary = "List the installed versions of python."
        
    def run_command(self, options, args):
        if os.path.islink("%s/current" % PATH_PYTHONS):
            if os.path.realpath("%s/current" % PATH_PYTHONS) == ROOT:
                cur = os.path.realpath("%s/bin/python" % ROOT)
            else:
                cur = os.path.realpath("%s/current" % PATH_PYTHONS)
            print "%s (*)" % cur
        else:
            cur = ""
        for d in os.listdir("%s/" % PATH_PYTHONS):
            if d == "current" or cur == "%s/%s" % (PATH_PYTHONS, d):
                continue
            print "%s/%s" % (PATH_PYTHONS, d)

class SwitchCommand(Command):
    name = "switch"
    usage = "%prog PACKAGE"
    summary = "Switch to the given version."
    
    def run_command(self, options, args):
        if args:
            dist = args[0]
        distdir = dist
        if os.path.isfile( dist ) and os.access( dist, os.X_OK ):
            if re.search( ".*python(\d(\.\d)?)?$", dist ):
                self._switch_file(dist)
            else:
                print "Invalid binary: `%s`" % dist
            return
        elif os.path.isdir( dist ):
            if os.path.isdir("%s/bin" % dist):
                if os.path.isfile("%s/bin/python" % dist):
                    self._switch_file("%s/bin/python" % dist)
                if os.path.isfile("%s/bin/python3" % dist):
                    self._switch_file("%s/bin/python3" % dist)
                return
            elif os.path.isfile("%s/python" % dist) and os.access("%s/python" % dist, os.X_OK):
                self._switch_file("%s/python" % dist)
                return
            elif os.path.isfile("%s/python3" % dist) and os.access("%s/python3" % dist, os.X_OK):
                self._switch_file("%s/python3" % dist)
                return
            else:
                print "Invalid directory: `%s`" % dist
                return
        elif not os.path.isdir( "%s/%s" % (PATH_PYTHONS, dist) ):
            print "Unknown package: `%s`" % dist
            return
        self._switch_dir( distdir )
    
    def _switch_file(self, dist):
        self._unlink("%s/current" % PATH_PYTHONS)
        self._unlink("%s/bin/python" % ROOT)
        self._clean_switch_symlink()
        self._symlink(dist, "%s/bin/python" % ROOT)
        self._symlink(ROOT, "%s/current" % PATH_PYTHONS)
        print "Switched to "+dist
    
    def _switch_dir(self, dist):
        self._unlink("%s/current" % PATH_PYTHONS)
        self._unlink("%s/bin/python" % ROOT)
        self._symlink(dist, "%s/current" % PATH_PYTHONS)
        self._clean_switch_symlink()
        for root, dirs, files in os.walk("%s/pythons/current/bin/" % ROOT):
            for f in files:
                self._symlink("%s%s" % (root, f), "%s/bin/%s" % (ROOT, f))
        print "Switched to "+dist
        
class OffCommand(Command):
    name = "off"
    usage = "%prog"
    summary = "Disable pythonbrew."
    
    def run_command(self, options, args):
        self._unlink("%s/current" % PATH_PYTHONS)
        self._clean_switch_symlink()

class VersionCommand(Command):
    name = "version"
    usage = "%prog"
    summary = "Show version."
    
    def run_command(self, options, args):
        print VERSION

class Pythonbrew(object):
    def run(self):
        options, args = parser.parse_args(sys.argv[1:])
        if options.help and not args:
            args = ["help"]
        if not args:
            parser.error('You must give a command (use "pythonbrew help" to see a list of commands)')
            return
        add_command(HelpCommand())
        add_command(InitCommand())
        add_command(InstallCommand())
        add_command(InstalledCommand())
        add_command(SwitchCommand())
        add_command(OffCommand())
        add_command(VersionCommand())
        
        command = args[0].lower()
        if command not in command_dict:
            parser.error("Unknown command: `%s`" % command)
            return
        command = command_dict[command]
        command.run(args)
            
def main():
    p = Pythonbrew()
    p.run()
    
if __name__ == "__main__":
    main()