virtualenv
==========

.. contents::

Status and License
------------------

``virtualenv`` is intended (when complete) to be a successor to
`workingenv <http://cheeseshop.python.org/pypi/workingenv.py>`_, and
an extension of `virtual-python
<http://peak.telecommunity.com/DevCenter/EasyInstall#creating-a-virtual-python>`_.

It is written by Ian Bicking, and sponsored by the `Open Planning
Project <http://topp.openplans.org>`_.

It is licensed under an `MIT-style permissive license
<http://svn.colorstudy.com/virtualenv/trunk/docs/license.txt>`_.

You can install it with ``easy_install virtualenv``, or from the
`subversion repository
<http://svn.colorstudy.com/virtualenv/trunk#egg=virtualenv-dev>`_ with
``easy_install virtualenv==dev``.

What It Does
------------

``virtualenv`` is a tool to create isolated Python environments.

The basic problem being addressed is one of dependencies and versions,
and indirectly permissions.  Imagine you have an application that
needs version 1 of LibFoo, but another application requires version
2.  How can you use both these applications?  If you install
everything into ``/usr/lib/python2.4/site-packages`` (or whatever your
platform's standard location is), it's easy to end up in a situation
where you unintentionally upgrade an application that shouldn't be
upgraded.

Or more generally, what if you want to install an application *and
leave it be*?  If an application works, any change in its libraries or
the versions of those libraries can break the application.

Also, what if you can't install packages into the global
``site-packages`` directory?  For instance, on a shared host.

In all these cases, ``virtualenv`` can help you.  It creates an
environment that has its own installation directories, that doesn't
share libraries with other virtualenv environments (and optionally
doesn't use the globally installed libraries either).

The basic usage is::

    $ python virtualenv.py ENV

This creates ``ENV/lib/python2.4/site-packages`` (or
``ENV/lib/python2.5/site-packages`` on Python 2.5, etc), where any
libraries you install will go.  It also creates ``ENV/bin/python``,
which is a Python interpreter that uses this environment.  Anytime you
use that interpreter (including when a script has
``#!/path/to/ENV/bin/python`` in it) the libraries in that environment
will be used.

It also installs `Setuptools
<http://peak.telecommunity.com/DevCenter/setuptools>`_ for you, and if
you use ``ENV/bin/easy_install`` the packages will be installed into
the environment.

Creating Your Own Bootstrap Scripts
-----------------------------------

While this creates an environment, it doesn't put anything into the
environment.  Developers may find it useful to distribute a script
that sets up a particular environment, for example a script that
installs a particular web application.

To create a script like this, call
``virtualenv.create_bootstrap_script(extra_text)``, and write the
result to your new bootstrapping script.  Here's the documentation
from the docstring:

Creates a bootstrap script, which is like this script but with
extend_parser, adjust_options, and after_install hooks.

This returns a string that (written to disk of course) can be used
as a bootstrap script with your own customizations.  The script
will be the standard virtualenv.py script, with your extra text
added (your extra text should be Python code).

If you include these functions, they will be called:

``extend_parser(optparse_parser)``:
    You can add or remove options from the parser here.

``adjust_options(options, args)``:
    You can change options here, or change the args (if you accept
    different kinds of arguments, be sure you modify ``args`` so it is
    only ``[DEST_DIR]``).

``after_install(options, home_dir)``:

    After everything is installed, this function is called.  This
    is probably the function you are most likely to use.  An
    example would be::

        def after_install(options, home_dir):
            subprocess.call([join(home_dir, 'bin', 'easy_install'),
                             'MyPackage'])
            subprocess.call([join(home_dir, 'bin', 'my-package-script'),
                             'setup', home_dir])

    This example immediately installs a package, and runs a setup
    script from that package.

Bootstrap Example
~~~~~~~~~~~~~~~~~

Here's a more concrete example of how you could use this::

    import virtualenv, textwrap
    output = virtualenv.create_bootstrap_script(textwrap.dedent("""
    import os, subprocess
    def after_install(options, home_dir):
        etc = join(home_dir, 'etc')
        if not os.path.exists(etc):
            os.makedirs(etc)
        subprocess.call([join(home_dir, 'bin', 'easy_install'),
                         'BlogApplication'])
        subprocess.call([join(home_dir, 'bin', 'paster'),
                         'make-config', 'BlogApplication',
                         join(etc, 'blog.ini')])
        subprocess.call([join(home_dir, 'bin', 'paster'),
                         'setup-app', join(etc, 'blog.ini')])
    """))
    f = open('blog-bootstrap.py', 'w').write(output)

Compare & Contrast with Alternatives
------------------------------------

There are several alternatives that create isolated environments:

* ``workingenv`` (which I do not suggest you use anymore *if*
  virtualenv works on your platform) is the predecessor to this
  library.  It used the main Python interpreter, but relied on setting
  ``$PYTHONPATH`` to activate the environment.  This causes problems
  when running Python scripts that aren't part of the environment
  (e.g., a globally installed ``hg`` or ``bzr``).  It also conflicted
  a lot with Setuptools.

* `virtual-python
  <http://peak.telecommunity.com/DevCenter/EasyInstall#creating-a-virtual-python>`_
  is also a predecessor to this library.  It uses only symlinks, so it
  couldn't work on Windows.  It also symlinks over the *entire*
  standard library and global ``site-packages``.  As a result, it
  won't see new additions to the global ``site-packages``.

  This script only symlinks a small portion of the standard library
  into the environment, and so Windows it is feasible to simply copy
  these files over.  Also, it creates a new/empty ``site-packages``
  and also adds the global ``site-packages`` to the path, so updates
  are tracked separately.  This script also installs Setuptools
  automatically, saving a step and avoiding the need for network
  access.

* `zc.buildout <http://pypi.python.org/pypi/zc.buildout>`_ doesn't
  create an isolated Python environment in the same style, but
  achieves similar results through a declarative config file that sets
  up scripts with very particular packages.  As a declarative system,
  it is somewhat easier to repeat and manage, but more difficult to
  experiment with.  ``zc.buildout`` includes the ability to setup
  non-Python systems (e.g., a database server or an Apache instance).

I *strongly* recommend anyone doing application development or
deployment use one of these tools.

Changes & News
--------------

svn trunk
~~~~~~~~~

* Added ``lib-dynload`` and ``config`` to things that need to be
  copied over in an environment.
* Copy over or symlink the ``include`` directory, so that you can
  build packages that need the C headers.
* Include a ``distutils`` package, so you can locally update
  ``distutils.cfg`` (in ``lib/pythonX.Y/distutils/distutils.cfg``).
* Better avoid downloading Setuptools, and hitting PyPI on environment
  creation. 
* Fix a problem creating a ``lib64/`` directory.
* Should work on MacOSX Framework builds (the default Python
  installations on Mac).  From Ronald Oussoren.

0.8.4
~~~~~

* Windows installs would sometimes give errors about ``sys.prefix`` that
  were inaccurate.
* Slightly prettier output.

0.8.3
~~~~~

* Added support for Windows.

0.8.2
~~~~~

* Give a better warning if you are on an unsupported platform (Mac
  Framework Pythons, and Windows).
* Give error about running while inside a workingenv.
* Give better error message about Python 2.3.

0.8.1
~~~~~

Fixed packaging of the library.

0.8
~~~

Initial release.  Everything is changed and new!
