\documentclass{howto}

\usepackage{ltxmarkup}

\usepackage{times}

\usepackage{distutils}

\title{Installing Python Modules}

% The audience for this document includes people who don't know anything

% about Python and aren't about to learn the language just in order to

% install and maintain it for their users, i.e. system administrators.

% Thus, I have to be sure to explain the basics at some point:

% sys.path and PYTHONPATH at least. Should probably give pointers to

% other docs on "import site", PYTHONSTARTUP, PYTHONHOME, etc.

%

% Also, I need to take into account that most modules out there don't

% (yet) use Distutils: briefly explain the old Makefile.pre.in

% convention (maybe move material from the E&E manual to here?), and

% explain where to copy .py and .so files manually if the distribution

% doesn't provide a mechanism for doing so.

%

% Finally, it might be useful to include all the material from my "Care

% and Feeding of a Python Installation" talk in here somewhere. Yow!

\author{Greg Ward}

\authoraddress{E-mail: \email{[email protected]}}

\makeindex

\begin{document}

\maketitle

\begin{abstract}

\noindent

This document describes the Python Distribution Utilities

(``Distutils'') from the end-user's point-of-view, describing how to

extend the capabilities of a standard Python installation by building

and installing third-party Python modules and extensions.

\end{abstract}

%\begin{abstract}

%\noindent

%Abstract this!

%\end{abstract}

\tableofcontents

\section{Introduction}

\label{intro}

Although Python's extensive standard library covers many programming

needs, there often comes a time when you need to add some new

functionality to your Python installation in the form of third-party

modules. This might be necessary to support your own programming, or to

support an application that you want to use and that happens to be

written in Python.

In the past, there has been little support for adding third-party

modules to an existing Python installation. With the introduction of

the Python Distribution Utilities (Distutils for short) in Python 2.0,

this is starting to change. Not everything will change overnight,

though, so while this document concentrates on installing module

distributions that use the Distutils, we will also spend some time

dealing with the old ways.

This document is aimed primarily at the people who need to install

third-party Python modules: end-users and system administrators who just

need to get some Python application running, and existing Python

programmers who want to add some new goodies to their toolbox. You

don't need to know Python to read this document; there will be some

brief forays into using Python's interactive mode to explore your

installation, but that's it. If you're looking for information on how

to distribute your own Python modules so that others may use them, see

the \citetitle[../dist/dist.html]{Distributing Python Modules} manual.

\subsection{Best case: trivial installation}

\label{trivial-inst}

In the best case, someone will have prepared a special version of the

module distribution you want to install that is targeted specifically at

your platform and is installed just like any other software on your

platform. For example, the module developer might make an executable

installer available for Windows users, an RPM package for users of

RPM-based Linux systems (Red Hat, SuSE, Mandrake, and many others), a

Debian package for users of Debian-based Linux systems (Debian proper,

Caldera, Corel, etc.), and so forth.

In that case, you would download the installer appropriate to your

platform and do the obvious thing with it: run it if it's an executable

installer, \code{rpm --install} it if it's an RPM, etc. You don't need

to run Python or a setup script, you don't need to compile

anything---you might not even need to read any instructions (although

it's always a good idea to do so anyways).

Of course, things will not always be that easy. You might be interested

in a module distribution that doesn't have an easy-to-use installer for

your platform. In that case, you'll have to start with the source

distribution released by the module's author/maintainer. Installing

from a source distribution is not too hard, as long as the modules are

packaged in the standard way. The bulk of this document is about

building and installing modules from standard source distributions.

\subsection{The new standard: Distutils}

\label{new-standard}

If you download a module source distribution, you can tell pretty

quickly if it was packaged and distributed in the standard way, i.e.

using the Distutils. First, the distribution's name and version number

will be featured prominently in the name of the downloaded archive, e.g.

\file{foo-1.0.tar.gz} or \file{widget-0.9.7.zip}. Next, the archive

will unpack into a similarly-named directory: \file{foo-1.0} or

\file{widget-0.9.7}. Additionally, the distribution will contain a

setup script \file{setup.py}, and a \file{README.txt} (or possibly

\file{README}), which should explain that building and installing the

module distribution is a simple matter of running

\begin{verbatim}

python setup.py install

\end{verbatim}

If all these things are true, then you already know how to build and

install the modules you've just downloaded: run the command above.

Unless you need to install things in a non-standard way or customize the

build process, you don't really need this manual. Or rather, the above

command is everything you need to get out of this manual.

\subsection{The old way: no standards}

\label{old-way}

Before the Distutils, there was no infrastructure to support installing

third-party modules in a consistent, standardized way. Thus, it's not

really possible to write a general manual for installing Python modules

that don't use the Distutils; the only truly general statement that can

be made is, ``Read the module's own installation instructions.''

However, if such instructions exist at all, they are often woefully

inadequate and targeted at experienced Python developers. Such users

are already familiar with how the Python library is laid out on their

platform, and know where to copy various files in order for Python to

find them. This document makes no such assumptions, and explains how

the Python library is laid out on three major platforms (Unix, Windows,

and Mac~OS), so that you can understand what happens when the Distutils

do their job \emph{and} know how to install modules manually when the

module author fails to provide a setup script.

Additionally, while there has not previously been a standard

installation mechanism, Python has had some standard machinery for

building extensions on Unix since Python \XXX{version?}. This machinery

(the \file{Makefile.pre.in} file) is superseded by the Distutils, but it

will no doubt live on in older module distributions for a while. This

\file{Makefile.pre.in} mechanism is documented in the ``Extending \&

Embedding Python'' manual, but that manual is aimed at module

developers---hence, we include documentation for builders/installers

here.

All of the pre-Distutils material is tucked away in

section~\ref{pre-distutils}.

\section{Standard Build and Install}

\label{normal-install}

As described in section~\ref{new-standard}, building and installing

a module distribution using the Distutils is usually one simple command:

\begin{verbatim}

python setup.py install

\end{verbatim}

On Unix, you'd run this command from a shell prompt; on Windows, you

have to open a command prompt window (``DOS box'') and do it there; on

Mac~OS, things are a tad more complicated (see below).

\subsection{Platform variations}

You should always run the setup command from the distribution root

directory, i.e. the top-level subdirectory that the module source

distribution unpacks into. For example, if you've just downloaded a

module source distribution \file{foo-1.0.tar.gz} onto a Unix system, the

normal thing to do is:

\begin{verbatim}

gunzip -c foo-1.0.tar.gz | tar xf - # unpacks into directory foo-1.0

cd foo-1.0

python setup.py install

\end{verbatim}

On Windows, you'd probably download \file{foo-1.0.zip}. If you

downloaded the archive file to \file{C:\textbackslash{}Temp}, then it

would unpack into \file{C:\textbackslash{}Temp\textbackslash{}foo-1.0};

you can use either a GUI archive manipulator (such as WinZip) or a

command-line tool (such as \program{unzip} or \program{pkunzip}) to

unpack the archive. Then, open a command prompt window (``DOS box''),

and run:

\begin{verbatim}

cd c:\Temp\foo-1.0

python setup.py install

\end{verbatim}

On Mac~OS, you have to go through a bit more effort to supply

command-line arguments to the setup script:

\begin{itemize}

\item hit option-double-click on the script's icon (or option-drop it

onto the Python interpreter's icon)

\item press the ``Set unix-style command line'' button

\item set the ``Keep stdio window open on termination'' if you're

interested in seeing the output of the setup script (which is usually

voluminous and often useful)

\item (??) when the command-line dialog pops up, enter ``install'' (you

can, of course, enter any Distutils command-line as described in this

document or in the ``Distributing Python Modules'' document: just

leave of the initial \code{python setup.py} and you'll be fine)

\end{itemize}

\XXX{this should change: every Distutils setup script will need

command-line arguments for every run (and should probably keep stdout

around), so all this should happen automatically for setup scripts}

\subsection{Splitting the job up}

Running \code{setup.py install} builds and installs all modules in one

run. If you prefer to work incrementally---especially useful if you

want to customize the build process, or if things are going wrong---you

can use the setup script to do one thing at a time. This is

particularly helpful when the build and install will be done by

different users---e.g., you might want to build a module distribution

and hand it off to a system administrator for installation (or do it

yourself, with super-user privileges).

For example, you can build everything in one step, and then install

everything in a second step, by invoking the setup script twice:

\begin{verbatim}

python setup.py build

python setup.py install

\end{verbatim}

(If you do this, you will notice that running the \command{install}

command first runs the \command{build} command, which---in this

case---quickly notices that it has nothing to do, since everything in

the \file{build} directory is up-to-date.)

You may not need this ability to break things down often if all you do

is install modules downloaded off the 'net, but it's very handy for more

advanced tasks. If you get into distributing your own Python modules

and extensions, you'll run lots of individual Distutils commands on

their own.

\subsection{How building works}

As implied above, the \command{build} command is responsible for putting

the files to install into a \emph{build directory}. By default, this is

\file{build} under the distribution root; if you're excessively

concerned with speed, or want to keep the source tree pristine, you can

change the build directory with the \longprogramopt{build-base} option.

For example:

\begin{verbatim}

python setup.py build --build-base=/tmp/pybuild/foo-1.0

\end{verbatim}

(Or you could do this permanently with a directive in your system or

personal Distutils configuration file; see

section~\ref{config-files}.) Normally, this isn't necessary.

The default layout for the build tree is as follows:

\begin{verbatim}

--- build/ --- lib/

or

--- build/ --- lib.<plat>/

temp.<plat>/

\end{verbatim}

where \code{<plat>} expands to a brief description of the current

OS/hardware platform. The first form, with just a \file{lib} directory,

is used for ``pure module distributions''---that is, module

distributions that include only pure Python modules. If a module

distribution contains any extensions (modules written in C/C++, or Java

for JPython), then the second form, with two \code{<plat>} directories,

is used. In that case, the \file{temp.\filevar{plat}} directory holds

temporary files generated by the compile/link process that don't

actually get installed. In either case, the \file{lib} (or

\file{lib.\filevar{plat}}) directory contains all Python modules (pure

Python and extensions) that will be installed.

In the future, more directories will be added to handle Python scripts,

documentation, binary executables, and whatever else is needed to handle

the job of installing Python modules and applications.

\subsection{How installation works}

After the \command{build} command runs (whether you run it explicitly,

or the \command{install} command does it for you), the work of the

\command{install} command is relatively simple: all it has to do is copy

everything under \file{build/lib} (or \file{build/lib.\filevar{plat}})

to your chosen installation directory.

If you don't choose an installation directory---i.e., if you just run

\code{setup.py install}---then the \command{install} command installs to

the standard location for third-party Python modules. This location

varies by platform and by how you built/installed Python itself. On

Unix and Mac OS, it also depends on whether the module distribution

being installed is pure Python or contains extensions (``non-pure''):

\begin{tableiv}{l|l|l|c}{textrm}%

{Platform}{Standard installation location}{Default value}{Notes}

\lineiv{Unix (pure)}

{\filenq{\filevar{prefix}/lib/python2.0/site-packages}}

{\filenq{/usr/local/lib/python2.0/site-packages}}

{(1)}

\lineiv{Unix (non-pure)}

{\filenq{\filevar{exec-prefix}/lib/python2.0/site-packages}}

{\filenq{/usr/local/lib/python2.0/site-packages}}

{(1)}

\lineiv{Windows}

{\filenq{\filevar{prefix}}}

{\filenq{C:\textbackslash{}Python}}

{(2)}

\lineiv{Mac~OS (pure)}

{\filenq{\filevar{prefix}:Lib}}

{\filenq{Python:Lib} \XXX{???}}

{}

\lineiv{Mac~OS (non-pure)}

{\filevar{prefix}:Mac:PlugIns}

{\filenq{Python:Mac:PlugIns}\XXX{???}}

{}

\end{tableiv}

\noindent Notes:

\begin{description}

\item[(1)] Most Linux distributions include Python as a standard part of

the system, so \filevar{prefix} and \filevar{exec-prefix} are usually

both \file{/usr} on Linux. If you build Python yourself on Linux (or

any Unix-like system), the default \filevar{prefix} and

\filevar{exec-prefix} are \file{/usr/local}.

\item[(2)] The default installation directory on Windows was

\file{C:\textbackslash{}Program Files\textbackslash{}Python} under

Python 1.6a1, 1.5.2, and earlier.

\end{description}

\filevar{prefix} and \filevar{exec-prefix} stand for the directories

that Python is installed to, and where it finds its libraries at

run-time. They are always the same under Windows and Mac~OS, and very

often the same under Unix. You can find out what your Python

installation uses for \filevar{prefix} and \filevar{exec-prefix} by

running Python in interactive mode and typing a few simple commands.

Under Unix, just type \code{python} at the shell prompt; under Windows,

run ``Python 2.0 (interpreter)'' \XXX{right?}; under Mac~OS, \XXX{???}.

Once the interpreter is started, you type Python code at the

\samp{>>> } prompt. For example, on my Linux system, I type the three

Python statements shown below, and get the output as shown, to find

out my \filevar{prefix} and \filevar{exec-prefix}:

\begin{verbatim}

Python 1.5.2 (#1, Apr 18 1999, 16:03:16) [GCC pgcc-2.91.60 19981201 (egcs-1.1.1 on linux2

Copyright 1991-1995 Stichting Mathematisch Centrum, Amsterdam

>>> import sys

>>> sys.prefix

'/usr'

>>> sys.exec_prefix

'/usr'

\end{verbatim}

If you don't want to install to the standard location, or if you don't

have permission to write there, then you need to read about alternate

installations in the next section.

% This rather nasty macro is used to generate the tables that describe

% each installation scheme. It's nasty because it takes two arguments

% for each "slot" in an installation scheme, there will soon be more

% than five of these slots, and TeX has a limit of 10 arguments to a

% macro. Uh-oh.

\newcommand{\installscheme}[8]

{\begin{tableiii}{lll}{textrm}

{Type of file}

{Installation Directory}

{Override option}

\lineiii{pure module distribution}

{\filevar{#1}\filenq{#2}}

{\longprogramopt{install-purelib}}

\lineiii{non-pure module distribution}

{\filevar{#3}\filenq{#4}}

{\longprogramopt{install-platlib}}

\lineiii{scripts}

{\filevar{#5}\filenq{#6}}

{\longprogramopt{install-scripts}}

\lineiii{data}

{\filevar{#7}\filenq{#8}}

{\longprogramopt{install-data}}

\end{tableiii}}

\section{Alternate Installation}

\label{alt-install}

Often, it is necessary or desirable to install modules to a location

other than the standard location for third-party Python modules. For

example, on a Unix system you might not have permission to write to the

standard third-party module directory. Or you might wish to try out a

module before making it a standard part of your local Python

installation; this is especially true when upgrading a distribution

already present: you want to make sure your existing base of scripts

still works with the new version before actually upgrading.

The Distutils \command{install} command is designed to make installing

module distributions to an alternate location simple and painless. The

basic idea is that you supply a base directory for the installation, and

the \command{install} command picks a set of directories (called an

\emph{installation scheme}) under this base directory in which to

install files. The details differ across platforms, so read whichever

of the following section applies to you.

\subsection{Alternate installation: Unix (the home scheme)}

\label{alt-unix-prefix}

Under Unix, there are two ways to perform an alternate installation.

The ``prefix scheme'' is similar to how alternate installation works

under Windows and Mac~OS, but is not necessarily the most useful way to

maintain a personal Python library. Hence, we document the more

convenient and commonly useful ``home scheme'' first.

The idea behind the ``home scheme'' is that you build and maintain a

personal stash of Python modules, probably under your home directory.

Installing a new module distribution is as simple as

\begin{verbatim}

python setup.py install --home=<dir>

\end{verbatim}

where you can supply any directory you like for the \longprogramopt{home}

option. Lazy typists can just type a tilde (\code{\textasciitilde}); the

\command{install} command will expand this to your home directory:

\begin{verbatim}

python setup.py install --home=~

\end{verbatim}

The \longprogramopt{home} option defines the installation base

directory. Files are installed to the following directories under the

installation base as follows:

\installscheme{home}{/lib/python}

{home}{/lib/python}

{home}{/bin}

{home}{/share}

\subsection{Alternate installation: Unix (the prefix scheme)}

\label{alt-unix-home}

The ``prefix scheme'' is useful when you wish to use one Python

installation to perform the build/install (i.e., to run the setup

script), but install modules into the third-party module directory of a

different Python installation (or something that looks like a different

Python installation). If this sounds a trifle unusual, it is---that's

why the ``home scheme'' comes first. However, there are at least two

known cases where the prefix scheme will be useful.

First, consider that many Linux distributions put Python in \file{/usr},

rather than the more traditional \file{/usr/local}. This is entirely

appropriate, since in those cases Python is part of ``the system''

rather than a local add-on. However, if you are installing Python

modules from source, you probably want them to go in

\file{/usr/local/lib/python1.\filevar{X}} rather than

\file{/usr/lib/python1.\filevar{X}}. This can be done with

\begin{verbatim}

/usr/bin/python setup.py install --prefix=/usr/local

\end{verbatim}

Another possibility is a network filesystem where the name used to write

to a remote directory is different from the name used to read it: for

example, the Python interpreter accessed as \file{/usr/local/bin/python}

might search for modules in \file{/usr/local/lib/python1.\filevar{X}},

but those modules would have to be installed to, say,

\file{/mnt/\filevar{@server}/export/lib/python1.\filevar{X}}. This

could be done with

\begin{verbatim}

/usr/local/bin/python setup.py install --prefix=/mnt/@server/export

\end{verbatim}

In either case, the \longprogramopt{prefix} option defines the

installation base, and the \longprogramopt{exec-prefix} option defines

the platform-specific installation base, which is used for

platform-specific files. (Currently, this just means non-pure module

distributions, but could be expanded to C libraries, binary executables,

etc.) If \longprogramopt{exec-prefix} is not supplied, it defaults to

\longprogramopt{prefix}. Files are installed as follows:

\installscheme{prefix}{/lib/python1.\filevar{X}/site-packages}

{exec-prefix}{/lib/python1.\filevar{X}/site-packages}

{prefix}{/bin}

{prefix}{/share}

There is no requirement that \longprogramopt{prefix} or

\longprogramopt{exec-prefix} actually point to an alternate Python

installation; if the directories listed above do not already exist, they

are created at installation time.

Incidentally, the real reason the prefix scheme is important is simply

that a standard Unix installation uses the prefix scheme, but with

\longprogramopt{prefix} and \longprogramopt{exec-prefix} supplied by

Python itself (as \code{sys.prefix} and \code{sys.exec\_prefix}). Thus,

you might think you'll never use the prefix scheme, but every time you

run \code{python setup.py install} without any other options, you're

using it.

Note that installing extensions to an alternate Python installation has

no effect on how those extensions are built: in particular, the Python

header files (\file{Python.h} and friends) installed with the Python

interpreter used to run the setup script will be used in compiling

extensions. It is your responsibility to ensure that the interpreter

used to run extensions installed in this way is compatibile with the

interpreter used to build them. The best way to do this is to ensure

that the two interpreters are the same version of Python (possibly

different builds, or possibly copies of the same build). (Of course, if

your \longprogramopt{prefix} and \longprogramopt{exec-prefix} don't even

point to an alternate Python installation, this is immaterial.)

\subsection{Alternate installation: Windows}

\label{alt-windows}

Since Windows has no conception of a user's home directory, and since

the standard Python installation under Windows is simpler than that

under Unix, there's no point in having separate \longprogramopt{prefix}

and \longprogramopt{home} options. Just use the \longprogramopt{prefix}

option to specify a base directory, e.g.

\begin{verbatim}

python setup.py install --prefix="\Temp\Python"

\end{verbatim}

to install modules to the \file{\textbackslash{}Temp} directory on the current

drive.

The installation base is defined by the \longprogramopt{prefix} option;

the \longprogramopt{exec-prefix} option is not supported under Windows.

Files are installed as follows:

\installscheme{prefix}{}

{prefix}{}

{prefix}{\textbackslash{}Scripts}

{prefix}{\textbackslash{}Data}

\subsection{Alternate installation: Mac~OS}

\label{alt-macos}

Like Windows, Mac~OS has no notion of home directories (or even of

users), and a fairly simple standard Python installation. Thus, only a

\longprogramopt{prefix} option is needed. It defines the installation

base, and files are installed under it as follows:

\XXX{how do MacPython users run the interpreter with command-line args?}

\installscheme{prefix}{:Lib}

{prefix}{:Mac:PlugIns}

{prefix}{:Scripts}

{prefix}{:Data}

\XXX{Corran Webster says: ``Modules are found in either \file{:Lib} or

\file{:Mac:Lib}, while extensions usually go in

\file{:Mac:PlugIns}''---does this mean that non-pure distributions should

be divided between \file{:Mac:PlugIns} and \file{:Mac:Lib}? If so, that

changes the granularity at which we care about modules: instead of

``modules from pure distributions'' and ``modules from non-pure

distributions'', it becomes ``modules from pure distributions'',

``Python modules from non-pure distributions'', and ``extensions from

non-pure distributions''. Is this necessary?!?}

\section{Custom Installation}

\label{custom-install}

Sometimes, the alternate installation schemes described in

section~\ref{alt-install} just don't do what you want. You might

want to tweak just one or two directories while keeping everything under

the same base directory, or you might want to completely redefine the

installation scheme. In either case, you're creating a \emph{custom

installation scheme}.

You probably noticed the column of ``override options'' in the tables

describing the alternate installation schemes above. Those options are

how you define a custom installation scheme. These override options can

be relative, absolute, or explicitly defined in terms of one of the

installation base directories. (There are two installation base

directories, and they are normally the same---they only differ when you

use the Unix ``prefix scheme'' and supply different

\longprogramopt{prefix} and \longprogramopt{exec-prefix} options.)

For example, say you're installing a module distribution to your home

directory under Unix---but you want scripts to go in

\file{\textasciitilde/scripts} rather than \file{\textasciitilde/bin}.

As you might expect, you can override this directory with the

\longprogramopt{install-scripts} option; in this case, it makes most

sense to supply a relative path, which will be interpreted relative to

the installation base directory (your home directory, in this case):

\begin{verbatim}

python setup.py install --home=~ --install-scripts=scripts

\end{verbatim}

Another Unix example: suppose your Python installation was built and

installed with a prefix of \file{/usr/local/python}, so under a standard

installation scripts will wind up in \file{/usr/local/python/bin}. If

you want them in \file{/usr/local/bin} instead, you would supply this

absolute directory for the \longprogramopt{install-scripts} option:

\begin{verbatim}

python setup.py install --install-scripts=/usr/local/bin

\end{verbatim}

(This performs an installation using the ``prefix scheme,'' where the

prefix is whatever your Python interpreter was installed with---

\file{/usr/local/python} in this case.)

If you maintain Python on Windows, you might want third-party modules to

live in a subdirectory of \filevar{prefix}, rather than right in

\filevar{prefix} itself. This is almost as easy as customizing the

script installation directory---you just have to remember that there are

two types of modules to worry about, pure modules and non-pure modules

(i.e., modules from a non-pure distribution). For example:

\begin{verbatim}

python setup.py install --install-purelib=Site --install-platlib=Site

\end{verbatim}

The specified installation directories are relative to \filevar{prefix}.

Of course, you also have to ensure that these directories are in

Python's module search path, e.g. by putting a \file{.pth} file in

\filevar{prefix} (\XXX{should have a section describing .pth files and

cross-ref it here}).

If you want to define an entire installation scheme, you just have to

supply all of the installation directory options. The recommended way

to do this is to supply relative paths; for example, if you want to

maintain all Python module-related files under \file{python} in your

home directory, and you want a separate directory for each platform that

you use your home directory from, you might define the following

installation scheme:

\begin{verbatim}

python setup.py install --home=~ \

--install-purelib=python/lib \

--install-platlib=python/lib.$PLAT \

--install-scripts=python/scripts

--install-data=python/data

\end{verbatim}

or, equivalently,

\begin{verbatim}

python setup.py install --home=~/python \

--install-purelib=lib \

--install-platlib='lib.$PLAT' \

--install-scripts=scripts

--install-data=data

\end{verbatim}

\code{\$PLAT} is not (necessarily) an environment variable---it will be

expanded by the Distutils as it parses your command line options (just

as it does when parsing your configuration file(s)).

Obviously, specifying the entire installation scheme every time you

install a new module distribution would be very tedious. Thus, you can

put these options into your Distutils config file (see

section~\ref{config-files}):

\begin{verbatim}

[install]

install-base=$HOME

install-purelib=python/lib

install-platlib=python/lib.$PLAT

install-scripts=python/scripts

install-data=python/data

\end{verbatim}

or, equivalently,

\begin{verbatim}

[install]

install-base=$HOME/python

install-purelib=lib

install-platlib=lib.$PLAT

install-scripts=scripts

install-data=data

\end{verbatim}

Note that these two are \emph{not} equivalent if you supply a different

installation base directory when you run the setup script. For example,

\begin{verbatim}

python setup.py --install-base=/tmp

\end{verbatim}

would install pure modules to \filevar{/tmp/python/lib} in the first

case, and to \filevar{/tmp/lib} in the second case. (For the second

case, you probably want to supply an installation base of

\file{/tmp/python}.)

You probably noticed the use of \code{\$HOME} and \code{\$PLAT} in the

sample configuration file input. These are Distutils configuration

variables, which bear a strong resemblance to environment variables. In

fact, you can use environment variables in config files---on platforms

that have such a notion---but the Distutils additionally define a few

extra variables that may not be in your environment, such as

\code{\$PLAT}. (And of course, you can only use the configuration

variables supplied by the Distutils on systems that don't have

environment variables, such as Mac~OS (\XXX{true?}).) See

section~\ref{config-files} for details.

\XXX{need some Windows and Mac~OS examples---when would custom

installation schemes be needed on those platforms?}

\section{Distutils Configuration Files}

\label{config-files}

\section{Pre-Distutils Conventions}

\label{pre-distutils}

\subsection{The Makefile.pre.in file}

\label{makefile-pre-in}

\subsection{Installing modules manually}

\label{manual-install}

\end{document}