pythons

.gitignore

@@ -9,3 +9,4 @@ pythonbrew.egg-info
 dist
 __pycache__
 *.swp
+.idea

ChangeLog

@@ -1,3 +1,11 @@
+* 1.1
+  - Added --framework, --universal and --static options to install command.
+
+* 1.0
+  - Added systemwide install support. (issue #31)
+  - Fixed issue #41 Handle venv binary with the symlink command.
+  - Improved `venv` command (without virtualenvwrapper)
+
 * 0.9
   - Added `buildout` command.
   - Added `venv` command.

PKG-INFO

@@ -12,7 +12,11 @@ The recommended way to download and install pythonbrew is to run these statement
 
   curl -kL http://xrl.us/pythonbrewinstall | bash
 
-After that, pythonbrew installs itself to ~/.pythonbrew, and you should follow the instruction on screen to setup your .bashrc to put it in your PATH.
+After that, pythonbrew installs itself to ~/.pythonbrew. 
+
+Please add the following line to the end of your ~/.bashrc::
+
+  [[ -s $HOME/.pythonbrew/etc/bashrc ]] && source $HOME/.pythonbrew/etc/bashrc
 
 If you need to install pythonbrew into somewhere else, you can do that by setting a PYTHONBREW_ROOT environment variable::
 
@@ -21,6 +25,17 @@ If you need to install pythonbrew into somewhere else, you can do that by settin
   chmod +x pythonbrewinstall
   ./pythonbrewinstall
 
+For Systemwide(Multi-User) installation
+---------------------------------------
+
+If the install script is run as root, pythonbrew will automatically install into /usr/local/pythonbrew.
+
+The pythonbrew will be automatically configured for every user on the system if you install as root.
+
+After installation, where you would normally use `sudo`, non-root users will need to use `sudopybrew`::
+
+  sudopybrew install -n -v -j2 2.7.2
+
 Usage
 =====
 
@@ -87,14 +102,16 @@ Create/Remove a symbolic link to python (in a directory on your $PATH)::
   pythonbrew symlink -p 2.7.2
   pythonbrew symlink pip # Create a symbolic link to the specified script in bin directory
   pythonbrew symlink -r # Remove a symbolic link
+  pythonbrew symlink -v foo # Create a symbolic link to the specified virtual environment python in bin directory
 
 Runs the buildout with specified or current using python::
   
   pythonbrew buildout
   pythonbrew buildout -p 2.6.6
 
-Create isolated python environments::
+Create isolated python environments (uses virtualenv)::
   
+  pythonbrew venv init
   pythonbrew venv create proj
   pythonbrew venv list
   pythonbrew venv use proj
@@ -145,35 +162,50 @@ buildout
   Runs the buildout with specified or current using python.
   
 venv
-  Create isolated python environments.
+  Create isolated python environments (uses virtualenv)
   
 version
   Show version.
   
-See more details below:
-  pythonbrew help <command>
+See more details below
+  `pythonbrew help <command>`
 
-LICENCE
-=======
+Changelog
+=========
 
-The MIT License
+1.1 (2011-08-29)
+----------------
 
-Copyright (c) <2010-2011> <utahta>
+- Added --framework, --universal and --static options to install command.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+1.0 (2011-08-08)
+----------------
 
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
+- Added systemwide install support. (issue #31)
+- Fixed issue #41 Handle venv binary with the symlink command.
+- Improved `venv` command (without virtualenvwrapper)
+
+0.9 (2011-07-21)
+----------------
+
+- Added `venv` command (uses virtualenv and virtualenvwrapper)
+- Added `buildout` command.
+
+0.8 (2011-07-10)
+----------------
+
+- Fixed issue #21 Added Ubuntu 11.04(Natty) support
+- Fixed issue #24 non-framework python27 now defines environ properly. Thanks npinto.
+- Fixed issue #27 Cleanup of OS X python build flags
+- Fixed issue #28 Describe the 'symlink' command better. Thanks tgs.
+- Fixed issue #30 py command does not accept arguments with a space
+- Fixed bug: `pythonbrew off` need not have removed the symlink in bin directory
+- Added --no-test option to the install command
+- Added --verbose option to the install command
+- `pythonbrew clean` has been removed. Added `pythonbrew cleanup` instead.
+
+More
+----
+
+see the `pythonbrew/Changelog <https://github.com/utahta/pythonbrew/blob/master/ChangeLog>`_
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

README.rst

@@ -1,6 +1,16 @@
 Overview
 ========
 
+Pythonbrew is anti-virtualenv. This isn't.
+
+Differences:
+
+- No `switch`. That's crazy.
+- Bottles (pre-compiled Pythons)
+
+----------------------------------
+
+
 pythonbrew is a program to automate the building and installation of Python in the users $HOME.
 
 pythonbrew is inspired by `perlbrew <http://github.com/gugod/App-perlbrew>`_ and `rvm <https://github.com/wayneeseguin/rvm>`_.
@@ -12,7 +22,11 @@ The recommended way to download and install pythonbrew is to run these statement
 
   curl -kL http://xrl.us/pythonbrewinstall | bash
 
-After that, pythonbrew installs itself to ~/.pythonbrew, and you should follow the instruction on screen to setup your .bashrc to put it in your PATH.
+After that, pythonbrew installs itself to ~/.pythonbrew.
+
+Please add the following line to the end of your ~/.bashrc::
+
+  [[ -s $HOME/.pythonbrew/etc/bashrc ]] && source $HOME/.pythonbrew/etc/bashrc
 
 If you need to install pythonbrew into somewhere else, you can do that by setting a PYTHONBREW_ROOT environment variable::
 
@@ -21,11 +35,22 @@ If you need to install pythonbrew into somewhere else, you can do that by settin
   chmod +x pythonbrewinstall
   ./pythonbrewinstall
 
+For Systemwide(Multi-User) installation
+---------------------------------------
+
+If the install script is run as root, pythonbrew will automatically install into /usr/local/pythonbrew.
+
+The pythonbrew will be automatically configured for every user on the system if you install as root.
+
+After installation, where you would normally use `sudo`, non-root users will need to use `sudopybrew`::
+
+  sudopybrew install -n -v -j2 2.7.2
+
 Usage
 =====
 
 pythonbrew command [options]
-    
+
 Install some pythons::
 
   pythonbrew install 2.7.2
@@ -38,7 +63,7 @@ Install some pythons::
   pythonbrew install /path/to/Python-2.7.2.tgz
   pythonbrew install /path/to/Python-2.7.2
   pythonbrew install 2.7.2 3.2
-  
+
 Permanently use the specified python::
 
   pythonbrew switch 2.7.2
@@ -80,21 +105,23 @@ Upgrades pythonbrew to the latest version::
 Disable pythonbrew::
 
   pythonbrew off
-  
+
 Create/Remove a symbolic link to python (in a directory on your $PATH)::
 
   pythonbrew symlink # Create a symbolic link, like "py2.7.2", for each installed version
   pythonbrew symlink -p 2.7.2
   pythonbrew symlink pip # Create a symbolic link to the specified script in bin directory
   pythonbrew symlink -r # Remove a symbolic link
+  pythonbrew symlink -v foo # Create a symbolic link to the specified virtual environment python in bin directory
 
 Runs the buildout with specified or current using python::
-  
+
   pythonbrew buildout
   pythonbrew buildout -p 2.6.6
 
-Create isolated python environments::
-  
+Create isolated python environments (uses virtualenv)::
+
+  pythonbrew venv init
   pythonbrew venv create proj
   pythonbrew venv list
   pythonbrew venv use proj
@@ -122,10 +149,10 @@ py <python file>
 
 list
   List the installed all pythons.
-  
+
 list -k <version>
   List the available install pythons.
-  
+
 uninstall <version>
   Uninstall the given version of python.
 
@@ -137,21 +164,21 @@ update
 
 off
   Disable pythonbrew.
-  
+
 symlink
   Create/Remove a symbolic link to python (in a directory on your $PATH)
-  
+
 buildout
   Runs the buildout with specified or current using python.
-  
+
 venv
-  Create isolated python environments.
-  
+  Create isolated python environments (uses virtualenv)
+
 version
   Show version.
-  
-See more details below:
-  pythonbrew help <command>
+
+See more details below
+  `pythonbrew help <command>`
 
 LICENCE
 =======

pythonbrew-install

@@ -66,16 +66,23 @@ if [[ $PYTHON_FOUND != '1' ]] ; then
     exit
 fi
 
-ROOT="$HOME/.pythonbrew"
-if [[ -n $PYTHONBREW_ROOT ]] ; then
-    ROOT=$PYTHONBREW_ROOT
+systemwide_install=0
+if [[ -n "$PYTHONBREW_ROOT" ]] ; then
+    ROOT="$PYTHONBREW_ROOT"
+else
+    if (( UID == 0 )) ; then
+        systemwide_install=1
+        ROOT="/usr/local/pythonbrew"
+    else
+        ROOT="$HOME/.pythonbrew"
+    fi
 fi
 PATH_DISTS="$ROOT/dists"
 
 STABLE_VERSION=`curl -skL https://github.com/utahta/pythonbrew/raw/master/stable-version.txt`
 STABLE_VERSION=`trim $STABLE_VERSION`
-if [[ $STABLE_VERSION = "" ]] ; then
-    echo 'Could not get stable-version of pythonbrew.'
+if [[ -z "$STABLE_VERSION" ]] ; then
+    echo 'Can not get stable-version of pythonbrew.'
     exit 1
 fi
 TEMP_FILE="pythonbrew-$STABLE_VERSION"
@@ -93,7 +100,11 @@ echo "Extracting $PATH_DISTS/$TEMP_TARBALL"
 builtin cd $PATH_DISTS ; tar zxf $TEMP_TARBALL
 
 echo "Installing pythonbrew into $ROOT"
-$PYTHON $PATH_DISTS/$TEMP_FILE/pythonbrew_install.py
+if (( systemwide_install == 1 )) ; then
+    PYTHONBREW_ROOT="$ROOT" $PYTHON $PATH_DISTS/$TEMP_FILE/pythonbrew_install.py --systemwide
+else
+    $PYTHON $PATH_DISTS/$TEMP_FILE/pythonbrew_install.py
+fi
 if [[ $? == 1 ]] ; then
     echo "Failed to install pythonbrew."
     exit

pythonbrew/__init__.py

@@ -1,7 +1,14 @@
 import sys
+import os
 from pythonbrew.basecommand import command_dict, load_all_commands
 from pythonbrew.baseparser import parser
 from pythonbrew.log import logger
+from pythonbrew.define import PATH_HOME_ETC
+from pythonbrew.util import makedirs
+
+def init_home():
+    if not os.path.isdir(PATH_HOME_ETC):
+        makedirs(PATH_HOME_ETC)
 
 def main():
     options, args = parser.parse_args(sys.argv[1:])
@@ -10,13 +17,10 @@ def main():
     if not args:
         args = ['help'] # as default
     
+    init_home()
     load_all_commands()
     command = args[0].lower()
     if command not in command_dict:
-        if command == 'clean':
-            # note: for some time
-            logger.info('\nDEPRECATION WARNING: `pythonbrew clean` has been renamed. Please run `pythonbrew cleanup` instead.\n')
-            return
         parser.error("Unknown command: `%s`" % command)
         return
     command = command_dict[command]

pythonbrew/commands/buildout.py

@@ -2,7 +2,7 @@ import os
 import sys
 import subprocess
 from pythonbrew.basecommand import Command
-from pythonbrew.define import PATH_PYTHONS, BOOTSTRAP_DLSITE, PATH_DISTS
+from pythonbrew.define import PATH_PYTHONS, BOOTSTRAP_DLSITE
 from pythonbrew.util import Package, get_using_python_pkgname, Link, is_installed
 from pythonbrew.log import logger
 from pythonbrew.downloader import Downloader
@@ -28,7 +28,7 @@ class BuildoutCommand(Command):
         else:
             pkgname = get_using_python_pkgname()
         if not is_installed(pkgname):
-            logger.info('%s is not installed.' % pkgname)
+            logger.error('`%s` is not installed.' % pkgname)
             sys.exit(1)
         logger.info('Using %s' % pkgname)
         
@@ -38,20 +38,21 @@ class BuildoutCommand(Command):
         # Download bootstrap.py
         download_url = BOOTSTRAP_DLSITE
         filename = Link(download_url).filename
-        bootstrap = os.path.join(PATH_DISTS, filename)
+        bootstrap = os.path.join(os.getcwd(), filename) # fetching into current directory
         try:
             d = Downloader()
             d.download(filename, download_url, bootstrap)
         except:
-            logger.error("Failed to download. `%s`" % download_url)
+            e = sys.exc_info()[1]
+            logger.error("%s" % (e))
             sys.exit(1)
 
-        # Using bootstrap.py
+        # call bootstrap.py
         if subprocess.call([python, bootstrap, '-d']):
             logger.error('Failed to bootstrap.')
             sys.exit(1)
 
-        # Using buildout
+        # call buildout
         subprocess.call(['./bin/buildout'])
 
 BuildoutCommand()

pythonbrew/commands/help.py

@@ -17,11 +17,11 @@ class HelpCommand(Command):
             command.parser.print_help()
             return
         parser.print_help()
-        logger.info("\nCommands available:")
+        logger.log("\nCommands available:")
         commands = [command_dict[key] for key in sorted(command_dict.keys())]
         for command in commands:
-            logger.info("  %s: %s" % (command.name, command.summary))
-        logger.info("\nFurther Instructions:")
-        logger.info("  https://github.com/utahta/pythonbrew")
+            logger.log("  %s: %s" % (command.name, command.summary))
+        logger.log("\nFurther Instructions:")
+        logger.log("  https://github.com/utahta/pythonbrew")
 
 HelpCommand()

pythonbrew/commands/install.py

@@ -1,10 +1,8 @@
+import sys
 from pythonbrew.basecommand import Command
-from pythonbrew.log import logger
 from pythonbrew.installer.pythoninstaller import PythonInstaller,\
     PythonInstallerMacOSX
 from pythonbrew.util import is_macosx
-from pythonbrew.exceptions import UnknownVersionException,\
-    AlreadyInstalledException, NotSupportedVersionException
 
 class InstallCommand(Command):
     name = "install"
@@ -61,24 +59,41 @@ class InstallCommand(Command):
             default=0,
             help="Enable parallel make."
         )
-    
+        self.parser.add_option(
+            "--framework",
+            dest="framework",
+            action="store_true",
+            default=False,
+            help="Build (MacOSX|Darwin) framework."
+        )
+        self.parser.add_option(
+            "--universal",
+            dest="universal",
+            action="store_true",
+            default=False,
+            help="Build for both 32 & 64 bit Intel."
+        )
+        self.parser.add_option(
+            "--static",
+            dest="static",
+            action="store_true",
+            default=False,
+            help="Build static libraries."
+        )
+
     def run_command(self, options, args):
-        if args:
-            # installing python
-            for arg in args:
-                try:
-                    if is_macosx():
-                        p = PythonInstallerMacOSX(arg, options)
-                    else:
-                        p = PythonInstaller(arg, options)
-                    p.install()
-                except UnknownVersionException:
-                    continue
-                except AlreadyInstalledException:
-                    continue
-                except NotSupportedVersionException:
-                    continue
-        else:
-            logger.info("Unknown python version.")
-    
+        if not args:
+            self.parser.print_help()
+            sys.exit(1)
+        # installing python
+        for arg in args:
+            try:
+                if is_macosx():
+                    p = PythonInstallerMacOSX(arg, options)
+                else:
+                    p = PythonInstaller(arg, options)
+                p.install()
+            except:
+                continue
+
 InstallCommand()

pythonbrew/commands/list.py

@@ -3,8 +3,7 @@ import re
 from pythonbrew.basecommand import Command
 from pythonbrew.define import PYTHON_VERSION_URL, LATEST_VERSIONS_OF_PYTHON,\
     PATH_PYTHONS
-from pythonbrew.util import Package, get_using_python_pkgname,\
-    get_using_python_path
+from pythonbrew.util import Package, get_using_python_pkgname
 from pythonbrew.log import logger
 
 class ListCommand(Command):
@@ -36,18 +35,16 @@ class ListCommand(Command):
             self.installed(options, args)
     
     def installed(self, options, args):
-        logger.info('# installed pythons')
+        logger.log("# pythonbrew pythons")
         cur = get_using_python_pkgname()
         for d in sorted(os.listdir(PATH_PYTHONS)):
             if cur and cur == d:
-                logger.info('%s (*)' % d)
+                logger.log('  %s (*)' % d)
             else:
-                logger.info('%s' % d)
-        if not cur:
-            logger.info('%s (*)' % get_using_python_path())
+                logger.log('  %s' % d)
     
     def available_install(self, options, args):
-        logger.info('# available install pythons')
+        logger.log('# Pythons')
         if args:
             pkg = Package(args[0])
             _re = re.compile(r"%s" % pkg.name)
@@ -57,12 +54,12 @@ class ListCommand(Command):
                     pkgs.append(pkgname)
             if pkgs:
                 for pkgname in pkgs:
-                    logger.info("%s" % pkgname)
+                    logger.log("%s" % pkgname)
             else:
-                logger.info("Python version not found. `%s`" % pkg.name)
+                logger.error("`%s` was not found." % pkg.name)
         else:
             for pkgname in self._get_packages_name(options):
-                logger.info("%s" % pkgname)
+                logger.log("%s" % pkgname)
     
     def _get_packages_name(self, options):
         return ["Python-%s" % version for version in sorted(PYTHON_VERSION_URL.keys()) 

pythonbrew/commands/py.py

@@ -32,12 +32,12 @@ class PyCommand(Command):
     
     def run_command(self, options, args):
         if not args:
-            logger.info("Unrecognized command line argument: argument not found.")
+            self.parser.print_help()
             sys.exit(1)
         pythons = self._get_pythons(options.pythons)
         for d in pythons:
             if options.verbose:
-                logger.info('*** %s ***' % d)
+                logger.info('`%s` running...' % d)
             path = os.path.join(PATH_PYTHONS, d, 'bin', args[0])
             if os.path.isfile(path) and os.access(path, os.X_OK):
                 subprocess.call([path] + args[1:])
@@ -46,7 +46,7 @@ class PyCommand(Command):
                 if os.path.isfile(path) and os.access(path, os.X_OK):
                     subprocess.call([path] + args)
                 else:
-                    logger.info('%s: No such file or directory.' % path)
+                    logger.error('%s: No such file or directory.' % path)
     
     def _get_pythons(self, _pythons):
         pythons = [Package(p).name for p in _pythons]

pythonbrew/commands/switch.py

@@ -1,7 +1,7 @@
 import os
 import sys
 from pythonbrew.basecommand import Command
-from pythonbrew.define import PATH_PYTHONS, PATH_BIN
+from pythonbrew.define import PATH_PYTHONS
 from pythonbrew.util import Package, set_current_path, is_installed
 from pythonbrew.log import logger
 
@@ -12,16 +12,16 @@ class SwitchCommand(Command):
     
     def run_command(self, options, args):
         if not args:
-            logger.info("Unrecognized command line argument: argument not found.")
+            self.parser.print_help()
             sys.exit(1)
         pkg = Package(args[0])
         pkgname = pkg.name
         if not is_installed(pkgname):
-            logger.info("`%s` is not installed." % pkgname)
+            logger.error("`%s` is not installed." % pkgname)
             sys.exit(1)
         pkgbin = os.path.join(PATH_PYTHONS,pkgname,'bin')
         
-        set_current_path('%s:%s' % (PATH_BIN, pkgbin))
+        set_current_path(pkgbin)
         
         logger.info("Switched to %s" % pkgname)
 

pythonbrew/commands/symlink.py

@@ -1,7 +1,9 @@
 import os
+import sys
 from pythonbrew.basecommand import Command
-from pythonbrew.define import PATH_PYTHONS, PATH_BIN
-from pythonbrew.util import Package, symlink, unlink
+from pythonbrew.define import PATH_PYTHONS, PATH_BIN, PATH_VENVS
+from pythonbrew.util import Package, symlink, unlink, get_using_python_pkgname,\
+    is_installed
 from pythonbrew.log import logger
 
 class SymlinkCommand(Command):
@@ -32,6 +34,12 @@ class SymlinkCommand(Command):
             default=None,
             help="Use as default the specified python version."
         )
+        self.parser.add_option(
+            "-v", "--venv",
+            dest="venv",
+            default=None,
+            help="Use the virtual environment python."
+        )
     
     def run_command(self, options, args):
         if options.default:
@@ -43,6 +51,28 @@ class SymlinkCommand(Command):
                     self._symlink(bin, bin, pkgname)
                 else:
                     self._symlink('python', 'py', pkgname)
+        elif options.venv:
+            if options.pythons:
+                pkgname = Package(options.pythons[0]).name
+            else:
+                pkgname = get_using_python_pkgname()
+            if not is_installed(pkgname):
+                logger.error('`%s` is not installed.')
+                sys.exit(1)
+            
+            venv_pkgdir = os.path.join(PATH_VENVS, pkgname)
+            venv_dir = os.path.join(venv_pkgdir, options.venv)
+            if not os.path.isdir(venv_dir):
+                logger.error("`%s` environment was not found in %s." % (options.venv, venv_pkgdir))
+                sys.exit(1)
+            pkg = Package(pkgname)
+            if args:
+                bin = args[0]
+                dstbin = '%s%s-%s' % (bin, pkg.version, options.venv)
+                self._symlink(bin, dstbin, pkgname)
+            else:
+                dstbin = 'py%s-%s' % (pkg.version, options.venv)
+                self._symlink('python', dstbin, pkgname)
         else:
             pythons = self._get_pythons(options.pythons)
             for pkgname in pythons:
@@ -75,7 +105,7 @@ class SymlinkCommand(Command):
         if os.path.isfile(src):
             symlink(src, dst)
         else:
-            logger.info("%s: File not found" % src)
+            logger.error("%s was not found in your path." % src)
     
     def _get_pythons(self, _pythons):
         """Get the installed python versions list.

pythonbrew/commands/uninstall.py

@@ -19,7 +19,7 @@ class UninstallCommand(Command):
                 pkgpath = os.path.join(PATH_PYTHONS, pkgname)
                 venvpath = os.path.join(PATH_VENVS, pkgname)
                 if not is_installed(pkgname):
-                    logger.info("`%s` is not installed." % pkgname)
+                    logger.error("`%s` is not installed." % pkgname)
                     continue
                 if get_using_python_pkgname() == pkgname:
                     off()

pythonbrew/commands/update.py

@@ -6,7 +6,7 @@ from pythonbrew.define import PATH_DISTS, VERSION, ROOT,\
 from pythonbrew.log import logger
 from pythonbrew.downloader import Downloader, get_pythonbrew_update_url,\
     get_stable_version, get_headerinfo_from_url
-from pythonbrew.util import rm_r, extract_downloadfile, Link, is_gzip, Subprocess
+from pythonbrew.util import rm_r, extract_downloadfile, Link, is_gzip, Subprocess, Version
 
 class UpdateCommand(Command):
     name = "update"
@@ -65,7 +65,7 @@ class UpdateCommand(Command):
         except:
             logger.error("Failed to download. `%s`" % download_url)
             sys.exit(1)
-        logger.info("The config.cfg has been updated.")
+        logger.log("The config.cfg has been updated.")
     
     def _update_pythonbrew(self, options, args):
         if options.master:
@@ -75,13 +75,13 @@ class UpdateCommand(Command):
         else:
             version = get_stable_version()
             # check for version
-            if not options.force and version <= VERSION:
+            if not options.force and Version(version) <= VERSION:
                 logger.info("You are already running the installed latest version of pythonbrew.")
                 return
         
         download_url = get_pythonbrew_update_url(version)
         if not download_url:
-            logger.error("`%s` of pythonbrew not found." % version)
+            logger.error("`pythonbrew-%s` was not found in pypi." % version)
             sys.exit(1)
         headinfo = get_headerinfo_from_url(download_url)
         content_type = headinfo['content-type']

pythonbrew/commands/use.py

@@ -1,7 +1,7 @@
 import os
 import sys
 from pythonbrew.basecommand import Command
-from pythonbrew.define import PATH_PYTHONS, PATH_BIN, PATH_ETC_TEMP
+from pythonbrew.define import PATH_PYTHONS, PATH_HOME_ETC_TEMP
 from pythonbrew.util import Package
 from pythonbrew.log import logger
 
@@ -12,24 +12,23 @@ class UseCommand(Command):
     
     def run_command(self, options, args):
         if not args:
-            logger.info("Unrecognized command line argument: argument not found.")
+            self.parser.print_help()
             sys.exit(1)
         pkg = Package(args[0])
         pkgname = pkg.name
         pkgdir = os.path.join(PATH_PYTHONS, pkgname)
         if not os.path.isdir(pkgdir):
-            logger.info("`%s` is not installed." % pkgname)
+            logger.error("`%s` is not installed." % pkgname)
             sys.exit(1)
         pkgbin = os.path.join(pkgdir,'bin')
         
-        self._set_temp('%s:%s' % (PATH_BIN, pkgbin))
+        self._set_temp(pkgbin)
         
         logger.info("Using `%s`" % pkgname)
 
     def _set_temp(self, path):
-        fp = open(PATH_ETC_TEMP, 'w')
-        fp.write('PATH_PYTHONBREW="%s"\n' % (path))
+        fp = open(PATH_HOME_ETC_TEMP, 'w')
+        fp.write('PATH_PYTHONBREW_TEMP="%s"\n' % (path))
         fp.close()
 
-
 UseCommand()

pythonbrew/commands/venv.py

@@ -1,10 +1,13 @@
 import os
 import sys
 from pythonbrew.basecommand import Command
-from pythonbrew.define import PATH_PYTHONS, PATH_VENVS, PATH_ETC_VENV
-from pythonbrew.util import Subprocess, Package,\
-    is_installed, get_installed_pythons_pkgname, get_using_python_pkgname
+from pythonbrew.define import PATH_PYTHONS, PATH_VENVS, PATH_HOME_ETC_VENV,\
+    PATH_ETC, VIRTUALENV_DLSITE, PATH_DISTS
+from pythonbrew.util import Package, \
+    is_installed, get_installed_pythons_pkgname, get_using_python_pkgname,\
+    untar_file, Subprocess, rm_r
 from pythonbrew.log import logger
+from pythonbrew.downloader import Downloader
 
 class VenvCommand(Command):
     name = "venv"
@@ -26,38 +29,30 @@ class VenvCommand(Command):
             action='store_true',
             default=False,
             help="Show the all python environments.",
-            metavar='VERSION'
         )
-        self.template_env = """export VIRTUALENVWRAPPER_PYTHON=%(venv_py)s
-export VIRTUALENVWRAPPER_VIRTUALENV=%(venv_venv)s
-export WORKON_HOME=%(workon_home)s
-export VIRTUALENVWRAPPER_HOOK_DIR=%(workon_home)s
-export VIRTUALENVWRAPPER_LOG_DIR=%(workon_home)s
-source %(venv_sh)s
-"""
-    
+        self.parser.add_option(
+            "-n", "--no-site-packages",
+            dest="no_site_packages",
+            action='store_true',
+            default=False,
+            help="Don't give access to the global site-packages dir to the virtual environment.",
+        )
+        self._venv_dir = os.path.join(PATH_ETC, 'virtualenv')
+        self._venv = os.path.join(self._venv_dir, 'virtualenv.py')
+        
     def run_command(self, options, args):
         if not args:
-            logger.error('Unrecognized command line argument: ( see: \'pythonbrew help venv\' )')
+            self.parser.print_help()
             sys.exit(1)
         cmd = args[0]
-        if not cmd in ('create', 'delete', 'use', 'list'):
-            logger.error('Unrecognized command line argument: ( see: \'pythonbrew help venv\' )')
+        if not cmd in ('init', 'create', 'delete', 'use', 'list'):
+            self.parser.print_help()
             sys.exit(1)
         
-        # find python2
-        venv_pkgname = None
-        for pkgname in reversed(get_installed_pythons_pkgname()):
-            # virtualenvwrapper require Python2
-            venv_pkgver = Package(pkgname).version
-            if venv_pkgver >= '2.4' and venv_pkgver < '3':
-                venv_pkgname = pkgname
-                break
-        if not venv_pkgname:
-            logger.error('Can not create virtual environment before installing a python2.  Try \'pythonbrew install <python2.4 - 2.7>\'.')
-            sys.exit(1)
-        venv_dir = os.path.join(PATH_PYTHONS, venv_pkgname)
-        venv_bin = os.path.join(venv_dir, 'bin')
+        # initialize?
+        if cmd == 'init':
+            self.run_command_init()
+            return
         
         # target python interpreter
         if options.python:
@@ -66,92 +61,103 @@ source %(venv_sh)s
                 logger.error('%s is not installed.' % pkgname)
                 sys.exit(1)
         else:
+            # check using python under pythonbrew
             pkgname = get_using_python_pkgname()
             if not pkgname:
-                logger.error('Can not use venv command before using a python.  Try \'pythonbrew switch <some python>\'.')
+                logger.error('Can not use venv command before switching a python.  Try \'pythonbrew switch <version of python>\'.')
                 sys.exit(1)
         self._pkgname = pkgname
         self._target_py = os.path.join(PATH_PYTHONS, pkgname, 'bin', 'python')
         self._workon_home = os.path.join(PATH_VENVS, pkgname)
-        self._venv_py = os.path.join(venv_bin, 'python')
-        self._venv_venv = os.path.join(venv_bin, 'virtualenv')
-        self._venv_sh = os.path.join(venv_bin, 'virtualenvwrapper.sh')
+        self._py = os.path.join(PATH_PYTHONS, pkgname, 'bin', 'python')
         
-        # has virtualenv & virtualenvwrapper?
-        if not self._venv_venv or not self._venv_sh:
-            logger.info('Installing virtualenv into %s' % venv_dir)
-            s = Subprocess(verbose=True)
-            s.shell('%s %s %s' % (os.path.join(venv_bin,'pip'), 'install', 'virtualenvwrapper'))
+        # is already installed virtualenv?
+        if not os.path.exists(self._venv):
+            self.run_command_init()
         
         # Create a shell script
-        try:
-            self.__getattribute__('run_command_%s' % cmd)(options, args)
-        except:
-            logger.error('`%s` command not found.' % cmd)
+        self.__getattribute__('run_command_%s' % cmd)(options, args)
+    
+    def run_command_init(self):
+        if os.path.exists(self._venv):
+            logger.info('venv command is already initialized.')
+            return
+        if not os.access(PATH_DISTS, os.W_OK):
+            logger.error("Can not initialize venv command: Permission denied.")
             sys.exit(1)
+        d = Downloader()
+        download_file = os.path.join(PATH_DISTS, 'virtualenv.tar.gz')
+        d.download('virtualenv.tar.gz', VIRTUALENV_DLSITE, download_file)
+        logger.info('Extracting virtualenv into %s' % self._venv_dir)
+        untar_file(download_file, self._venv_dir)
     
     def run_command_create(self, options, args):
-        output = [self.template_env % {'venv_py': self._venv_py,
-                                       'venv_venv': self._venv_venv,
-                                       'workon_home': self._workon_home,
-                                       'venv_sh': self._venv_sh}]
+        if not os.access(PATH_VENVS, os.W_OK):
+            logger.error("Can not create a virtuale environment in %s.\nPermission denied." % PATH_VENVS)
+            sys.exit(1)
+
+        virtualenv_options = []
+        if options.no_site_packages:
+            virtualenv_options.append('--no-site-packages')
+        
         for arg in args[1:]:
-            output.append("""echo '# Create `%(arg)s` environment into %(workon_home)s'
-mkvirtualenv -p '%(target_py)s' '%(arg)s'
-""" % {'arg': arg,
-       'workon_home': self._workon_home,
-       'target_py': self._target_py})
-        self._write(''.join(output))
+            target_dir = os.path.join(self._workon_home, arg)
+            logger.info("Creating `%s` environment into %s" % (arg, self._workon_home))
+            # make command
+            cmd = [self._py, self._venv, '-p', self._target_py]
+            cmd.extend(virtualenv_options)
+            cmd.append(target_dir)
+            # create environment
+            s = Subprocess(verbose=True)
+            s.call(cmd)
         
     def run_command_delete(self, options, args):
-        output = [self.template_env % {'venv_py': self._venv_py, 
-                                       'venv_venv': self._venv_venv,
-                                       'workon_home': self._workon_home,
-                                       'venv_sh': self._venv_sh}]
         for arg in args[1:]:
-            output.append("""echo '# Delete `%(arg)s` environment in %(workon_home)s'
-rmvirtualenv '%(arg)s'
-""" % {'arg': arg,
-       'workon_home': self._workon_home})
-        self._write(''.join(output))
+            target_dir = os.path.join(self._workon_home, arg)
+            if not os.path.isdir(target_dir):
+                logger.error('%s already does not exist.' % target_dir)
+            else:
+                if not os.access(target_dir, os.W_OK):
+                    logger.error("Can not delete %s.\nPermission denied." % target_dir)
+                    continue
+                logger.info('Deleting `%s` environment in %s' % (arg, self._workon_home))
+                # make command
+                rm_r(target_dir)
     
     def run_command_use(self, options, args):
         if len(args) < 2:
             logger.error("Unrecognized command line argument: ( 'pythonbrew venv use <project>' )")
             sys.exit(1)
-        template = self.template_env + """echo '# Using `%(arg)s` environment (found in %(workon_home)s)'
+        
+        activate = os.path.join(self._workon_home, args[1], 'bin', 'activate')
+        if not os.path.exists(activate):
+            logger.error('`%s` environment already does not exist. Try `pythonbrew venv create %s`.' % (args[1], args[1]))
+            sys.exit(1)
+        
+        self._write("""\
+echo '# Using `%(arg)s` environment (found in %(workon_home)s)'
 echo '# To leave an environment, simply run `deactivate`'
-workon '%(arg)s'
-"""
-        self._write(template % {'venv_py': self._venv_py, 
-                                'venv_venv': self._venv_venv,
-                                'workon_home': self._workon_home,
-                                'venv_sh': self._venv_sh,
-                                'arg': args[1]})
-    
+source '%(activate)s'
+""" % {'arg': args[1], 'workon_home': self._workon_home, 'activate': activate})
+        
     def run_command_list(self, options, args):
-        template = self.template_env + """echo '# virtualenv for %(pkgname)s (found in %(workon_home)s)'
-workon
-"""
         if options.all:
-            output = []
             for pkgname in get_installed_pythons_pkgname():
                 workon_home = os.path.join(PATH_VENVS, pkgname)
-                output.append(template % {'venv_py': self._venv_py,
-                                          'venv_venv': self._venv_venv,
-                                          'workon_home': workon_home,
-                                          'venv_sh': self._venv_sh,
-                                          'pkgname': pkgname})
-            self._write(''.join(output))
+                logger.log("# virtualenv for %(pkgname)s (found in %(workon_home)s)" % {'pkgname': pkgname, 'workon_home': workon_home})
+                if os.path.isdir(workon_home):
+                    for d in sorted(os.listdir(workon_home)):
+                        if os.path.isdir(os.path.join(workon_home, d)):
+                            logger.log(d)
         else:
-            self._write(template % {'venv_py': self._venv_py, 
-                                    'venv_venv': self._venv_venv,
-                                    'workon_home': self._workon_home,
-                                    'venv_sh': self._venv_sh,
-                                    'pkgname': self._pkgname})
+            logger.log("# virtualenv for %(pkgname)s (found in %(workon_home)s)" % {'pkgname': self._pkgname, 'workon_home': self._workon_home})
+            if os.path.isdir(self._workon_home):
+                for d in sorted(os.listdir(self._workon_home)):
+                    if os.path.isdir(os.path.join(self._workon_home, d)):
+                        logger.log(d)
     
     def _write(self, src):
-        fp = open(PATH_ETC_VENV, 'w')
+        fp = open(PATH_HOME_ETC_VENV, 'w')
         fp.write(src)
         fp.close()
     

pythonbrew/commands/version.py

@@ -8,6 +8,6 @@ class VersionCommand(Command):
     summary = "Show version"
     
     def run_command(self, options, args):
-        logger.info(VERSION)
+        logger.log(VERSION)
 
 VersionCommand()

pythonbrew/curl.py

@@ -4,26 +4,27 @@ import subprocess
 from subprocess import Popen, PIPE
 from pythonbrew.log import logger
 from pythonbrew.util import to_str
+from pythonbrew.exceptions import CurlFetchException
 
 class Curl(object):
     def __init__(self):
         returncode = subprocess.call("command -v curl > /dev/null", shell=True)
         if returncode:
-            logger.info("pythonbrew required curl. curl was not found in your path.")
+            logger.log("pythonbrew required curl. curl was not found in your path.")
             sys.exit(1)
     
     def read(self, url):
         p = Popen("curl -skL %s" % url, stdout=PIPE, shell=True)
         p.wait()
         if p.returncode:
-            raise
+            raise Exception('Failed to read.')
         return p.stdout.read()
     
     def readheader(self, url):
         p = Popen("curl --head -skL %s" % url, stdout=PIPE, shell=True)
         p.wait()
         if p.returncode:
-            raise
+            raise Exception('Failed to readheader.')
         respinfo = {}
         for line in p.stdout:
             line = to_str(line.strip())
@@ -39,4 +40,4 @@ class Curl(object):
         p = Popen("curl -# -kL %s -o %s" % (url, filename), shell=True)
         p.wait()
         if p.returncode:
-            raise
+            raise CurlFetchException('Failed to fetch.')

pythonbrew/define.py

@@ -6,16 +6,17 @@ except:
     import configparser as ConfigParser
 
 # pythonbrew version
-VERSION = "0.9"
+VERSION = "1.1"
 
+# pythonbrew installer root path
+INSTALLER_ROOT = os.path.dirname(os.path.abspath(__file__))
+
+# Root
 # pythonbrew root path
 ROOT = os.environ.get("PYTHONBREW_ROOT")
 if not ROOT:
     ROOT = os.path.join(os.environ["HOME"],".pythonbrew")
 
-# pythonbrew installer root path
-INSTALLER_ROOT = os.path.dirname(os.path.abspath(__file__))
-
 # directories
 PATH_PYTHONS = os.path.join(ROOT,"pythons")
 PATH_BUILD = os.path.join(ROOT,"build")
@@ -38,10 +39,21 @@ PATH_PATCHES_MACOSX_PYTHON24 = os.path.join(PATH_PATCHES_MACOSX,"python24")
 
 # files
 PATH_BIN_PYTHONBREW = os.path.join(PATH_BIN,'pythonbrew')
-PATH_ETC_CURRENT = os.path.join(PATH_ETC,'current')
-PATH_ETC_TEMP = os.path.join(PATH_ETC,'temp')
 PATH_ETC_CONFIG = os.path.join(PATH_ETC,'config.cfg')
-PATH_ETC_VENV = os.path.join(PATH_ETC, 'venv.run')
+
+# Home
+# pythonbrew home path
+PATH_HOME = os.environ.get('PYTHONBREW_HOME')
+if not PATH_HOME:
+    PATH_HOME = os.path.join(os.environ["HOME"],".pythonbrew")
+
+# directories
+PATH_HOME_ETC = os.path.join(PATH_HOME, 'etc')
+
+# files
+PATH_HOME_ETC_VENV = os.path.join(PATH_HOME_ETC, 'venv.run')
+PATH_HOME_ETC_CURRENT = os.path.join(PATH_HOME_ETC,'current')
+PATH_HOME_ETC_TEMP = os.path.join(PATH_HOME_ETC,'temp')
 
 # read config.cfg
 config = ConfigParser.SafeConfigParser()
@@ -58,6 +70,9 @@ DISTRIBUTE_SETUP_DLSITE = _get_or_default('distribute', 'url')
 # buildout bootstrap download
 BOOTSTRAP_DLSITE = _get_or_default('bootstrap', 'url')
 
+# virtualenv download
+VIRTUALENV_DLSITE = _get_or_default('virtualenv', 'url')
+
 # pythonbrew download
 PYTHONBREW_UPDATE_URL_MASTER = _get_or_default('pythonbrew', 'master')
 PYTHONBREW_UPDATE_URL_DEVELOP = _get_or_default('pythonbrew', 'develop')

pythonbrew/etc/bashrc

@@ -1,6 +1,20 @@
-PATH_ROOT="@ROOT@"
+# settings
+PATH_ROOT="$PYTHONBREW_ROOT"
+if [ -z "${PATH_ROOT}" ] ; then
+    PATH_ROOT="$HOME/.pythonbrew"
+fi
 PATH_ETC="$PATH_ROOT/etc"
 
+PATH_HOME="$PYTHONBREW_HOME"
+if [ -z "${PATH_HOME}" ] ; then
+    PATH_HOME="$HOME/.pythonbrew"
+fi
+PATH_HOME_ETC="$PATH_HOME/etc"
+
+# py file
+PY_PYTHONBREW="$PATH_ROOT/bin/pythonbrew"
+
+# functions
 __pythonbrew_set_default()
 {
     PATH_PYTHONBREW="$PATH_ROOT/bin"
@@ -14,8 +28,9 @@ __pythonbrew_set_path()
 
 __pythonbrew_set_temp_path()
 {
-    if [[ -s "$PATH_ETC/temp" ]] ; then
-        source "$PATH_ETC/temp"
+    if [[ -s "$PATH_HOME_ETC/temp" ]] ; then
+        source "$PATH_HOME_ETC/temp"
+        PATH_PYTHONBREW="$PATH_ROOT/bin:$PATH_PYTHONBREW_TEMP"
     else
         __pythonbrew_set_default
     fi
@@ -24,8 +39,9 @@ __pythonbrew_set_temp_path()
 
 __pythonbrew_set_current_path()
 {
-    if [[ -s "$PATH_ETC/current" ]] ; then
-        source "$PATH_ETC/current"
+    if [[ -s "$PATH_HOME_ETC/current" ]] ; then
+        source "$PATH_HOME_ETC/current"
+        PATH_PYTHONBREW="$PATH_ROOT/bin:$PATH_PYTHONBREW_CURRENT"
     else
         __pythonbrew_set_default
     fi
@@ -39,35 +55,35 @@ __pythonbrew_reload()
 
 __pythonbrew_use()
 {
-    command pythonbrew "$@"
+    $pythonbrew "$@"
     [[ $? == 0 ]] && __pythonbrew_set_temp_path
 }
 
 __pythonbrew_switch()
 {
-    command pythonbrew "$@"
+    $pythonbrew "$@"
     [[ $? == 0 ]] && __pythonbrew_set_current_path
 }
 
 __pythonbrew_off()
 {
-    command pythonbrew "$@"
+    $pythonbrew "$@"
     [[ $? == 0 ]] && __pythonbrew_set_current_path
 }
 
 __pythonbrew_update()
 {
-    command pythonbrew "$@"
+    $pythonbrew "$@"
     [[ $? == 0 ]] && __pythonbrew_reload
 }
 
 __pythonbrew_venv()
 {
-    command pythonbrew "$@"
+    $pythonbrew "$@"
     if [[ $? == 0 ]] ; then
-        if [[ -s "$PATH_ETC/venv.run" ]] ; then
-            source "$PATH_ETC/venv.run"
-            cat /dev/null > "$PATH_ETC/venv.run"
+        if [[ -s "$PATH_HOME_ETC/venv.run" ]] ; then
+            source "$PATH_HOME_ETC/venv.run"
+            cat /dev/null > "$PATH_HOME_ETC/venv.run"
         fi
     fi
 }
@@ -87,7 +103,7 @@ __pythonbrew_find_command()
     done
 }
 
-pythonbrew()
+__pythonbrew_run()
 {
     __pythonbrew_find_command "$@"
     case $command_name in
@@ -96,15 +112,27 @@ pythonbrew()
         off) __pythonbrew_off "$@" ;;
         update) __pythonbrew_update "$@" ;;
         venv) __pythonbrew_venv "$@" ;;
-        *) command pythonbrew "$@" ;;
+        *) $pythonbrew "$@" ;;
     esac
     builtin hash -r
 }
 
+pythonbrew()
+{
+    pythonbrew=$PY_PYTHONBREW
+    __pythonbrew_run "$@"
+}
+
 pybrew()
 {
     pythonbrew "$@"
 }
 
+sudopybrew()
+{
+    pythonbrew="sudo PYTHONBREW_ROOT=$PATH_ROOT PATH=$PATH_PYTHONBREW:$PATH_WITHOUT_PYTHONBREW $PY_PYTHONBREW"
+    __pythonbrew_run "$@"
+}
+
 # main
 __pythonbrew_set_current_path

pythonbrew/etc/config.cfg

@@ -4,6 +4,9 @@ url = http://python-distribute.org/distribute_setup.py
 [bootstrap]
 url = http://svn.zope.org/*checkout*/zc.buildout/trunk/bootstrap/bootstrap.py
 
+[virtualenv]
+url = http://pypi.python.org/packages/source/v/virtualenv/virtualenv-1.6.4.tar.gz
+
 [pythonbrew]
 master = https://github.com/utahta/pythonbrew/tarball/master
 develop = https://github.com/utahta/pythonbrew/tarball/develop
@@ -178,5 +181,7 @@ latest = True
 
 [Python-3.2]
 url = http://www.python.org/ftp/python/3.2/Python-3.2.tgz
-latest = True
 
+[Python-3.2.1]
+url = http://www.python.org/ftp/python/3.2.1/Python-3.2.1.tgz
+latest = True

pythonbrew/exceptions.py

@@ -11,4 +11,6 @@ class AlreadyInstalledException(Exception):
     """General exception during installing"""
 class NotSupportedVersionException(Exception):
     """General exception during installing"""
-    
+    
+class CurlFetchException(Exception):
+    """Exception curl during fetching"""

pythonbrew/installer/__init__.py

@@ -3,10 +3,10 @@ from pythonbrew.log import logger
 from pythonbrew.define import INSTALLER_ROOT, ROOT, PATH_ETC
 
 def install_pythonbrew():
-    PythonbrewInstaller().install(INSTALLER_ROOT)
-    # pythonbrew is only for bash
+    PythonbrewInstaller.install(INSTALLER_ROOT)
+    # for bash
     shrc = yourshrc = "bashrc"
-    logger.info("""
+    logger.log("""
 Well-done! Congratulations!
 
 The pythonbrew is installed as:
@@ -33,4 +33,30 @@ Enjoy pythonbrew at %(ROOT)s!!
 """ % {'ROOT':ROOT, 'yourshrc':yourshrc, 'shrc':shrc, 'PATH_ETC':PATH_ETC})
 
 def upgrade_pythonbrew():
-    PythonbrewInstaller().install(INSTALLER_ROOT)
+    PythonbrewInstaller.install(INSTALLER_ROOT)
+
+def systemwide_pythonbrew():
+    PythonbrewInstaller.install(INSTALLER_ROOT)
+    PythonbrewInstaller.systemwide_install()
+    logger.log("""
+Well-done! Congratulations!
+
+The pythonbrew is installed as:
+    
+  %(ROOT)s
+
+After that, exit this shell, start a new one, and install some fresh
+pythons:
+
+  pythonbrew install 2.7.2
+  pythonbrew install 3.2
+
+For further instructions, run:
+
+  pythonbrew help
+
+The default help messages will popup and tell you what to do!
+
+Enjoy pythonbrew at %(ROOT)s!!
+""" % {'ROOT':ROOT})
+        

pythonbrew/installer/pythonbrewinstaller.py

@@ -6,15 +6,17 @@ from pythonbrew.util import makedirs, rm_r
 from pythonbrew.define import PATH_BUILD, PATH_BIN, PATH_DISTS, PATH_PYTHONS,\
     PATH_ETC, PATH_SCRIPTS, PATH_SCRIPTS_PYTHONBREW,\
     PATH_SCRIPTS_PYTHONBREW_COMMANDS, PATH_BIN_PYTHONBREW,\
-    ROOT, PATH_LOG, PATH_PATCHES, PATH_ETC_CONFIG,\
-    PATH_SCRIPTS_PYTHONBREW_INSTALLER, PATH_VENVS
+    PATH_LOG, PATH_PATCHES, PATH_ETC_CONFIG,\
+    PATH_SCRIPTS_PYTHONBREW_INSTALLER, PATH_VENVS, PATH_HOME_ETC, ROOT
 import stat
+import time
 
 class PythonbrewInstaller(object):
     """pythonbrew installer:
     """
     
-    def install(self, installer_root):
+    @staticmethod
+    def install(installer_root):
         # create directories
         makedirs(PATH_PYTHONS)
         makedirs(PATH_BUILD)
@@ -23,6 +25,7 @@ class PythonbrewInstaller(object):
         makedirs(PATH_BIN)
         makedirs(PATH_LOG)
         makedirs(PATH_VENVS)
+        makedirs(PATH_HOME_ETC)
         
         # create script directories
         rm_r(PATH_SCRIPTS)
@@ -61,12 +64,46 @@ if __name__ == "__main__":
         os.chmod(PATH_BIN_PYTHONBREW, stat.S_IRUSR|stat.S_IWUSR|stat.S_IXUSR|stat.S_IRGRP|stat.S_IXGRP|stat.S_IROTH|stat.S_IXOTH)
         
         # create a bashrc for pythonbrew
-        fp = open(os.path.join(PATH_ETC,'bashrc'), 'w')
-        for line in open(os.path.join(installer_root,'etc','bashrc')):
-            line = line.replace('@ROOT@', ROOT)
-            fp.write(line)
-        fp.close()
+        shutil.copy(os.path.join(installer_root,'etc','bashrc'), os.path.join(PATH_ETC,'bashrc'))
         
         # copy config.cfg
         shutil.copy(os.path.join(installer_root,'etc','config.cfg'), PATH_ETC_CONFIG)
-
+    
+    @staticmethod
+    def systemwide_install():
+        profile = """\
+#begin-pythonbrew
+if [ -n "${BASH_VERSION:-}" -o -n "${ZSH_VERSION:-}" ] ; then
+    export PYTHONBREW_ROOT=%(root)s
+    source "${PYTHONBREW_ROOT}/etc/bashrc"
+fi
+#end-pythonbrew
+""" % {'root': ROOT}
+        
+        if os.path.isdir('/etc/profile.d'):
+            fp = open('/etc/profile.d/pythonbrew.sh', 'w')
+            fp.write(profile)
+            fp.close()
+        elif os.path.isfile('/etc/profile'):
+            # create backup
+            shutil.copy('/etc/profile', '/tmp/profile.pythonbrew.%s' % int(time.time()))
+            
+            output = []
+            is_copy = True
+            fp = open('/etc/profile', 'r')
+            for line in fp:
+                if line.startswith('#begin-pythonbrew'):
+                    is_copy = False
+                    continue
+                elif line.startswith('#end-pythonbrew'):
+                    is_copy = True
+                    continue
+                if is_copy:
+                    output.append(line)
+            fp.close()
+            output.append(profile)
+            
+            fp = open('/etc/profile', 'w')
+            fp.write(''.join(output))
+            fp.close()
+        

pythonbrew/installer/pythoninstaller.py

@@ -2,12 +2,13 @@ import os
 import sys
 import shutil
 import mimetypes
+import re
 from pythonbrew.util import makedirs, symlink, Package, is_url, Link,\
     unlink, is_html, Subprocess, rm_r,\
     is_python25, is_python24, is_python26, is_python27,\
     extract_downloadfile, is_archive_file, path_to_fileurl, is_file,\
     fileurl_to_path, is_python30, is_python31, is_python32,\
-    get_macosx_deployment_target
+    get_macosx_deployment_target, Version
 from pythonbrew.define import PATH_BUILD, PATH_DISTS, PATH_PYTHONS,\
     ROOT, PATH_LOG, DISTRIBUTE_SETUP_DLSITE,\
     PATH_PATCHES_MACOSX_PYTHON25, PATH_PATCHES_MACOSX_PYTHON24,\
@@ -16,7 +17,7 @@ from pythonbrew.downloader import get_python_version_url, Downloader,\
     get_headerinfo_from_url
 from pythonbrew.log import logger
 from pythonbrew.exceptions import UnknownVersionException,\
-    AlreadyInstalledException, NotSupportedVersionException
+    NotSupportedVersionException
 
 class PythonInstaller(object):
     """Python installer
@@ -38,18 +39,28 @@ class PythonInstaller(object):
             pkg = Package(name, options.alias)
             self.download_url = get_python_version_url(pkg.version)
             if not self.download_url:
-                logger.info("Unknown python version: `%s`" % pkg.name)
+                logger.error("Unknown python version: `%s`" % pkg.name)
                 raise UnknownVersionException
             filename = Link(self.download_url).filename
         self.pkg = pkg
         self.install_dir = os.path.join(PATH_PYTHONS, pkg.name)
         self.build_dir = os.path.join(PATH_BUILD, pkg.name)
         self.download_file = os.path.join(PATH_DISTS, filename)
-        
+
+        self.options = options
+        self.logfile = os.path.join(PATH_LOG, 'build.log')
+        self.patches = []
+
+        if Version(self.pkg.version) >= '3.1':
+            self.configure_options = ['--with-computed-gotos']
+        else:
+            self.configure_options = []
+
+    def install(self):
         # cleanup
         if os.path.isdir(self.build_dir):
             shutil.rmtree(self.build_dir)
-        
+
         # get content type.
         if is_file(self.download_url):
             path = fileurl_to_path(self.download_url)
@@ -61,16 +72,11 @@ class PythonInstaller(object):
             # note: maybe got 404 or 503 http status code.
             logger.error("Invalid content-type: `%s`" % self.content_type)
             return
-        
-        self.options = options
-        self.logfile = os.path.join(PATH_LOG, 'build.log')
-        self.configure_options = ''
-        self.patches = []
 
-    def install(self):
         if os.path.isdir(self.install_dir):
             logger.info("You are already installed `%s`" % self.pkg.name)
-            raise AlreadyInstalledException
+            return
+        
         self.download_and_extract()
         logger.info("\nThis could take a while. You can run the following command on another shell to track the status:")
         logger.info("  tail -f %s\n" % self.logfile)
@@ -83,11 +89,11 @@ class PythonInstaller(object):
         except:
             rm_r(self.install_dir)
             logger.error("Failed to install %s. See %s to see why." % (self.pkg.name, self.logfile))
-            logger.info("  pythonbrew install --force %s" % self.pkg.version)
+            logger.log("  pythonbrew install --force %s" % self.pkg.version)
             sys.exit(1)
         self.symlink()
         self.install_setuptools()
-        logger.info("Installed %(pkgname)s successfully. Run the following command to switch to %(pkgname)s."
+        logger.info("\nInstalled %(pkgname)s successfully. Run the following command to switch to %(pkgname)s."
                     % {"pkgname":self.pkg.name})
         logger.info("  pythonbrew switch %s" % self.pkg.alias)
     
@@ -107,14 +113,14 @@ class PythonInstaller(object):
                 dl.download(base_url, self.download_url, self.download_file)
             except:
                 unlink(self.download_file)
-                logger.info("\nInterrupt to abort. `%s`" % (self.download_url))
+                logger.error("Failed to download.\n%s" % (sys.exc_info()[1]))
                 sys.exit(1)
         # extracting
         if not extract_downloadfile(self.content_type, self.download_file, self.build_dir):
             sys.exit(1)
 
     def patch(self):
-        version = self.pkg.version
+        version = Version(self.pkg.version)
         # for ubuntu 11.04(Natty)
         if is_python24(version):
             patch_dir = os.path.join(PATH_PATCHES_ALL, "python24")
@@ -154,7 +160,7 @@ class PythonInstaller(object):
                     else:
                         s.shell("patch -p0 < %s" % patch)
         except:
-            logger.error("Failed to patch `%s`" % self.build_dir)
+            logger.error("Failed to patch `%s`.\n%s" % (self.build_dir, sys.exc_info()[1]))
             sys.exit(1)
     
     def _add_patches_to_list(self, patch_dir, patch_files):
@@ -170,7 +176,10 @@ class PythonInstaller(object):
     
     def configure(self):
         s = Subprocess(log=self.logfile, cwd=self.build_dir, verbose=self.options.verbose)
-        s.check_call("./configure --prefix=%s %s %s" % (self.install_dir, self.options.configure, self.configure_options))
+        cmd = "./configure --prefix=%s %s %s" % (self.install_dir, self.options.configure, ' '.join(self.configure_options))
+        if self.options.verbose:
+            logger.log(cmd)
+        s.check_call(cmd)
 
     def make(self):
         jobs = self.options.jobs
@@ -185,7 +194,7 @@ class PythonInstaller(object):
                 s.check_call("make test")
 
     def make_install(self):
-        version = self.pkg.version
+        version = Version(self.pkg.version)
         if version == "1.5.2" or version == "1.6.1":
             makedirs(self.install_dir)
         s = Subprocess(log=self.logfile, cwd=self.build_dir, verbose=self.options.verbose)
@@ -193,20 +202,33 @@ class PythonInstaller(object):
 
     def symlink(self):
         install_dir = os.path.realpath(self.install_dir)
+        if self.options.framework:
+            # create symlink bin -> /path/to/Frameworks/Python.framework/Versions/?.?/bin
+            bin_dir = os.path.join(install_dir, 'bin')
+            if os.path.exists(bin_dir):
+                rm_r(bin_dir)
+            m = re.match(r'\d\.\d', self.pkg.version)
+            if m:
+                version = m.group(0)
+            symlink(os.path.join(install_dir,'Frameworks','Python.framework','Versions',version,'bin'),
+                    os.path.join(bin_dir))
+
         path_python = os.path.join(install_dir,'bin','python')
         if not os.path.isfile(path_python):
-            path_python3 = os.path.join(install_dir,'bin','python3')
-            path_python3_0 = os.path.join(install_dir,'bin','python3.0')
-            if os.path.isfile(path_python3):
-                symlink(path_python3, path_python)
-            elif os.path.isfile(path_python3_0):
-                symlink(path_python3_0, path_python)
+            src = None
+            for d in os.listdir(os.path.join(install_dir,'bin')):
+                if re.match(r'python\d\.\d', d):
+                    src = d
+                    break
+            if src:
+                path_src = os.path.join(install_dir,'bin',src)
+                symlink(path_src, path_python)
 
     def install_setuptools(self):
         options = self.options
         pkgname = self.pkg.name
         if options.no_setuptools:
-            logger.info("Skip installation of setuptools.")
+            logger.log("Skip installation of setuptools.")
             return
         download_url = DISTRIBUTE_SETUP_DLSITE
         filename = Link(download_url).filename
@@ -228,7 +250,7 @@ class PythonInstaller(object):
                 s.check_call([easy_install, 'pip'])
         except:
             logger.error("Failed to install setuptools. See %s/build.log to see why." % (ROOT))
-            logger.info("Skip installation of setuptools.")
+            logger.log("Skip installation of setuptools.")
 
 class PythonInstallerMacOSX(PythonInstaller):
     """Python installer for MacOSX
@@ -237,14 +259,26 @@ class PythonInstallerMacOSX(PythonInstaller):
         super(PythonInstallerMacOSX, self).__init__(arg, options)
 
         # check for version
-        version = self.pkg.version
+        version = Version(self.pkg.version)
         if version < '2.6' and (version != '2.4.6' and version < '2.5.5'):
-            logger.info("`%s` is not supported on MacOSX Snow Leopard" % self.pkg.name)
+            logger.error("`%s` is not supported on MacOSX Snow Leopard" % self.pkg.name)
             raise NotSupportedVersionException
         # set configure options
         target = get_macosx_deployment_target()
         if target:
-            self.configure_options = 'MACOSX_DEPLOYMENT_TARGET=%s' % target
+            self.configure_options.append('MACOSX_DEPLOYMENT_TARGET=%s' % target)
+
+        # set build options
+        if options.framework and options.static:
+            logger.error("Can't specify both framework and static.")
+            raise Exception
+        if options.framework:
+            self.configure_options.append('--enable-framework=%s' % os.path.join(self.install_dir, 'Frameworks'))
+        elif not options.static:
+            self.configure_options.append('--enable-shared')
+        if options.universal:
+            self.configure_options.append('--enable-universalsdk=/')
+            self.configure_options.append('--with-universal-archs=intel')
 
         # note: skip `make test` to avoid hanging test_threading.
         if is_python25(version) or is_python24(version):
@@ -252,7 +286,7 @@ class PythonInstallerMacOSX(PythonInstaller):
     
     def patch(self):
         # note: want an interface to the source patching functionality. like a patchperl.
-        version = self.pkg.version
+        version = Version(self.pkg.version)
         if is_python24(version):
             patch_dir = PATH_PATCHES_MACOSX_PYTHON24
             self._add_patches_to_list(patch_dir, ['patch-configure', 'patch-Makefile.pre.in',

pythonbrew/log.py

@@ -1,43 +1,43 @@
 import sys
-import logging
 
-class LoggerInfo(object):
-    def log(self, level, msg, *arg, **keys):
-        sys.stdout.write("%s\n" % msg)
-
-class LoggerError(object):
-    def log(self, level, msg, *arg, **keys):
-        sys.stderr.write("ERROR: %s\n" % msg)
-
-class Logger(object):
+class Color(object):
+    DEBUG = '\033[35m'
+    INFO = '\033[32m'
+    ERROR = '\033[31m'
+    ENDC = '\033[0m'
     
-    DEBUG = logging.DEBUG
-    INFO = logging.INFO
-    ERROR = logging.ERROR
+    @classmethod
+    def _deco(cls, msg, color):
+        return '%s%s%s' % (color, msg, cls.ENDC)
     
-    def __init__(self):
-        self._consumers = []
-        consumer = LoggerInfo()
-        self.add_consumer(Logger.INFO, consumer)
+    @classmethod
+    def debug(cls, msg):
+        return cls._deco(msg, cls.DEBUG)
+    @classmethod
+    def info(cls, msg):
+        return cls._deco(msg, cls.INFO)
+    @classmethod
+    def error(cls, msg):
+        return cls._deco(msg, cls.ERROR)
+
+class Logger(object):    
+    def debug(self, msg):
+        self._stdout(Color.debug("DEBUG: %s\n" % msg))
+    
+    def log(self, msg):
+        self._stdout("%s\n" % (msg))
+    
+    def info(self, msg):
+        self._stdout(Color.info('%s\n' % msg))
         
-        consumer = LoggerError()
-        self.add_consumer(Logger.ERROR, consumer)
-    
-    def debug(self, msg, *args, **keys):
-        self._log(Logger.DEBUG, msg, *args, **keys)
-    
-    def info(self, msg, *args, **keys):
-        self._log(Logger.INFO, msg, *args, **keys)
+    def error(self, msg):
+        self._stderr(Color.error("ERROR: %s\n" % msg))
         
-    def error(self, msg, *args, **keys):
-        self._log(Logger.ERROR, msg, *args, **keys)
-    
-    def _log(self, level, msg, *args, **keys):
-        for (consumer_level, consumer) in self._consumers:
-            if level == consumer_level:
-                consumer.log(level, msg, *args, **keys)
-    
-    def add_consumer(self, level, consumer):
-        self._consumers.append((level, consumer))
+    def _stdout(self, msg):
+        sys.stdout.write(msg)
+        sys.stdout.flush()
+    def _stderr(self, msg):
+        sys.stderr.write(msg)
+        sys.stderr.flush()
 
 logger = Logger()

pythonbrew/util.py

@@ -10,7 +10,7 @@ import urllib
 import subprocess
 import shlex
 import select
-from pythonbrew.define import PATH_BIN, PATH_ETC_CURRENT, PATH_PYTHONS
+from pythonbrew.define import PATH_BIN, PATH_HOME_ETC_CURRENT, PATH_PYTHONS
 from pythonbrew.exceptions import ShellCommandException
 from pythonbrew.log import logger
 
@@ -72,26 +72,31 @@ def get_macosx_deployment_target():
         return m.group(1)
     return None
 
+def _py_version_cmp(v, v1, v2):
+    if is_str(v):
+        v = Version(v)
+    return v >= v1 and v < v2
+
 def is_python24(version):
-    return version >= '2.4' and version < '2.5'
+    return _py_version_cmp(version, '2.4', '2.5')
 
 def is_python25(version):
-    return version >= '2.5' and version < '2.6'
+    return _py_version_cmp(version, '2.5', '2.6')
 
 def is_python26(version):
-    return version >= '2.6' and version < '2.7'
+    return _py_version_cmp(version, '2.6', '2.7')
 
 def is_python27(version):
-    return version >= '2.7' and version < '2.8'
+    return _py_version_cmp(version, '2.7', '2.8')
 
 def is_python30(version):
-    return version >= '3.0' and version < '3.1'
+    return _py_version_cmp(version, '3.0', '3.1')
 
 def is_python31(version):
-    return version >= '3.1' and version < '3.2'
+    return _py_version_cmp(version, '3.1', '3.2')
 
 def is_python32(version):
-    return version >= '3.2' and version < '3.3'
+    return _py_version_cmp(version, '3.2', '3.3')
 
 def makedirs(path):
     if not os.path.exists(path):
@@ -209,14 +214,19 @@ def extract_downloadfile(content_type, download_file, target_dir):
         return False
     return True
 
-def get_using_python_path():
-    p = subprocess.Popen('command -v python', stdout=subprocess.PIPE, shell=True)
+def get_command_path(command):
+    p = subprocess.Popen('command -v %s' % command, stdout=subprocess.PIPE, shell=True)
     return to_str(p.communicate()[0].strip())
 
+def get_using_python_path():
+    return get_command_path('python')
+
 def get_using_python_pkgname():
     """return: Python-<VERSION> or None"""
     path = get_using_python_path()
     for d in sorted(os.listdir(PATH_PYTHONS)):
+        if not os.path.exists(os.path.join(PATH_PYTHONS, d, 'bin','python')):
+            continue
         if path and os.path.samefile(path, os.path.join(PATH_PYTHONS, d, 'bin','python')):
             return d
     return None
@@ -233,8 +243,8 @@ def is_installed(name):
     return True
     
 def set_current_path(path):
-    fp = open(PATH_ETC_CURRENT, 'w')
-    fp.write('PATH_PYTHONBREW="%s"\n' % (path))
+    fp = open(PATH_HOME_ETC_CURRENT, 'w')
+    fp.write('PATH_PYTHONBREW_CURRENT="%s"\n' % (path))
     fp.close()
 
 def path_to_fileurl(path):
@@ -268,6 +278,11 @@ def is_str(val):
         return isinstance(val, str)
     return False
 
+def is_sequence(val):
+    if is_str(val):
+        return False
+    return (hasattr(val, "__getitem__") or hasattr(val, "__iter__"))
+
 def bltin_any(iter):
     try:
         return any(iter)
@@ -278,6 +293,9 @@ def bltin_any(iter):
                 return True
         return False
 
+#-----------------------------
+# class
+#-----------------------------
 class Subprocess(object):
     def __init__(self, log=None, cwd=None, verbose=False, debug=False):
         self._log = log
@@ -290,7 +308,9 @@ class Subprocess(object):
     
     def shell(self, cmd):
         if self._debug:
-            logger.info(cmd)
+            logger.log(cmd)
+        if is_sequence(cmd):
+            cmd = ''.join(cmd)
         if self._log:
             if self._verbose:
                 cmd = "(%s) 2>&1 | tee '%s'" % (cmd, self._log)
@@ -304,7 +324,7 @@ class Subprocess(object):
         if is_str(cmd):
             cmd = shlex.split(cmd)
         if self._debug:
-            logger.info(cmd)
+            logger.log(cmd)
         
         fp = ((self._log and open(self._log, 'a')) or None)
         p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=self._cwd)
@@ -314,7 +334,7 @@ class Subprocess(object):
                 if not line:
                     break
                 if self._verbose:
-                    logger.info(line.strip())
+                    logger.log(line.strip())
                 if fp:
                     fp.write(line)
                     fp.flush()
@@ -345,7 +365,7 @@ class Package(object):
         if alias:
             self.name = 'Python-%s' % alias
             self.alias = alias
-
+    
 class Link(object):
     def __init__(self, url):
         self._url = url
@@ -364,4 +384,71 @@ class Link(object):
     def base_url(self):
         return posixpath.basename(self._url.split('#', 1)[0].split('?', 1)[0])
 
-        
+class Version(object):
+    """version compare
+    """
+    def __init__(self, v):
+        self._version = v
+        self._p = self._parse_version(v)
+
+    def __lt__(self, o):
+        if is_str(o):
+            o = self._parse_version(o)
+        return self._p < o
+
+    def __le__(self, o):
+        if is_str(o):
+            o = self._parse_version(o)
+        return self._p <= o
+
+    def __eq__(self, o):
+        if is_str(o):
+            o = self._parse_version(o)
+        return self._p == o
+
+    def __ne__(self, o):
+        if is_str(o):
+            o = self._parse_version(o)
+        return self._p != o
+
+    def __gt__(self, o):
+        if is_str(o):
+            o = self._parse_version(o)
+        return self._p > o
+
+    def __ge__(self, o):
+        if is_str(o):
+            o = self._parse_version(o)
+        return self._p >= o
+
+    def _parse_version(self, s):
+        """see pkg_resouce.parse_version
+        """
+        component_re = re.compile(r'(\d+ | [a-z]+ | \.| -)', re.VERBOSE)
+        replace = {'pre':'c', 'preview':'c','-':'final-','rc':'c','dev':'@'}.get
+
+        def _parse_version_parts(s):
+            for part in component_re.split(s):
+                part = replace(part,part)
+                if not part or part=='.':
+                    continue
+                if part[:1] in '0123456789':
+                    yield part.zfill(8)    # pad for numeric comparison
+                else:
+                    yield '*'+part
+            yield '*final'  # ensure that alpha/beta/candidate are before final
+
+        parts = []
+        for part in _parse_version_parts(s.lower()):
+            if part.startswith('*'):
+                if part<'*final':   # remove '-' before a prerelease tag
+                    while parts and parts[-1]=='*final-': parts.pop()
+                # remove trailing zeros from each series of numeric parts
+                while parts and parts[-1]=='00000000':
+                    parts.pop()
+            parts.append(part)
+        return tuple(parts)
+
+    def __repr__(self):
+        return self._version
+

pythonbrew_install.py

@@ -1,4 +1,4 @@
-from pythonbrew.installer import install_pythonbrew, upgrade_pythonbrew
+from pythonbrew.installer import install_pythonbrew, upgrade_pythonbrew, systemwide_pythonbrew
 from optparse import OptionParser
 if __name__ == "__main__":
     parser = OptionParser()
@@ -9,8 +9,17 @@ if __name__ == "__main__":
         default=False,
         help="Upgrade."
     )
+    parser.add_option(
+        '--systemwide',
+        dest="systemwide",
+        action="store_true",
+        default=False,
+        help="systemwide install."
+    )
     (opt, arg) = parser.parse_args()
-    if opt.upgrade:
+    if opt.systemwide:
+        systemwide_pythonbrew()
+    elif opt.upgrade:
         upgrade_pythonbrew()
     else:
         install_pythonbrew()

setup.py

@@ -17,6 +17,10 @@ setup(name='pythonbrew',
         'Programming Language :: Python :: 2.4',
         'Programming Language :: Python :: 2.5',
         'Programming Language :: Python :: 2.6',
+        'Programming Language :: Python :: 2.7',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.1',
+        'Programming Language :: Python :: 3.2',
       ],
       keywords='pythonbrew pip easy_install distutils setuptools virtualenv',
       author='utahta',

stable-version.txt

@@ -1 +1 @@
-0.9
+1.1

tests/__init__.py

@@ -1,17 +0,0 @@
-import os
-import shutil
-
-PYTHONBREW_ROOT = '/tmp/pythonbrew.test'
-TESTPY_VERSION = ['2.4.6', '2.5.5', '2.6.6', '3.2']
-def cleanall():
-    if os.path.isdir(PYTHONBREW_ROOT):
-        shutil.rmtree(PYTHONBREW_ROOT)
-
-def setup():
-    os.environ['PYTHONBREW_ROOT'] = PYTHONBREW_ROOT
-    cleanall()
-    from pythonbrew.installer import install_pythonbrew
-    install_pythonbrew()
-    
-def teardown():
-    cleanall()

tests/test_00_update.py

@@ -1,11 +0,0 @@
-class UpdateOptions(object):
-    master = False
-    develop = False
-    config = False
-    force = False
-
-def test_update():
-    from pythonbrew.commands.update import UpdateCommand
-    c = UpdateCommand()
-    c.run_command(UpdateOptions(), None)
-    

tests/test_01_help.py

@@ -1,4 +0,0 @@
-def test_help():
-    from pythonbrew.commands.help import HelpCommand
-    c = HelpCommand()
-    c.run_command(None, None)

tests/test_02_version.py

@@ -1,4 +0,0 @@
-def test_version():
-    from pythonbrew.commands.version import VersionCommand
-    c = VersionCommand()
-    c.run_command(None, None)

tests/test_03_install.py

@@ -1,18 +0,0 @@
-from tests import TESTPY_VERSION
-
-class InstallOptions(object):
-    force = True
-    no_test = True
-    verbose = False
-    configure = ""
-    no_setuptools = False
-    alias = None
-    jobs = 2
-
-def test_install():
-    from pythonbrew.commands.install import InstallCommand
-    py_version = TESTPY_VERSION.pop(0)
-    c = InstallCommand()
-    c.run_command(InstallOptions(), [py_version]) # pybrew install -f -j2 2.4.6
-    c.run_command(InstallOptions(), TESTPY_VERSION) # pybrew install -f -j2 2.5.6 2.6.6 3.2
-

tests/test_04_switch.py

@@ -1,7 +0,0 @@
-from tests import TESTPY_VERSION
-
-def test_switch():
-    from pythonbrew.commands.switch import SwitchCommand
-    for py_version in TESTPY_VERSION:
-        c = SwitchCommand()
-        c.run_command(None, [py_version])

tests/test_05_use.py

@@ -1,7 +0,0 @@
-from tests import TESTPY_VERSION
-
-def test_use():
-    from pythonbrew.commands.use import UseCommand
-    for py_version in TESTPY_VERSION:
-        c = UseCommand()
-        c.run_command(None, [py_version])

tests/test_06_off.py

@@ -1,4 +0,0 @@
-def test_off():
-    from pythonbrew.commands.off import OffCommand
-    c = OffCommand()
-    c.run_command(None, None)

tests/test_07_list.py

@@ -1,8 +0,0 @@
-class ListOptions(object):
-    all_versions = False
-    known = False
-
-def test_list():
-    from pythonbrew.commands.list import ListCommand
-    c = ListCommand()
-    c.run_command(ListOptions(), None)

tests/test_08_py.py

@@ -1,22 +0,0 @@
-from tests import PYTHONBREW_ROOT
-import os
-
-TESTPY_FILE = os.path.join(PYTHONBREW_ROOT, 'etc', 'testfile.py')
-
-class PyOptions(object):
-    pythons = []
-    verbose = False
-    bin = "python"
-    options = ""
-
-def _create_pyfile():
-    fp = open(TESTPY_FILE, 'w')
-    fp.write("print('test')")
-    fp.close()
-
-def test_py():
-    from pythonbrew.commands.py import PyCommand
-    _create_pyfile()
-    
-    c = PyCommand()
-    c.run_command(PyOptions(), [TESTPY_FILE])

tests/test_09_buildout.py

@@ -1,31 +0,0 @@
-from tests import PYTHONBREW_ROOT
-import os
-
-BUILDOUT_DIR = os.path.join(PYTHONBREW_ROOT, 'etc', 'buildout')
-BUILDOUT_CONF = os.path.join(BUILDOUT_DIR, 'buildout.cfg')
-
-def _create_buildout_cfg():
-    if not os.path.isdir(BUILDOUT_DIR):
-        os.makedirs(BUILDOUT_DIR)
-    fp = open(BUILDOUT_CONF, 'w')
-    fp.write("""[buildout]
-parts = test
-develop =
-
-[test]
-recipe = 
-eggs =""")
-    fp.close()
-
-class BuildoutOptions(object):
-    python = '2.6.6'
-
-def test_buildout():
-    from pythonbrew.commands.buildout import BuildoutCommand
-    
-    # Runs the buildout
-    _create_buildout_cfg()
-    os.chdir(BUILDOUT_DIR)
-    c = BuildoutCommand()
-    c.run_command(BuildoutOptions(), [])
-    

tests/test_10_venv.py

@@ -1,11 +0,0 @@
-class VenvOptions(object):
-    python = '2.6.6'
-    all = False
-
-def test_venv():
-    from pythonbrew.commands.venv import VenvCommand
-    c = VenvCommand()
-    c.run_command(VenvOptions(), ['create', 'aaa'])
-    c.run_command(VenvOptions(), ['list'])
-    c.run_command(VenvOptions(), ['use', 'aaa'])
-    c.run_command(VenvOptions(), ['delete', 'aaa'])

tests/test_11_cleanup.py

@@ -1,4 +0,0 @@
-def test_clean():
-    from pythonbrew.commands.cleanup import CleanupCommand
-    c = CleanupCommand()
-    c.run_command(None, None)

tests/test_11_uninstall.py

@@ -1,7 +0,0 @@
-from tests import TESTPY_VERSION
-
-def test_uninstall():
-    from pythonbrew.commands.uninstall import UninstallCommand
-    for py_version in TESTPY_VERSION:
-        c = UninstallCommand()
-        c.run_command(None, [py_version])

tests/test_12_cleanup.py

@@ -1,4 +0,0 @@
-def test_clean():
-    from pythonbrew.commands.cleanup import CleanupCommand
-    c = CleanupCommand()
-    c.run_command(None, None)

tests/test_suite.py

@@ -0,0 +1,138 @@
+# coding=utf-8
+#---------------------------------------------------------------------------
+# Copyright 2011 utahta
+#---------------------------------------------------------------------------
+import os
+import shutil
+
+#---------------------------------------------------------------------------
+# Settings
+#---------------------------------------------------------------------------
+PYTHONBREW_ROOT = '/tmp/pythonbrew.test'
+TESTPY_VERSION = ['2.4.6', '2.5.5', '2.6.6', '3.2']
+
+def _cleanall():
+    if os.path.isdir(PYTHONBREW_ROOT):
+        shutil.rmtree(PYTHONBREW_ROOT)
+
+def _install_pythonbrew():
+    from pythonbrew.installer import install_pythonbrew
+    install_pythonbrew()
+
+def setup():
+    os.environ['PYTHONBREW_ROOT'] = PYTHONBREW_ROOT
+    _cleanall()
+    _install_pythonbrew()
+
+def teardown():
+    _cleanall()
+
+class Options(object):
+    def __init__(self, opts):
+        for (k,v) in opts.items():
+            setattr(self, k, v)
+
+#---------------------------------------------------------------------------
+# Test
+#---------------------------------------------------------------------------
+def test_00_update():
+    from pythonbrew.commands.update import UpdateCommand
+    c = UpdateCommand()
+    c.run_command(Options({'master':False, 'develop':False, 'config':False, 'force':False}), 
+                  None)
+
+def test_01_help():
+    from pythonbrew.commands.help import HelpCommand
+    c = HelpCommand()
+    c.run_command(None, None)
+
+def test_02_version():
+    from pythonbrew.commands.version import VersionCommand
+    c = VersionCommand()
+    c.run_command(None, None)
+
+def test_03_install():
+    from pythonbrew.commands.install import InstallCommand
+    py_version = TESTPY_VERSION.pop(0)
+    o = Options({'force':True, 'no_test':True, 'verbose':False, 'configure':"",
+                 'no_setuptools': False, 'alias':None, 'jobs':2, 
+                 'framework':False, 'universal':False, 'static':False})
+    c = InstallCommand()
+    c.run_command(o, [py_version]) # pybrew install -f -j2 2.4.6
+    c.run_command(o, TESTPY_VERSION) # pybrew install -f -j2 2.5.6 2.6.6 3.2
+
+def test_04_switch():
+    from pythonbrew.commands.switch import SwitchCommand
+    for py_version in TESTPY_VERSION:
+        c = SwitchCommand()
+        c.run_command(None, [py_version])
+
+def test_05_use():
+    from pythonbrew.commands.use import UseCommand
+    for py_version in TESTPY_VERSION:
+        c = UseCommand()
+        c.run_command(None, [py_version])
+
+def test_06_off():
+    from pythonbrew.commands.off import OffCommand
+    c = OffCommand()
+    c.run_command(None, None)
+
+def test_07_list():
+    from pythonbrew.commands.list import ListCommand
+    c = ListCommand()
+    c.run_command(Options({'all_versions':False, 'known':False}), 
+                  None)
+
+def test_08_py():
+    from pythonbrew.commands.py import PyCommand
+    TESTPY_FILE = os.path.join(PYTHONBREW_ROOT, 'etc', 'testfile.py')
+    fp = open(TESTPY_FILE, 'w')
+    fp.write("print('test')")
+    fp.close()
+    # Runs the python script
+    c = PyCommand()
+    c.run_command(Options({'pythons':[], 'verbose':False, 'bin':"python", 'options':""}), 
+                  [TESTPY_FILE])
+
+def test_09_buildout():
+    from pythonbrew.commands.buildout import BuildoutCommand
+    BUILDOUT_DIR = os.path.join(PYTHONBREW_ROOT, 'etc', 'buildout')
+    BUILDOUT_CONF = os.path.join(BUILDOUT_DIR, 'buildout.cfg')
+    if not os.path.isdir(BUILDOUT_DIR):
+        os.makedirs(BUILDOUT_DIR)
+    fp = open(BUILDOUT_CONF, 'w')
+    fp.write("""[buildout]
+parts = test
+develop =
+
+[test]
+recipe = 
+eggs =""")
+    fp.close()
+    # Runs the buildout
+    os.chdir(BUILDOUT_DIR)
+    c = BuildoutCommand()
+    c.run_command(Options({'python':'2.6.6'}), [])
+
+def test_10_venv():
+    from pythonbrew.commands.venv import VenvCommand
+    c = VenvCommand()
+    o = Options({'python':'2.6.6', 'all':False, 'no_site_packages':False})
+    c.run_command(o, ['init'])
+    c.run_command(o, ['create', 'aaa'])
+    c.run_command(o, ['list'])
+    c.run_command(o, ['use', 'aaa'])
+    c.run_command(o, ['delete', 'aaa'])
+
+def test_11_uninstall():
+    from pythonbrew.commands.uninstall import UninstallCommand
+    for py_version in TESTPY_VERSION:
+        c = UninstallCommand()
+        c.run_command(None, [py_version])
+
+def test_12_clean():
+    from pythonbrew.commands.cleanup import CleanupCommand
+    c = CleanupCommand()
+    c.run_command(None, None)
+