Metadata-Version: 1.0
Name: zc.buildout
Version: 1.0.0b20
Summary: System for managing development buildouts
Home-page: http://svn.zope.org/zc.buildout
Author: Jim Fulton
Author-email: jim@zope.com
License: ZPL 2.1
Description: ********
        Buildout
        ********
        
        .. contents::
        
        The Buildout project provides support for creating applications,
        especially Python applications.  It provides tools for assembling
        applications from multiple parts, Python or otherwise.  An application
        may actually contain multiple programs, processes, and configuration
        settings.
        
        The word "buildout" refers to a description of a set of parts and the
        software to create and assemble them.  It is often used informally to
        refer to an installed system based on a buildout definition.  For
        example, if we are creating an application named "Foo", then "the Foo
        buildout" is the collection of configuration and application-specific
        software that allows an instance of the application to be created.  We
        may refer to such an instance of the application informally as "a Foo
        buildout".
        
        To get a feel for some of the things you might use buildouts for, see
        the `Buildout examples`_.
        
        To lean more about using buildouts, see `Detailed Documentation`_.
        
        Recipes
        *******
        
        Existing recipes include:
        
        `zc.recipe.egg <http://dev.zope.org/Buildout/egg.html>`_
        The egg recipe installes one or more eggs, with their
        dependencies.  It installs their console-script entry points with
        the needed eggs included in their paths.
        
        `zc.recipe.testrunner <http://dev.zope.org/Buildout/testrunner.html>`_
        The testrunner egg installs creates a test runner script for one or
        more eggs.
        
        `zc.recipe.zope3checkout <http://dev.zope.org/Buildout/zope3checkout.html>`_
        The zope3checkout recipe installs a Zope 3 checkout into a
        buildout.
        
        `zc.recipe.zope3instance <http://dev.zope.org/Buildout/zope3instance.html>`_
        The zope3instance recipe sets up a Zope 3 instance.
        
        `zc.recipe.filestorage <http://dev.zope.org/Buildout/filestorage.html>`_
        The filestorage recipe sets up a ZODB file storage for use in a
        Zope 3 instance creayed by the zope3instance recipe.
        
        Buildout examples
        *****************
        
        Here are a few examples of what you can do with buildouts.  We'll
        present these as a set of use cases.
        
        Try out an egg
        ==============
        
        Sometimes you want to try an egg (or eggs) that someone has released.
        You'd like to get a Python interpreter that lets you try things
        interactively or run sample scripts without having to do path
        manipulations.  If you can and don't mind modifying your Python
        installation, you could use easy_install, otherwise, you could create
        a directory somewhere and create a buildout.cfg file in that directory
        containing::
        
        [buildout]
        parts = mypython
        
        [mypython]
        recipe = zc.recipe.egg
        interpreter = mypython
        eggs = theegg
        
        where theegg is the name of the egg you want to try out.
        
        Run buildout in this directory.  It will create a bin subdirectory
        that includes a mypython script.  If you run mypython without any
        arguments you'll get an interactive interpreter with the egg in the
        path. If you run it with a script and script arguments, the script
        will run with the egg in its path.  Of course, you can specify as many
        eggs as you want in the eggs option.
        
        If the egg provides any scripts (console_scripts entry points), those
        will be installed in your bin directory too.
        
        Work on a package
        =================
        
        I often work on packages that are managed separately.  They don't have
        scripts to be installed, but I want to be able to run their tests
        using the `zope.testing test runner
        <http://www.python.org/pypi/zope.testing>`_.  In this kind of
        application, the program to be instaleld is the test runner.  A good
        example of this is `zc.ngi <http://svn.zope.org/zc.ngi/trunk/>`_.
        
        Here I have a subversion project for the zc.ngi package.  The software
        is in the src directory.  The configuration file is very simple::
        
        [buildout]
        develop = .
        parts = test
        
        [test]
        recipe = zc.recipe.testrunner
        eggs = zc.ngi
        
        I use the develop option to create a develop egg based on the current
        directory.  I request a test script named "test" using the
        zc.recipe.testrunner recipe.  In the section for the test script, I
        specify that I want to run the tests in the zc.ngi package.
        
        When I check out this project into a new sandbox, I run bootstrap.py
        to get setuptools and zc.buildout and create bin/buildout.  I run
        bin/buildout, which installs the test script, bin/test, which I can
        then use to run the tests.
        
        This is probably the most common type of buildout.
        
        The `zc.buildout project <http://svn.zope.org/zc.buildout/trunk>`_
        is a slightly more complex example of this type of buildout.
        
        Install egg-based scripts
        =========================
        
        A variation of the `Try out an egg`_ use case is to install scripts
        into your ~/bin directory (on Unix, of course).  My ~/bin directory is
        a buildout with a configuration file that looks like::
        
        
        [buildout]
        parts = foo bar
        bin-directory = .
        
        [foo]
        ...
        
        whwre foo and bar are packages with scripts that I want available.  As
        I need new scripts, I can add additional sections.  The bin-directory
        option specified that scripts should be installed into the current
        directory.
        
        Multi-program multi-machine systems
        ===================================
        
        Using an older prototype version of the buildout, we've build a number
        of systems involving multiple programs, databases, and machines.  One
        typical example consists of:
        
        - Multiple Zope instances
        
        - Multiple ZEO servers
        
        - An LDAP server
        
        - Cache-invalidation and Mail delivery servers
        
        - Dozens of add-on packages
        
        - Multiple test runners
        
        - Multiple deployment modes, including dev, stage, and prod,
        with prod deployment over multiple servers
        
        Parts installed include:
        
        - Application software installs, including Zope, ZEO and LDAP
        software
        
        - Add-on packages
        
        - Bundles of configuration that define Zope, ZEO and LDAP instances
        
        - Utility scripts such as test runners, server-control
        scripts, cron jobs.
        
        Questions and Bug Reporting
        ***************************
        
        Please send questions and comments to the
        `distutils SIG mailing list <mailto://distutils-sig@python.org>`_.
        
        Report bugs using the `zc.buildout Launchpad Bug Tracker
        <https://launchpad.net/products/zc.buildout/+bugs>`_.
        
        
        Status
        ******
        
        The buildout system is under active development. Some near term
        priorities include:
        
        - Fixing `bugs <https://launchpad.net/products/zc.buildout/+bugs>`_
        
        - Making buildouts more
        `repeatable
        <https://features.launchpad.net/products/zc.buildout/+spec/repeatable>`_
        
        - Adding support for making distributions from buildouts
        
        - Better error reporing
        
        Change History
        **************
        
        1.0.0b20 (2007-02-08)
        =====================
        
        Feature Changes
        ---------------
        
        - Added a buildout newest option, to control whether the newest
        distributions should be sought to meet requirements.  This might
        also provide a hint to recipes that don't deal with
        distributions. For example, a recipe that manages subversion
        checkouts might not update a checkout if newest is set to "false".
        
        - Added a *newest* keyword parameter to the
        zc.buildout.easy_install.install and zc.buildout.easy_install.build
        functions to control whether the newest distributions that meed
        given requirements should be sought.  If a false value is provided
        for this parameter and already installed eggs meet the given
        requirements, then no attempt will be made to search for newer
        distributions.
        
        - The recipe-testing support setUp function now adds the name
        *buildout* to the test namespace with a value that is the path to
        the buildout script in the sample buildout.  This allows tests to
        use
        
        >>> print system(buildout),
        
        rather than:
        
        >>> print system(join('bin', 'buildout')),
        
        
        Bugs Fixed
        ----------
        
        - Paths returned from update methods replaced lists of installed files
        rather than augmenting them.
        
        1.0.0b19 (2007-01-24)
        =====================
        
        Bugs Fixed
        ----------
        
        - Explicitly specifying a Python executable failed if the output of
        running Python with the -V option included a 2-digit (rather than a
        3-digit) version number.
        
        1.0.0b18 (2007-01-22)
        =====================
        
        Feature Changes
        ---------------
        
        - Added documentation for some previously undocumented features of the
        easy_install APIs.
        
        - By popular demand, added a -o command-line option that is a short
        hand for the assignment buildout:offline=true.
        
        Bugs Fixed
        ----------
        
        - When deciding whether recipe develop eggs had changed, buildout
        incorrectly considered files in .svn and CVS directories.
        
        1.0.0b17 (2006-12-07)
        =====================
        
        Feature Changes
        ---------------
        
        - Configuration files can now be loaded from URLs.
        
        Bugs Fixed
        ----------
        
        - https://bugs.launchpad.net/products/zc.buildout/+bug/71246
        
        Buildout extensions installed as eggs couldn't be loaded in offline
        mode.
        
        
        1.0.0b16 (2006-12-07)
        =====================
        
        Feature Changes
        ---------------
        
        - A new command-line argument, -U, suppresses reading user defaults.
        
        - You can now suppress use of an installed-part database
        (e.g. .installed.cfg) by sprifying an empty value for the buildout
        installed option.
        
        Bugs Fixed
        ----------
        
        - When the install command is used with a list of parts, only
        those parts are supposed to be installed, but the buildout was also
        building parts that those parts depended on.
        
        1.0.0b15 (2006-12-06)
        =====================
        
        Bugs Fixed
        ----------
        
        - Uninstall recipes weren't loaded correctly in cases where
        no parts in the (new) configuration used the recipe egg.
        
        1.0.0b14 (2006-12-05)
        =====================
        
        Feature Changes
        ---------------
        
        - Added uninstall recipes for dealing with complex uninstallation
        scenarios.
        
        Bugs Fixed
        ----------
        
        - Automatic upgrades weren't performed on Windows due to a bug that
        caused buildout to incorrectly determine that it wasn't running
        locally in a buildout.
        
        - Fixed some spurious test failures on Windows.
        
        1.0.0b13 (2006-12-04)
        =====================
        
        Feature Changes
        ---------------
        
        - Variable substitutions now reflect option data written by recipes.
        
        - A part referenced by a part in a parts list is now added to the parts
        list before the referencing part.  This means that you can omit
        parts from the parts list if they are referenced by other parts.
        
        - Added a develop function to the easy_install module to aid in
        creating develop eggs with custom build_ext options.
        
        - The build and develop functions in the easy_install module now
        return the path of the egg or egg link created.
        
        - Removed the limitation that parts named in the install command can
        only name configured parts.
        
        - Removed support ConfigParser-style variable substitutions
        (e.g. %(foo)s). Only the string-template style of variable
        (e.g. ${section:option}) substitutions will be supported.
        Supporting both violates "there's only one way to do it".
        
        - Deprecated the buildout-section extendedBy option.
        
        Bugs Fixed
        ----------
        
        - We treat setuptools as a dependency of any distribution that
        (declares that it) uses namespace packages, whether it declares
        setuptools as a dependency or not.  This wasn't working for eggs
        intalled by virtue of being dependencies.
        
        
        1.0.0b12 (2006-10-24)
        =====================
        
        Feature Changes
        ---------------
        
        - Added an initialization argument to the
        zc.buildout.easy_install.scripts function to include initialization
        code in generated scripts.
        
        1.0.0b11 (2006-10-24)
        =====================
        
        Bugs Fixed
        ----------
        
        `67737 <https://launchpad.net/products/zc.buildout/+bug/67737>`_
        Verbose and quite output options caused errors when the
        develop buildout option was used to create develop eggs.
        
        `67871 <https://launchpad.net/products/zc.buildout/+bug/67871>`_
        Installation failed if the source was a (local) unzipped
        egg.
        
        `67873 <https://launchpad.net/products/zc.buildout/+bug/67873>`_
        There was an error in producing an error message when part names
        passed to the install command weren't included in the
        configuration.
        
        1.0.0b10 (2006-10-16)
        =====================
        
        Feature Changes
        ---------------
        
        - Renamed the runsetup command to setup. (The old name still works.)
        
        - Added a recipe update method. Now install is only called when a part
        is installed for the first time, or after an uninstall. Otherwise,
        update is called.  For backward compatibility, recipes that don't
        define update methiods are still supported.
        
        - If a distribution defines namespace packages but fails to declare
        setuptools as one of its dependencies, we now treat setuptools as an
        implicit dependency.  We generate a warning if the distribution
        is a develop egg.
        
        - You can now create develop eggs for setup scripts that don't use setuptools.
        
        Bugs Fixed
        ----------
        
        - Egg links weren't removed when corresponding entries were removed
        from develop sections.
        
        - Running a non-local buildout command (one not installed in the
        buildout) ket to a hang if there were new versions of zc.buildout or
        setuptools were available.  Now we issue a warning and don't
        upgrade.
        
        - When installing zip-safe eggs from local directories, the eggs were
        moved, rather than copied, removing them from the source directory.
        
        1.0.0b9 (2006-10-02)
        ====================
        
        Bugs Fixed
        ----------
        
        Non-zip-safe eggs were not unzipped when they were installed.
        
        1.0.0b8 (2006-10-01)
        ====================
        
        Bugs Fixed
        ----------
        
        - Installing source distributions failed when using alternate Python
        versions (depending on the versions of Python used.)
        
        - Installing eggs wasn't handled as efficiently as possible due to a
        bug in egg URL parsing.
        
        - Fixed a bug in runsetup that caused setup scripts that introspected
        __file__ to fail.
        
        1.0.0b7
        =======
        
        Added a documented testing framework for use by recipes. Refactored
        the buildout tests to use it.
        
        Added a runsetup command run a setup script.  This is handy if, like
        me, you don't install setuptools in your system Python.
        
        1.0.0b6
        =======
        
        Fixed https://launchpad.net/products/zc.buildout/+bug/60582
        Use of extension options caused bootstrapping to fail if the eggs
        directory didn't already exist.  We no longer use extensions for
        bootstrapping.  There really isn't any reason to anyway.
        
        
        1.0.0b5
        =======
        
        Refactored to do more work in buildout and less work in easy_install.
        This makes things go a little faster, makes errors a little easier to
        handle, and allows extensions (like the sftp extension) to influence
        more of the process. This was done to fix a problem in using the sftp
        support.
        
        1.0.0b4
        =======
        
        - Added an **experimental** extensions mechanism, mainly to support
        adding sftp support to buildouts that need it.
        
        - Fixed buildout self-updating on Windows.
        
        1.0.0b3
        =======
        
        - Added a help option (-h, --help)
        
        - Increased the default level of verbosity.
        
        - Buildouts now automatically update themselves to new versions of
        zc.buildout and setuptools.
        
        - Added Windows support.
        
        - Added a recipe API for generating user errors.
        
        - No-longer generate a py_zc.buildout script.
        
        - Fixed some bugs in variable substitutions.
        
        The characters "-", "." and " ", weren't allowed in section or
        option names.
        
        Substitutions with invalid names were ignored, which caused
        missleading failures downstream.
        
        - Improved error handling.  No longer show tracebacks for user errors.
        
        - Now require a recipe option (and therefore a section) for every part.
        
        - Expanded the easy_install module API to:
        
        - Allow extra paths to be provided
        
        - Specify explicit entry points
        
        - Specify entry-point arguments
        
        1.0.0b2
        =======
        
        Added support for specifying some build_ext options when installing eggs
        from source distributions.
        
        1.0.0b1
        =======
        
        - Changed the bootstrapping code to only install setuptools and
        zc.buildout. The bootstrap code no-longer runs the buildout itself.
        This was to fix a bug that caused parts to be recreated
        unnecessarily because the recipe signature in the initial buildout
        reflected temporary locations for setuptools and zc.buildout.
        
        - Now create a minimal setup.py if it doesn't exist and issue a
        warning that it is being created.
        
        - Fixed bug in saving installed configuration data.  %'s and extra
        spaces weren't quoted.
        
        1.0.0a1
        =======
        
        Initial public version
        
        Detailed Documentation
        **********************
        
        Buildouts
        =========
        
        The word "buildout" refers to a description of a set of parts and the
        software to create and assemble them.  It is often used informally to
        refer to an installed system based on a buildout definition.  For
        example, if we are creating an application named "Foo", then "the Foo
        buildout" is the collection of configuration and application-specific
        software that allows an instance of the application to be created.  We
        may refer to such an instance of the application informally as "a Foo
        buildout".
        
        This document describes how to define buildouts using buildout
        configuration files and recipes.  There are three ways to set up the
        buildout software and create a buildout instance:
        
        1. Install the zc.buildout egg with easy_install and use the buildout
        script installed in a Python scripts area.
        
        2. Use the buildout bootstrap script to create a buildout that
        includes both the setuptools and zc.buildout eggs.  This allows you
        to use the buildout software without modifying a Python install.
        The buildout script is installed into your buildout local scripts
        area.
        
        3. Use a buildoput command from an already installed buildout to
        bootstrap a new buildout.  (See the section on bootstraping later
        in this document.)
        
        Often, a software project will be managed in a software repository,
        such as a subversion repository, that includes some software source
        directories, buildout configuration files, and a copy of the buildout
        bootstrap script.  To work on the project, one would check out the
        project from the repository and run the bootstrap script which
        installs setuptools and zc.buildout into the checkout as well as any
        parts defined.
        
        We have a sample buildout that we created using the bootstrap command
        of an existing buildout (method 3 above).  It has the absolute minimum
        information.  We have bin, develop-eggs, eggs and parts directories,
        and a configuration file:
        
        >>> ls(sample_buildout)
        d  bin
        -  buildout.cfg
        d  develop-eggs
        d  eggs
        d  parts
        
        The bin directory contains scripts.
        
        >>> ls(sample_buildout, 'bin')
        -  buildout
        
        >>> ls(sample_buildout, 'eggs')
        -  setuptools-0.6-py2.4.egg
        -  zc.buildout-1.0-py2.4.egg
        
        The develop-eggs and parts directories are initially empty:
        
        >>> ls(sample_buildout, 'develop-eggs')
        >>> ls(sample_buildout, 'parts')
        
        The develop-eggs directory holds egg links for software being
        developed in the buildout.  We separate develop-eggs and other eggs to
        allow eggs directories to be shared across multiple buildouts.  For
        example, a common developer technique is to define a common eggs
        directory in their home that all non-develop eggs are stored in.  This
        allows larger buildouts to be set up much more quickly and saves disk
        space.
        
        The parts directory provides an area where recipes can install
        part data.  For example, if we built a custom Python, we would
        install it in the part directory.  Part data is stored in a
        sub-directory of the parts directory with the same name as the part.
        
        Buildouts are defined using configuration files.  These are in the
        format defined by the Python ConfigParser module, with extensions
        that we'll describe later.  By default, when a buildout is run, it
        looks for the file buildout.cfg in the directory where the buildout is
        run.
        
        The minimal configuration file has a buildout section that defines no
        parts:
        
        >>> cat(sample_buildout, 'buildout.cfg')
        [buildout]
        parts =
        
        A part is simply something to be created by a buildout.  It can be
        almost anything, such as a Python package, a program, a directory, or
        even a configuration file.
        
        Recipes
        -------
        
        A part is created by a recipe.  Recipes are always installed as Python
        eggs. They can be downloaded from a package server, such as the
        Python Package Index, or they can be developed as part of a project
        using a "develop" egg.
        
        A develop egg is a special kind of egg that gets installed as an "egg
        link" that contains the name of a source directory.  Develop eggs
        don't have to be packaged for distribution to be used and can be
        modified in place, which is especially useful while they are being
        developed.
        
        Let's create a recipe as part of the sample project.  We'll create a
        recipe for creating directories.  First, we'll create a recipes source
        directory for our local recipes:
        
        >>> mkdir(sample_buildout, 'recipes')
        
        and then we'll create a source file for our mkdir recipe:
        
        >>> write(sample_buildout, 'recipes', 'mkdir.py',
        ... """
        ... import logging, os, zc.buildout
        ...
        ... class Mkdir:
        ...
        ...     def __init__(self, buildout, name, options):
        ...         self.buildout = buildout
        ...         self.name = name
        ...         self.options = options
        ...         options['path'] = os.path.join(
        ...                               buildout['buildout']['directory'],
        ...                               options['path'],
        ...                               )
        ...         if not os.path.isdir(os.path.dirname(options['path'])):
        ...             logging.getLogger(self.name).error(
        ...                 'Cannot create %s. %s is not a directory.',
        ...                 options['path'], os.path.dirname(options['path']))
        ...             raise zc.buildout.UserError('Invalid Path')
        ...
        ...
        ...     def install(self):
        ...         path = self.options['path']
        ...         logging.getLogger(self.name).info(
        ...             'Creating directory %s', os.path.basename(path))
        ...         os.mkdir(path)
        ...         return path
        ...
        ...     def update(self):
        ...         pass
        ... """)
        
        Currently, recipes must define 3 methods [#future_recipe_methods]_:
        
        - a constructor,
        
        - an install method, and
        
        - an update method.
        
        The constructor is responsible for updating a parts options to reflect
        data read from other sections.  The buildout system keeps track of
        whether a part specification has changed.  A part specification has
        changed if it's options, after ajusting for data read from other
        sections, has changed, or if the recipe has changed.  Only the options
        for the part are considered.  If data are read from other sections,
        then that information has to be reflected in the parts options.  In
        the Mkdir example, the given path is interpreted relative to the
        buildout directory, and data from the buildout directory is read.  The
        path option is updated to reflect this.  If the directory option was
        changed in the buildout sections, we would know to update parts
        created using the mkdir recipe using relative path names.
        
        When buildout is run, it saves configuration data for installed parts
        in a file named ".installed.cfg".  In subsequent runs, it compares
        part-configuration data stored in the .installed.cfg file and the
        part-configuration data loaded from the configuration files as
        modified by recipe constructors to decide if the configuration of a
        part has changed. If the configuration has changed, or if the recipe
        has changed, then the part is uninstalled and reinstalled.  The
        buildout only looks at the part's options, so any data used to
        configure the part needs to be reflected in the part's options.  It is
        the job of a recipe constructor to make sure that the options include
        all relevent data.
        
        Of course, parts are also uninstalled if they are no-longer used.
        
        The recipe defines a constructor that takes a buildout object, a part
        name, and an options dictionary. It saves them in instance attributes.
        If the path is relative, we'll interpret it as relative to the
        buildout directory.  The buildout object passed in is a mapping from
        section name to a mapping of options for that section. The buildout
        directory is available as the directory option of the buildout
        section.  We normalize the path and save it back into the options
        directory.
        
        The install method is responsible for creating the part.  In this
        case, we need the path of the directory to create.  We'll use a path
        option from our options dictionary.  The install method logs what it's
        doing using the Python logging call.  We return the path that we
        installed.  If the part is uninstalled or reinstalled, then the path
        returned will be removed by the buildout machinery.  A recipe install
        method is expected to return a string, or an iterable of strings
        containing paths to be removed if a part is uninstalled.  For most
        recipes, this is all of the uninstall support needed. For more complex
        uninstallation scenarios use `Uninstall recipes`_.
        
        The update method is responsible for updating an already installed
        part.  An empty method is often provided, as in this example, if parts
        can't be updated.  An update method can return None, a string, or an
        iterable of strings.  If a string or iterable of strings is returned,
        then the saved list of paths to be uninstalled is updated with the new
        information by adding any new files returned by the update method.
        
        We need to provide packaging information so that our recipe can be
        installed as a develop egg. The minimum information we need to specify
        [#packaging_info]_ is a name.  For recipes, we also need to define the
        names of the recipe classes as entry points.  Packaging information is
        provided via a setup.py script:
        
        >>> write(sample_buildout, 'recipes', 'setup.py',
        ... """
        ... from setuptools import setup
        ...
        ... setup(
        ...     name = "recipes",
        ...     entry_points = {'zc.buildout': ['mkdir = mkdir:Mkdir']},
        ...     )
        ... """)
        
        Our setup script defines an entry point. Entry points provide
        a way for an egg to define the services it provides.  Here we've said
        that we define a zc.buildout entry point named mkdir.  Recipe
        classes must be exposed as entry points in the zc.buildout group.  we
        give entry points names within the group.
        
        We also need a README.txt for our recipes to avoid an annoying warning
        from distutils, on which setuptools and zc.buildout are based:
        
        >>> write(sample_buildout, 'recipes', 'README.txt', " ")
        
        Now let's update our buildout.cfg:
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = data-dir
        ...
        ... [data-dir]
        ... recipe = recipes:mkdir
        ... path = mystuff
        ... """)
        
        Let's go through the changes one by one::
        
        develop = recipes
        
        This tells the buildout to install a development egg for our recipes.
        Any number of paths can be listed.  The paths can be relative or
        absolute.  If relative, they are treated as relative to the buildout
        directory.  They can be directory or file paths.  If a file path is
        given, it should point to a Python setup script.  If a directory path
        is given, it should point to a directory containing a setup.py file.
        Development eggs are installed before building any parts, as they may
        provide locally-defined recipes needed by the parts.
        
        ::
        
        parts = data-dir
        
        Here we've named a part to be "built".  We can use any name we want
        except that different part names must be unique and recipes will often
        use the part name to decide what to do.
        
        ::
        
        [data-dir]
        recipe = recipes:mkdir
        path = mystuff
        
        
        When we name a part, we also create a section of the same
        name that contains part data.  In this section, we'll define
        the recipe to be used to install the part.  In this case, we also
        specify the path to be created.
        
        Let's run the buildout.  We do so by running the build script in the
        buildout:
        
        >>> import os
        >>> os.chdir(sample_buildout)
        >>> buildout = os.path.join(sample_buildout, 'bin', 'buildout')
        >>> print system(buildout),
        buildout: Develop: /sample-buildout/recipes
        buildout: Installing data-dir
        data-dir: Creating directory mystuff
        
        We see that the recipe created the directory, as expected:
        
        >>> ls(sample_buildout)
        -  .installed.cfg
        d  bin
        -  buildout.cfg
        d  develop-eggs
        d  eggs
        d  mystuff
        d  parts
        d  recipes
        
        In addition, .installed.cfg has been created containing information
        about the part we installed:
        
        >>> cat(sample_buildout, '.installed.cfg')
        [buildout]
        installed_develop_eggs = /sample-buildout/develop-eggs/recipes.egg-link
        parts = data-dir
        <BLANKLINE>
        [data-dir]
        __buildout_installed__ = /sample-buildout/mystuff
        __buildout_signature__ = recipes-c7vHV6ekIDUPy/7fjAaYjg==
        path = /sample-buildout/mystuff
        recipe = recipes:mkdir
        
        Note that the directory we installed is included in .installed.cfg.
        In addition, the path option includes the actual destination
        directory.
        
        If we change the name of the directory in the configuration file,
        we'll see that the directory gets removed and recreated:
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = data-dir
        ...
        ... [data-dir]
        ... recipe = recipes:mkdir
        ... path = mydata
        ... """)
        
        >>> print system(buildout),
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling data-dir
        buildout: Installing data-dir
        data-dir: Creating directory mydata
        
        >>> ls(sample_buildout)
        -  .installed.cfg
        d  bin
        -  buildout.cfg
        d  develop-eggs
        d  eggs
        d  mydata
        d  parts
        d  recipes
        
        If any of the files or directories created by a recipe are removed,
        the part will be reinstalled:
        
        >>> rmdir(sample_buildout, 'mydata')
        >>> print system(buildout),
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling data-dir
        buildout: Installing data-dir
        data-dir: Creating directory mydata
        
        Error reporting
        ---------------
        
        If a user makes an error, an error needs to be printed and work needs
        to stop.  This is accomplished by logging a detailed error message and
        then raising a (or an instance of a subclass of a)
        zc.buildout.UserError exception.  Raising UserError causes the
        buildout to print the error and exit without printing a traceback.  In
        the sample above, of someone gives a non-existant directory to create
        the directory in:
        
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = data-dir
        ...
        ... [data-dir]
        ... recipe = recipes:mkdir
        ... path = /xxx/mydata
        ... """)
        
        We'll get a user error, not a traceback.
        
        >>> print system(buildout),
        buildout: Develop: /sample-buildout/recipes
        data-dir: Cannot create /xxx/mydata. /xxx is not a directory.
        Error: Invalid Path
        
        
        Configuration file syntax
        -------------------------
        
        As mentioned earlier, buildout configuration files use the format
        defined by the Python ConfigParser module with extensions.  The
        extensions are:
        
        - option names are case sensitive
        
        - option values can ue a substitution syntax, described below, to
        refer to option values in specific sections.
        
        The ConfigParser syntax is very flexible.  Section names can contain
        any characters other than newlines and right square braces ("]").
        Option names can contain any characters other than newlines, colons,
        and equal signs, can not start with a space, and don't include
        trailing spaces.
        
        It is likely that, in the future, some characters will be given
        special buildout-defined meanings.  This is already true of the
        characters ":", "$", "%", "(", and ")".  For now, it is a good idea to
        keep section and option names simple, sticking to alphanumeric
        characters, hyphens, and periods.
        
        Variable substitutions
        ----------------------
        
        Buildout configuration files support variable substitution.
        To illustrate this, we'll create an debug recipe to
        allow us to see interactions with the buildout:
        
        >>> write(sample_buildout, 'recipes', 'debug.py',
        ... """
        ... class Debug:
        ...
        ...     def __init__(self, buildout, name, options):
        ...         self.buildout = buildout
        ...         self.name = name
        ...         self.options = options
        ...
        ...     def install(self):
        ...         items = self.options.items()
        ...         items.sort()
        ...         for option, value in items:
        ...             print option, value
        ...         return ()
        ...
        ...     update = install
        ... """)
        
        This recipe doesn't actually create anything. The install method
        doesn't return anything, because it didn't create any files or
        directories.
        
        We also have to update our setup script:
        
        >>> write(sample_buildout, 'recipes', 'setup.py',
        ... """
        ... from setuptools import setup
        ... entry_points = (
        ... '''
        ... [zc.buildout]
        ... mkdir = mkdir:Mkdir
        ... debug = debug:Debug
        ... ''')
        ... setup(name="recipes", entry_points=entry_points)
        ... """)
        
        We've rearranged the script a bit to make the entry points easier to
        edit.  In particular, entry points are now defined as a configuration
        string, rather than a dictionary.
        
        Let's update our configuration to provide variable substitution
        examples:
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = data-dir debug
        ... log-level = INFO
        ...
        ... [debug]
        ... recipe = recipes:debug
        ... File 1 = ${data-dir:path}/file
        ... File 2 = ${debug:File 1}/log
        ...
        ... [data-dir]
        ... recipe = recipes:mkdir
        ... path = mydata
        ... """)
        
        In this example, we've used ConfigParser substitutions for file2 and
        file3.  This type of substitution uses Python string format syntax.
        Valid names are options in the same section and options defined in the
        DEFAULT section.
        
        We used a string-template substitution for file1.  This type of
        substitution uses the string.Template syntax.  Names substituted are
        qualified option names, consisting of a section name and option name
        joined by a colon.
        
        Now, if we run the buildout, we'll see the options with the values
        substituted.
        
        >>> print system(buildout),
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling data-dir
        buildout: Installing data-dir
        data-dir: Creating directory mydata
        buildout: Installing debug
        File 1 /sample-buildout/mydata/file
        File 2 /sample-buildout/mydata/file/log
        recipe recipes:debug
        
        Note that the substitution of the data-dir path option reflects the
        update to the option performed by the mkdir recipe.
        
        It might seem surprising that mydata was created again.  This is
        because we changed our recipes package by adding the debug module.
        The buildout system didn't know if this module could effect the mkdir
        recipe, so it assumed it could and reinstalled mydata.  If we rerun
        the buildout:
        
        >>> print system(buildout),
        buildout: Develop: /sample-buildout/recipes
        buildout: Updating data-dir
        buildout: Updating debug
        File 1 /sample-buildout/mydata/file
        File 2 /sample-buildout/mydata/file/log
        recipe recipes:debug
        
        We can see that mydata was not recreated.
        
        Note that, in this case, we didn't specify a log level, so
        we didn't get output about what the buildout was doing.
        
        Section and option names in variable substitutions are only allowed to
        contain alphanumeric characters, hyphens, periods and spaces. This
        restriction might be relaxed in future releases.
        
        
        Automatic part selection and ordering
        -------------------------------------
        
        When a section with a recipe is refered to, either through variable
        substitution or by an initializing recipe, the section is treated as a
        part and added to the part list before the referencing part.  For
        example, we can leave data-dir out of the parts list:
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = debug
        ... log-level = INFO
        ...
        ... [debug]
        ... recipe = recipes:debug
        ... File 1 = ${data-dir:path}/file
        ... File 2 = ${debug:File 1}/log
        ...
        ... [data-dir]
        ... recipe = recipes:mkdir
        ... path = mydata
        ... """)
        
        
        It will still be treated as a part:
        
        >>> print system(buildout),
        buildout: Develop: /sample-buildout/recipes
        buildout: Updating data-dir
        buildout: Updating debug
        File 1 /sample-buildout/mydata/file
        File 2 /sample-buildout/mydata/file/log
        recipe recipes:debug
        
        >>> cat('.installed.cfg') # doctest: +ELLIPSIS
        [buildout]
        installed_develop_eggs = /sample-buildout/develop-eggs/recipes.egg-link
        parts = data-dir debug
        ...
        
        Note that the data-dir part is included *before* the debug part,
        because the debug part refers to the data-dir part.  Even if we list
        the data-dir part after the debug part, it will be included before:
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = debug data-dir
        ... log-level = INFO
        ...
        ... [debug]
        ... recipe = recipes:debug
        ... File 1 = ${data-dir:path}/file
        ... File 2 = ${debug:File 1}/log
        ...
        ... [data-dir]
        ... recipe = recipes:mkdir
        ... path = mydata
        ... """)
        
        
        It will still be treated as a part:
        
        >>> print system(buildout),
        buildout: Develop: /sample-buildout/recipes
        buildout: Updating data-dir
        buildout: Updating debug
        File 1 /sample-buildout/mydata/file
        File 2 /sample-buildout/mydata/file/log
        recipe recipes:debug
        
        >>> cat('.installed.cfg') # doctest: +ELLIPSIS
        [buildout]
        installed_develop_eggs = /sample-buildout/develop-eggs/recipes.egg-link
        parts = data-dir debug
        ...
        
        Multiple configuration files
        ----------------------------
        
        A configuration file can "extend" another configuration file.
        Options are read from the other configuration file if they aren't
        already defined by your configuration file.
        
        The configuration files your file extends can extend
        other configuration files.  The same file may be
        used more than once although, of course, cycles aren't allowed.
        
        To see how this works, we use an example:
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... extends = base.cfg
        ...
        ... [debug]
        ... op = buildout
        ... """)
        
        >>> write(sample_buildout, 'base.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = debug
        ...
        ... [debug]
        ... recipe = recipes:debug
        ... op = base
        ... """)
        
        >>> print system(buildout),
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling debug
        buildout: Uninstalling data-dir
        buildout: Installing debug
        op buildout
        recipe recipes:debug
        
        The example is pretty trivial, but the pattern it illustrates is
        pretty common.  In a more practical example, the base buildout might
        represent a product and the extending buildout might be a
        customization.
        
        Here is a more elaborate example.
        
        >>> other = tmpdir('other')
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... extends = b1.cfg b2.cfg %(b3)s
        ...
        ... [debug]
        ... op = buildout
        ... """ % dict(b3=os.path.join(other, 'b3.cfg')))
        
        >>> write(sample_buildout, 'b1.cfg',
        ... """
        ... [buildout]
        ... extends = base.cfg
        ...
        ... [debug]
        ... op1 = b1 1
        ... op2 = b1 2
        ... """)
        
        >>> write(sample_buildout, 'b2.cfg',
        ... """
        ... [buildout]
        ... extends = base.cfg
        ...
        ... [debug]
        ... op2 = b2 2
        ... op3 = b2 3
        ... """)
        
        >>> write(other, 'b3.cfg',
        ... """
        ... [buildout]
        ... extends = b3base.cfg
        ...
        ... [debug]
        ... op4 = b3 4
        ... """)
        
        >>> write(other, 'b3base.cfg',
        ... """
        ... [debug]
        ... op5 = b3base 5
        ... """)
        
        >>> write(sample_buildout, 'base.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = debug
        ...
        ... [debug]
        ... recipe = recipes:debug
        ... name = base
        ... """)
        
        >>> print system(buildout),
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling debug
        buildout: Installing debug
        name base
        op buildout
        op1 b1 1
        op2 b2 2
        op3 b2 3
        op4 b3 4
        op5 b3base 5
        recipe recipes:debug
        
        There are several things to note about this example:
        
        - We can name multiple files in an extends option.
        
        - We can reference files recursively.
        
        - Relative file names in extended options are interpreted relative to
        the directory containing the referencing configuration file.
        
        Loading Configuration from URLs
        -------------------------------
        
        Configuration files can be loaded from URLs.  To see how this works,
        we'll set up a web server with some configuration files.
        
        >>> server_data = tmpdir('server_data')
        
        >>> write(server_data, "r1.cfg",
        ... """
        ... [debug]
        ... op1 = r1 1
        ... op2 = r1 2
        ... """)
        
        >>> write(server_data, "r2.cfg",
        ... """
        ... [buildout]
        ... extends = r1.cfg
        ...
        ... [debug]
        ... op2 = r2 2
        ... op3 = r2 3
        ... """)
        
        >>> server_url = start_server(server_data)
        
        >>> write('client.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = debug
        ... extends = %(url)s/r2.cfg
        ...
        ... [debug]
        ... recipe = recipes:debug
        ... name = base
        ... """ % dict(url=server_url))
        
        
        >>> print system(buildout+ ' -c client.cfg'),
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling debug
        buildout: Installing debug
        name base
        op1 r1 1
        op2 r2 2
        op3 r2 3
        recipe recipes:debug
        
        Here we specified a URL for the file we extended.  The file we
        downloaded, itself refered to a file on the server using a relative
        URL reference.  Relative references are interpreted relative to the
        base URL when they appear in configuration files loaded via URL.
        
        We can also specify a URL as the configuration file to be used by a
        buildout.
        
        >>> os.remove('client.cfg')
        >>> write(server_data, 'remote.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = debug
        ... extends = r2.cfg
        ...
        ... [debug]
        ... recipe = recipes:debug
        ... name = remote
        ... """)
        
        >>> print system(buildout + ' -c ' + server_url + '/remote.cfg'),
        Error: Missing option: buildout:directory
        
        Normally, the buildout directory defaults to directory
        containing a configuration file.  This won't work for configuration
        files loaded from URLs.  In this case, the buildout directory would
        normally be defined on the command line:
        
        >>> print system(buildout
        ...              + ' -c ' + server_url + '/remote.cfg'
        ...              + ' buildout:directory=' + sample_buildout
        ...              ),
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling debug
        buildout: Installing debug
        name remote
        op1 r1 1
        op2 r2 2
        op3 r2 3
        recipe recipes:debug
        
        User defaults
        -------------
        
        If the file $HOME/.buildout/defaults.cfg, exists, it is read before
        reading the configuration file.  ($HOME is the value of the HOME
        environment variable. The '/' is replaced by the operating system file
        delimiter.)
        
        >>> home = tmpdir('home')
        >>> mkdir(home, '.buildout')
        >>> write(home, '.buildout', 'default.cfg',
        ... """
        ... [debug]
        ... op1 = 1
        ... op7 = 7
        ... """)
        
        >>> os.environ['HOME'] = home
        >>> print system(buildout),
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling debug
        buildout: Installing debug
        name base
        op buildout
        op1 b1 1
        op2 b2 2
        op3 b2 3
        op4 b3 4
        op5 b3base 5
        op7 7
        recipe recipes:debug
        
        A buildout command-line argument, -U, can be used to suppress reading
        user defaults:
        
        >>> print system(buildout + ' -U'),
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling debug
        buildout: Installing debug
        name base
        op buildout
        op1 b1 1
        op2 b2 2
        op3 b2 3
        op4 b3 4
        op5 b3base 5
        recipe recipes:debug
        
        >>> del os.environ['HOME']
        
        Log level
        ---------
        
        We can control the level of logging by specifying a log level in out
        configuration file.  For example, so suppress info messages, we can
        set the logging level to WARNING
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... log-level = WARNING
        ... extends = b1.cfg b2.cfg
        ... """)
        
        >>> print system(buildout),
        name base
        op1 b1 1
        op2 b2 2
        op3 b2 3
        recipe recipes:debug
        
        Uninstall recipes
        -----------------
        
        As we've seen, when parts are installed, buildout keeps track of files
        and directories that they create. When the parts are uninstalled these
        files and directories are deleted.
        
        Sometimes more clean up is needed. For example, a recipe might add a
        system service by calling chkconfig --add during installation. Later
        during uninstallation, chkconfig --del will need to be called to
        remove the system service.
        
        In order to deal with these uninstallation issues, you can register
        uninstall recipes. Uninstall recipes are registered using the
        'zc.buildout.uninstall' entry point. Parts specify uninstall recipes
        using the 'uninstall' option.
        
        In comparison to regular recipes, uninstall recipes are much
        simpler. They are simply callable objects that accept the name of the
        part to be uninstalled and the part's options dictionary. Uninstall
        recipes don't have access to the part itself since it maybe not be
        able to be instantiated at uninstallation time.
        
        Here's a recipe that simulates installation of a system service, along
        with an uninstall recipe that simulates removing the service.
        
        >>> write(sample_buildout, 'recipes', 'service.py',
        ... """
        ... class Service:
        ...
        ...     def __init__(self, buildout, name, options):
        ...         self.buildout = buildout
        ...         self.name = name
        ...         self.options = options
        ...
        ...     def install(self):
        ...         print "chkconfig --add %s" % self.options['script']
        ...         return ()
        ...
        ...     def update(self):
        ...         pass
        ...
        ...
        ... def uninstall_service(name, options):
        ...     print "chkconfig --del %s" % options['script']
        ... """)
        
        To use these recipes we must register them using entry points. Make
        sure to use the same name for the recipe and uninstall recipe. This is
        required to let buildout know which uninstall recipe goes with which
        recipe.
        
        >>> write(sample_buildout, 'recipes', 'setup.py',
        ... """
        ... from setuptools import setup
        ... entry_points = (
        ... '''
        ... [zc.buildout]
        ... mkdir = mkdir:Mkdir
        ... debug = debug:Debug
        ... service = service:Service
        ...
        ... [zc.buildout.uninstall]
        ... service = service:uninstall_service
        ... ''')
        ... setup(name="recipes", entry_points=entry_points)
        ... """)
        
        Here's how these recipes could be used in a buildout:
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = service
        ...
        ... [service]
        ... recipe = recipes:service
        ... script = /path/to/script
        ... """)
        
        When the buildout is run the service will be installed
        
        >>> print system(buildout)
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling debug
        buildout: Installing service
        chkconfig --add /path/to/script
        <BLANKLINE>
        
        The service has been installed. If the buildout is run again with no
        changes, the serivce shouldn't be changed.
        
        >>> print system(buildout)
        buildout: Develop: /sample-buildout/recipes
        buildout: Updating service
        <BLANKLINE>
        
        Now we change the service part to trigger uninstallation and
        re-installation.
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = service
        ...
        ... [service]
        ... recipe = recipes:service
        ... script = /path/to/a/different/script
        ... """)
        
        >>> print system(buildout)
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling service
        buildout: Running uninstall recipe
        chkconfig --del /path/to/script
        buildout: Installing service
        chkconfig --add /path/to/a/different/script
        <BLANKLINE>
        
        Now we remove the service part, and add another part.
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = debug
        ...
        ... [debug]
        ... recipe = recipes:debug
        ... """)
        
        >>> print system(buildout)
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling service
        buildout: Running uninstall recipe
        chkconfig --del /path/to/a/different/script
        buildout: Installing debug
        recipe recipes:debug
        <BLANKLINE>
        
        Uninstall recipes don't have to take care of removing all the files
        and directories created by the part. This is still done automatically,
        following the execution of the uninstall recipe. An upshot is that an
        uninstallation recipe can access files and directories created by a
        recipe before they are deleted.
        
        For example, here's an uninstallation recipe that simulates backing up
        a directory before it is deleted. It is designed to work with the
        mkdir recipe introduced earlier.
        
        >>> write(sample_buildout, 'recipes', 'backup.py',
        ... """
        ... import os
        ... def backup_directory(name, options):
        ...     path = options['path']
        ...     size = len(os.listdir(path))
        ...     print "backing up directory %s of size %s" % (path, size)
        ... """)
        
        It must be registered with the zc.buildout.uninstall entry
        point. Notice how it is given the name 'mkdir' to associate it with
        the mkdir recipe.
        
        >>> write(sample_buildout, 'recipes', 'setup.py',
        ... """
        ... from setuptools import setup
        ... entry_points = (
        ... '''
        ... [zc.buildout]
        ... mkdir = mkdir:Mkdir
        ... debug = debug:Debug
        ... service = service:Service
        ...
        ... [zc.buildout.uninstall]
        ... uninstall_service = service:uninstall_service
        ... mkdir = backup:backup_directory
        ... ''')
        ... setup(name="recipes", entry_points=entry_points)
        ... """)
        
        Now we can use it with a mkdir part.
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = dir debug
        ...
        ... [dir]
        ... recipe = recipes:mkdir
        ... path = my_directory
        ...
        ... [debug]
        ... recipe = recipes:debug
        ... """)
        
        Run the buildout to install the part.
        
        >>> print system(buildout)
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling debug
        buildout: Installing dir
        dir: Creating directory my_directory
        buildout: Installing debug
        recipe recipes:debug
        <BLANKLINE>
        
        Now we remove the part from the configuration file.
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = debug
        ...
        ... [debug]
        ... recipe = recipes:debug
        ... """)
        
        When the buildout is run the part is removed, and the uninstall recipe
        is run before the directory is deleted.
        
        >>> print system(buildout)
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling dir
        buildout: Running uninstall recipe
        backing up directory /sample-buildout/my_directory of size 0
        buildout: Updating debug
        recipe recipes:debug
        <BLANKLINE>
        
        Now we will return the registeration to normal for the benefit of the
        rest of the examples.
        
        >>> write(sample_buildout, 'recipes', 'setup.py',
        ... """
        ... from setuptools import setup
        ... entry_points = (
        ... '''
        ... [zc.buildout]
        ... mkdir = mkdir:Mkdir
        ... debug = debug:Debug
        ... ''')
        ... setup(name="recipes", entry_points=entry_points)
        ... """)
        
        
        Command-line usage
        ------------------
        
        A number of arguments can be given on the buildout command line.  The
        command usage is::
        
        buildout [options and assignments] [command [command arguments]]
        
        The following options are supported:
        
        -h (or --help)
        Print basic usage information.  If this option is used, then all
        other options are ignored.
        
        -c filename
        The -c option can be used to specify a configuration file, rather than
        buildout.cfg in the current directory.
        
        -v
        Increment the verbosity by 10.  The verbosity is used to adjust
        the logging level.  The verbosity is subtracted from the numeric
        value of the log-level option specified in the configuration file.
        
        -q
        Decrement the verbosity by 10.
        
        -U
        Don't read user-default configuration.
        
        -o
        Run in off-line mode.  This is equivalent to the assignment
        buildout:offline=true.
        
        -O
        Run in non-off-line mode.  This is equivalent to the assignment
        buildout:offline=false.  This is the default buildout mode.  The
        -O option would normally be used to override a true offline
        setting in a configuration file.
        
        -n
        Run in newest mode.  This is equivalent to the assignment
        buildout:newest=true.  With this setting, which is the default,
        buildout will try to find the newest versions of distributions
        available that satisfy its requirements.
        
        -N
        Run in non-newest mode.  This is equivalent to the assignment
        buildout:newest=false.  With this setting, buildout will not seek
        new distributions if installed distributions satisfy it's
        requirements.
        
        Assignments are of the form::
        
        section_name:option_name=value
        
        Options and assignments can be given in any order.
        
        Here's an example:
        
        >>> write(sample_buildout, 'other.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = debug
        ... installed = .other.cfg
        ... log-level = WARNING
        ...
        ... [debug]
        ... name = other
        ... recipe = recipes:debug
        ... """)
        
        Note that we used the installed buildout option to specify an
        alternate file to store information about installed parts.
        
        >>> print system(buildout+' -c other.cfg debug:op1=foo -v'),
        buildout: Develop: /sample-buildout/recipes
        buildout: Installing debug
        name other
        op1 foo
        recipe recipes:debug
        
        Here we used the -c option to specify an alternate configuration file,
        and the -v option to increase the level of logging from the default,
        WARNING.
        
        Options can also be combined in the usual Unix way, as in:
        
        >>> print system(buildout+' -vcother.cfg debug:op1=foo'),
        buildout: Develop: /sample-buildout/recipes
        buildout: Updating debug
        name other
        op1 foo
        recipe recipes:debug
        
        Here we combined the -v and -c options with the configuration file
        name.  Note that the -c option has to be last, because it takes an
        argument.
        
        >>> os.remove(os.path.join(sample_buildout, 'other.cfg'))
        >>> os.remove(os.path.join(sample_buildout, '.other.cfg'))
        
        The most commonly used command is 'install' and it takes a list of
        parts to install. if any parts are specified, only those parts are
        installed.  To illustrate this, we'll update our configuration and run
        the buildout in the usual way:
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = debug d1 d2 d3
        ...
        ... [d1]
        ... recipe = recipes:mkdir
        ... path = d1
        ...
        ... [d2]
        ... recipe = recipes:mkdir
        ... path = d2
        ...
        ... [d3]
        ... recipe = recipes:mkdir
        ... path = d3
        ...
        ... [debug]
        ... recipe = recipes:debug
        ... """)
        
        >>> print system(buildout),
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling debug
        buildout: Installing debug
        recipe recipes:debug
        buildout: Installing d1
        d1: Creating directory d1
        buildout: Installing d2
        d2: Creating directory d2
        buildout: Installing d3
        d3: Creating directory d3
        
        >>> ls(sample_buildout)
        -  .installed.cfg
        -  b1.cfg
        -  b2.cfg
        -  base.cfg
        d  bin
        -  buildout.cfg
        d  d1
        d  d2
        d  d3
        d  develop-eggs
        d  eggs
        d  parts
        d  recipes
        
        >>> cat(sample_buildout, '.installed.cfg')
        [buildout]
        installed_develop_eggs = /sample-buildout/develop-eggs/recipes.egg-link
        parts = debug d1 d2 d3
        <BLANKLINE>
        [debug]
        __buildout_installed__ =
        __buildout_signature__ = recipes-PiIFiO8ny5yNZ1S3JfT0xg==
        recipe = recipes:debug
        <BLANKLINE>
        [d1]
        __buildout_installed__ = /sample-buildout/d1
        __buildout_signature__ = recipes-PiIFiO8ny5yNZ1S3JfT0xg==
        path = /sample-buildout/d1
        recipe = recipes:mkdir
        <BLANKLINE>
        [d2]
        __buildout_installed__ = /sample-buildout/d2
        __buildout_signature__ = recipes-PiIFiO8ny5yNZ1S3JfT0xg==
        path = /sample-buildout/d2
        recipe = recipes:mkdir
        <BLANKLINE>
        [d3]
        __buildout_installed__ = /sample-buildout/d3
        __buildout_signature__ = recipes-PiIFiO8ny5yNZ1S3JfT0xg==
        path = /sample-buildout/d3
        recipe = recipes:mkdir
        
        Now we'll update our configuration file:
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts = debug d2 d3 d4
        ...
        ... [d2]
        ... recipe = recipes:mkdir
        ... path = data2
        ...
        ... [d3]
        ... recipe = recipes:mkdir
        ... path = data3
        ...
        ... [d4]
        ... recipe = recipes:mkdir
        ... path = ${d2:path}-extra
        ...
        ... [debug]
        ... recipe = recipes:debug
        ... x = 1
        ... """)
        
        and run the buildout specifying just d3 and d4:
        
        >>> print system(buildout+' install d3 d4'),
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling d3
        buildout: Installing d3
        d3: Creating directory data3
        buildout: Installing d4
        d4: Creating directory data2-extra
        
        >>> ls(sample_buildout)
        -  .installed.cfg
        -  b1.cfg
        -  b2.cfg
        -  base.cfg
        d  bin
        -  buildout.cfg
        d  d1
        d  d2
        d  data2-extra
        d  data3
        d  develop-eggs
        d  eggs
        d  parts
        d  recipes
        
        Only the d3 and d4 recipes ran.  d3 was removed and data3 and data2-extra
        were created.
        
        The .installed.cfg is only updated for the recipes that ran:
        
        >>> cat(sample_buildout, '.installed.cfg')
        [buildout]
        installed_develop_eggs = /sample-buildout/develop-eggs/recipes.egg-link
        parts = debug d1 d2 d3 d4
        <BLANKLINE>
        [debug]
        __buildout_installed__ =
        __buildout_signature__ = recipes-PiIFiO8ny5yNZ1S3JfT0xg==
        recipe = recipes:debug
        <BLANKLINE>
        [d1]
        __buildout_installed__ = /sample-buildout/d1
        __buildout_signature__ = recipes-PiIFiO8ny5yNZ1S3JfT0xg==
        path = /sample-buildout/d1
        recipe = recipes:mkdir
        <BLANKLINE>
        [d2]
        __buildout_installed__ = /sample-buildout/d2
        __buildout_signature__ = recipes-PiIFiO8ny5yNZ1S3JfT0xg==
        path = /sample-buildout/d2
        recipe = recipes:mkdir
        <BLANKLINE>
        [d3]
        __buildout_installed__ = /sample-buildout/data3
        __buildout_signature__ = recipes-PiIFiO8ny5yNZ1S3JfT0xg==
        path = /sample-buildout/data3
        recipe = recipes:mkdir
        <BLANKLINE>
        [d4]
        __buildout_installed__ = /sample-buildout/data2-extra
        __buildout_signature__ = recipes-PiIFiO8ny5yNZ1S3JfT0xg==
        path = /sample-buildout/data2-extra
        recipe = recipes:mkdir
        
        Note that the installed data for debug, d1, and d2 haven't changed,
        because we didn't install those parts and that the d1 and d2
        directories are still there.
        
        Now, if we run the buildout without the install command:
        
        >>> print system(buildout),
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling d2
        buildout: Uninstalling d1
        buildout: Uninstalling debug
        buildout: Installing debug
        recipe recipes:debug
        x 1
        buildout: Installing d2
        d2: Creating directory data2
        buildout: Updating d3
        buildout: Updating d4
        
        We see the output of the debug recipe and that data2 was created.  We
        also see that d1 and d2 have gone away:
        
        >>> ls(sample_buildout)
        -  .installed.cfg
        -  b1.cfg
        -  b2.cfg
        -  base.cfg
        d  bin
        -  buildout.cfg
        d  data2
        d  data2-extra
        d  data3
        d  develop-eggs
        d  eggs
        d  parts
        d  recipes
        
        Alternate directory and file locations
        --------------------------------------
        
        The buildout normally puts the bin, eggs, and parts directories in the
        directory in the directory containing the configuration file. You can
        provide alternate locations, and even names for these directories.
        
        >>> alt = tmpdir('sample-alt')
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts =
        ... develop-eggs-directory = %(developbasket)s
        ... eggs-directory = %(basket)s
        ... bin-directory = %(scripts)s
        ... parts-directory = %(work)s
        ... """ % dict(
        ...    developbasket = os.path.join(alt, 'developbasket'),
        ...    basket = os.path.join(alt, 'basket'),
        ...    scripts = os.path.join(alt, 'scripts'),
        ...    work = os.path.join(alt, 'work'),
        ... ))
        
        >>> print system(buildout),
        buildout: Creating directory /sample-alt/scripts
        buildout: Creating directory /sample-alt/work
        buildout: Creating directory /sample-alt/basket
        buildout: Creating directory /sample-alt/developbasket
        buildout: Develop: /sample-buildout/recipes
        buildout: Uninstalling d4
        buildout: Uninstalling d3
        buildout: Uninstalling d2
        buildout: Uninstalling debug
        
        >>> ls(alt)
        d  basket
        d  developbasket
        d  scripts
        d  work
        
        >>> ls(alt, 'developbasket')
        -  recipes.egg-link
        
        You can also specify an alternate buildout directory:
        
        >>> rmdir(alt)
        >>> alt = tmpdir('sample-alt')
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... directory = %(alt)s
        ... develop = %(recipes)s
        ... parts =
        ... """ % dict(
        ...    alt=alt,
        ...    recipes=os.path.join(sample_buildout, 'recipes'),
        ...    ))
        
        >>> print system(buildout),
        buildout: Creating directory /sample-alt/bin
        buildout: Creating directory /sample-alt/parts
        buildout: Creating directory /sample-alt/eggs
        buildout: Creating directory /sample-alt/develop-eggs
        buildout: Develop: /sample-buildout/recipes
        
        >>> ls(alt)
        -  .installed.cfg
        d  bin
        d  develop-eggs
        d  eggs
        d  parts
        
        >>> ls(alt, 'develop-eggs')
        -  recipes.egg-link
        
        Logging control
        ---------------
        
        Three buildout options are used to control logging:
        
        log-level
        specifies the log level
        
        verbosity
        adjusts the log level
        
        log-format
        allows an alternate logging for mat to be specified
        
        We've already seen the log level and verbosity.  Let's look at an example
        of changing the format:
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = recipes
        ... parts =
        ... log-level = 25
        ... verbosity = 5
        ... log-format = %(levelname)s %(message)s
        ... """)
        
        Here, we've changed the format to include the log-level name, rather
        than the logger name.
        
        We've also illustrated, with a contrived example, that the log level
        can be a numeric value and that the verbosity can be specified in the
        configuration file.  Because the verbosity is subtracted from the log
        level, we get a final log level of 20, which is the INFO level.
        
        >>> print system(buildout),
        INFO Develop: /sample-buildout/recipes
        
        Predefined buildout options
        ---------------------------
        
        Buildouts have a number of predefined options that recipes can use
        and that users can override in their configuration files.  To see
        these, we'll run a minimal buildout configuration with a debug logging
        level.  One of the features of debug logging is that the configuration
        database is shown.
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... parts =
        ... """)
        
        >>> print system(buildout+' -v'),
        zc.buildout.easy_install: Installing ['zc.buildout', 'setuptools']
        zc.buildout.easy_install: We have a develop egg for zc.buildout
        zc.buildout.easy_install: We have the best distribution that satisfies
        setuptools
        <BLANKLINE>
        Configuration data:
        [buildout]
        bin-directory = /sample-buildout/bin
        develop-eggs-directory = /sample-buildout/develop-eggs
        directory = /sample-buildout
        eggs-directory = /sample-buildout/eggs
        executable = /usr/local/bin/python2.3
        installed = /sample-buildout/.installed.cfg
        log-format = %(name)s: %(message)s
        log-level = INFO
        newest = true
        offline = false
        parts =
        parts-directory = /sample-buildout/parts
        python = buildout
        verbosity = 10
        <BLANKLINE>
        
        All of these options can be overridden by configuration files or by
        command-line assignments.  We've discussed most of these options
        already, but let's review them and touch on some we haven't discussed:
        
        bin-directory
        The directory path where scripts are written.  This can be a
        relative path, which is interpreted relative to the directory
        option.
        
        develop-eggs-directory
        The directory path where development egg links are created for software
        being created in the local project.  This can be a relative path,
        which is interpreted relative to the directory option.
        
        directory
        The buildout directory.  This is the base for other buildout file
        and directory locations, when relative locations are used.
        
        eggs-directory
        The directory path where downloaded eggs are put.  It is common to share
        this directory across buildouts. Eggs in this directory should
        *never* be modified.  This can be a relative path, which is
        interpreted relative to the directory option.
        
        executable
        The Python executable used to run the buildout.  See the python
        option below.
        
        installed
        The file path where information about the results of the previous
        buildout run is written.  This can be a relative path, which is
        interpreted relative to the directory option.  This file provides
        an inventory of installed parts with information needed to decide
        which if any parts need to be uninstalled.
        
        log-format
        The format used for logging messages.
        
        log-level
        The log level before verbosity adjustment
        
        parts
        A white space separated list of parts to be installed.
        
        parts-directory
        A working directory that parts can used to store data.
        
        python
        The name of a section containing information about the default
        Python interpreter.  Recipes that need a installation
        typically have options to tell them which Python installation to
        use.  By convention, if a section-specific option isn't used, the
        option is looked for in the buildout section.  The option must
        point to a section with an executable option giving the path to a
        Python executable.  By default, the buildout section defines the
        default Python as the Python used to run the buildout.
        
        verbosity
        A log-level adjustment.  Typically, this is set via the -q and -v
        command-line options.
        
        
        Bootstrapping
        -------------
        
        If zc.buildout is installed, you can use it to create a new buildout
        with it's own local copies of zc.buildout and setuptools and with
        local buildout scripts.
        
        >>> sample_bootstrapped = tmpdir('sample-bootstrapped')
        
        >>> print system(buildout
        ...              +' -c'+os.path.join(sample_bootstrapped, 'setup.cfg')
        ...              +' bootstrap'),
        Warning: creating /sample-bootstrapped/setup.cfg
        buildout: Creating directory /sample-bootstrapped/bin
        buildout: Creating directory /sample-bootstrapped/parts
        buildout: Creating directory /sample-bootstrapped/eggs
        buildout: Creating directory /sample-bootstrapped/develop-eggs
        
        Note that a basic setup.cfg was created for us.
        
        >>> ls(sample_bootstrapped)
        d  bin
        d  develop-eggs
        d  eggs
        d  parts
        -  setup.cfg
        
        >>> ls(sample_bootstrapped, 'bin')
        -  buildout
        
        >>> _ = (ls(sample_bootstrapped, 'eggs'),
        ...      ls(sample_bootstrapped, 'develop-eggs'))
        -  setuptools-0.6-py2.3.egg
        -  zc.buildout-1.0-py2.3.egg
        
        (We list both the eggs and develop-eggs diectories because the
        buildout or setuptools egg could be installed in the develop-eggs
        directory if the original buildout had develop eggs for either
        buildout or setuptools.)
        
        Note that the buildout script was installed but not run.  To run
        the buildout, we'd have to run the installed buildout script.
        
        Newest and Offline Modes
        ------------------------
        
        By default buildout and recipes will try to find the newest versions
        of distributions needed to satisfy requirements.  This can be very
        time consuming, especially when incrementally working on setting up a
        buildout or working on a recipe.  The buildout newest option can be
        used to to suppress this.  If the newest option is set to false, then
        new distributions won't be sought if an installed distribution meets
        requirements.  The newest option can be set to false using the -N
        command-line option.
        
        The offline option goes a bit further.  If the buildout offline option
        is given a value of "true", the buildout and recipes that are aware of
        the option will avoid doing network access.  This is handy when
        running the buildout when not connected to the internet.  It also
        makes buildouts run much faster. This option is typically set using
        the buildout -o option.
        
        Controlling the installation database
        -------------------------------------
        
        The buildout installed uption is used to specify the file used to save
        information on installed parts.  This option is initialized to
        ".installed.cfg", but it can be overridded in the configuration file
        or on the command line:
        
        >>> os.remove('.installed.cfg')
        >>> print system(buildout+' buildout:installed=inst.cfg'),
        
        >>> ls(sample_buildout)
        -  b1.cfg
        -  b2.cfg
        -  base.cfg
        d  bin
        -  buildout.cfg
        d  develop-eggs
        d  eggs
        -  inst.cfg
        d  parts
        d  recipes
        
        
        The installation database can be disabled by supplying an empty
        buildout installed opttion:
        
        >>> os.remove('inst.cfg')
        >>> print system(buildout+' buildout:installed='),
        
        >>> ls(sample_buildout)
        -  b1.cfg
        -  b2.cfg
        -  base.cfg
        d  bin
        -  buildout.cfg
        d  develop-eggs
        d  eggs
        d  parts
        d  recipes
        
        
        Extensions
        ----------
        
        An **experimental** feature allows code to be loaded and run after
        configuration files have been read but before the buildout has begun
        any processing.  The intent is to allow special plugins such as
        urllib2 request handlers to be loaded.
        
        To load an extension, we use the extensions option and list one or
        more distribution requirements, on separate lines.  The distributions
        named will be loaded and any zc.buildout.extensions entry points found
        will be called with the buildout as an argument.
        
        Let's create a sample extension in out sample buildout created in the
        previous section:
        
        >>> mkdir(sample_bootstrapped, 'demo')
        
        >>> write(sample_bootstrapped, 'demo', 'demo.py',
        ... """
        ... def ext(buildout):
        ...     print 'ext', list(buildout)
        ... """)
        
        >>> write(sample_bootstrapped, 'demo', 'setup.py',
        ... """
        ... from setuptools import setup
        ...
        ... setup(
        ...     name = "demo",
        ...     entry_points = {'zc.buildout.extension': ['ext = demo:ext']},
        ...     )
        ... """)
        
        Our extension just prints out the word 'demo', and lists the sections
        found in the buildout passed to it.
        
        We'll update our buildout.cfg to list the demo directory as a develop
        egg to be built:
        
        >>> write(sample_bootstrapped, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = demo
        ... parts =
        ... """)
        
        >>> os.chdir(sample_bootstrapped)
        >>> print system(os.path.join(sample_bootstrapped, 'bin', 'buildout')),
        buildout: Develop: /sample-bootstrapped/demo
        
        Now we can add the extensions option.  We were a bit tricly and ran
        the buildout once with the demo develop egg defined but without the
        extension option.  This is because extensions are loaded before the
        buildout creates develop eggs. We needed to use a separate buildout
        run to create the develop egg.  Normally, when eggs are loaded from
        the network, we wouldn't need to do anything special.
        
        >>> write(sample_bootstrapped, 'buildout.cfg',
        ... """
        ... [buildout]
        ... develop = demo
        ... extensions = demo
        ... parts =
        ... """)
        
        We see that our extension is loaded and executed:
        
        >>> print system(os.path.join(sample_bootstrapped, 'bin', 'buildout')),
        ext ['buildout']
        buildout: Develop: /sample-bootstrapped/demo
        
        
        
        .. [#future_recipe_methods] In the future, additional mathods may be
        added. Older recipes with fewer methods will still be
        supported.
        
        .. [#packaging_info] If we wanted to create a distribution from this
        package, we would need specify much more information.  See the
        `setuptools documentation
        <http://peak.telecommunity.com/DevCenter/setuptools>`_.
        
        Automatic Buildout Updates
        ==========================
        
        When a buildout is run, one of the first steps performed is to check
        for updates to either zc.buildout or setuptools.  To demonstrate this,
        we've creates some "new releases" of buildout and setuptools in a
        new_releases folder:
        
        >>> ls(new_releases)
        d  setuptools
        -  setuptools-99.99-py2.4.egg
        d  zc.buildout
        -  zc.buildout-99.99-py2.4.egg
        
        Let's update the sample buildout.cfg to look in this area:
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... find-links = %(new_releases)s
        ... index = %(new_releases)s
        ... parts = show-versions
        ... develop = showversions
        ...
        ... [show-versions]
        ... recipe = showversions
        ... """ % dict(new_releases=new_releases))
        
        We'll also include a recipe that echos the versions of setuptools and
        zc.buildout used:
        
        >>> mkdir(sample_buildout, 'showversions')
        
        >>> write(sample_buildout, 'showversions', 'showversions.py',
        ... """
        ... import pkg_resources
        ...
        ... class Recipe:
        ...
        ...     def __init__(self, buildout, name, options):
        ...         pass
        ...
        ...     def install(self):
        ...         for project in 'zc.buildout', 'setuptools':
        ...             req = pkg_resources.Requirement.parse(project)
        ...             print project, pkg_resources.working_set.find(req).version
        ...         return ()
        ...     update = install
        ... """)
        
        
        >>> write(sample_buildout, 'showversions', 'setup.py',
        ... """
        ... from setuptools import setup
        ...
        ... setup(
        ...     name = "showversions",
        ...     entry_points = {'zc.buildout': ['default = showversions:Recipe']},
        ...     )
        ... """)
        
        
        Now if we run the buildout, the buildout will upgrade itself to the
        new versions found in new releases:
        
        >>> print system(buildout),
        zc.buildout.easy_install: Getting new distribution for zc.buildout
        zc.buildout.easy_install: Got zc.buildout 99.99
        zc.buildout.easy_install: Getting new distribution for setuptools
        zc.buildout.easy_install: Got setuptools 99.99
        buildout: Upgraded:
        zc.buildout version 99.99,
        setuptools version 99.99;
        restarting.
        buildout: Develop: /sample-buildout/showversions
        buildout: Installing show-versions
        zc.buildout 99.99
        setuptools 99.99
        
        Our buildout script has been updated to use the new eggs:
        
        >>> cat(sample_buildout, 'bin', 'buildout')
        #!/usr/local/bin/python2.4
        <BLANKLINE>
        import sys
        sys.path[0:0] = [
        '/sample-buildout/eggs/zc.buildout-99.99-py2.4.egg',
        '/sample-buildout/eggs/setuptools-99.99-py2.4.egg',
        ]
        <BLANKLINE>
        import zc.buildout.buildout
        <BLANKLINE>
        if __name__ == '__main__':
        zc.buildout.buildout.main()
        
        There are a number of cases in which the updates don't happen.
        Let's recreate the sample buildout. One case is the one in which we
        specify versions of zc.buildout and setuptools for which the don't
        match. If we update out configuration file to specify an older
        version:
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... find-links = %(new_releases)s
        ... index = %(new_releases)s
        ... parts = show-versions
        ... develop = showversions
        ... zc.buildout-version = < 99
        ... setuptools-version = < 99
        ...
        ... [show-versions]
        ... recipe = showversions
        ... """ % dict(new_releases=new_releases))
        
        We'll actually "upgrade" to an earlier version.
        
        >>> print system(buildout),
        buildout: Upgraded:
        zc.buildout version 1.0.0,
        setuptools version 0.6;
        restarting.
        buildout: Develop: /sample-buildout/showversions
        buildout: Updating show-versions
        zc.buildout 1.0.0
        setuptools 0.6
        
        We won't upgrade in offline mode:
        
        >>> write(sample_buildout, 'buildout.cfg',
        ... """
        ... [buildout]
        ... find-links = %(new_releases)s
        ... index = %(new_releases)s
        ... parts = show-versions
        ... develop = showversions
        ...
        ... [show-versions]
        ... recipe = showversions
        ... """ % dict(new_releases=new_releases))
        
        >>> print system(buildout+' -o'),
        buildout: Develop: /sample-buildout/showversions
        buildout: Updating show-versions
        zc.buildout 1.0.0
        setuptools 0.6
        
        Or in non-newest mode:
        
        >>> print system(buildout+' -N'),
        buildout: Develop: /sample-buildout/showversions
        buildout: Updating show-versions
        zc.buildout 1.0.0
        setuptools 0.6
        
        We also won't upgrade if the buildout script bing run isn't in the
        buildouts bin directory.  To see this we'll create a new buildout
        directory:
        
        >>> sample_buildout2 = tmpdir('sample_buildout2')
        >>> write(sample_buildout2, 'buildout.cfg',
        ... """
        ... [buildout]
        ... find-links = %(new_releases)s
        ... index = %(new_releases)s
        ... parts =
        ... """ % dict(new_releases=new_releases))
        
        >>> cd(sample_buildout2)
        >>> print system(buildout),
        buildout: Creating directory /sample_buildout2/bin
        buildout: Creating directory /sample_buildout2/parts
        buildout: Creating directory /sample_buildout2/eggs
        buildout: Creating directory /sample_buildout2/develop-eggs
        zc.buildout.easy_install: Getting new distribution for zc.buildout
        zc.buildout.easy_install: Got zc.buildout 99.99
        zc.buildout.easy_install: Getting new distribution for setuptools
        zc.buildout.easy_install: Got setuptools 99.99
        buildout: Not upgrading because not running a local buildout command
        
        >>> ls('bin')
        
        Testing Support
        ===============
        
        The zc.buildout.testing module provides an API that can be used when
        writing recipe tests.  This API is documented below.  Many examples of
        using this API can be found in the zc.buildout, zc.recipe.egg, and
        zc.recipe.testrunner tests.
        
        zc.buildout.testing.buildoutSetUp(test)
        ---------------------------------------
        
        The buildoutSetup function can be used as a doctest setup function.
        It creates a sample buildout that can be used by tests, changing the
        current working directory to the sample_buildout. It also adds a
        number of names to the test namespace:
        
        ``sample_buildout``
        This is the name of a buildout with a basic configuration.
        
        ``ls(*path)``
        List the contents of a directory.  The directory path is provided as one or
        more strings, to be joined with os.path.join.
        
        ``cat(*path)``
        Display the contents of a file.   The file path is provided as one or
        more strings, to be joined with os.path.join.
        
        On Windows, if the file doesn't exist, the function will try
        adding a '-script.py' suffix.  This helps to work around a
        difference in script generation on windows.
        
        ``mkdir(*path)``
        Create a directory. The directory path is provided as one or
        more strings, to be joined with os.path.join.
        
        ``rmdir(*path)``
        Remove a directory. The directory path is provided as one or
        more strings, to be joined with os.path.join.
        
        ``tmpdir(name)``
        Create a temporary directory with the given name.  The directory
        will be automatically removed at the end of the test.  The path of
        the created directory is returned.
        
        Further, if the the normalize_path normlaizing substitution (see
        below) is used, then any paths starting with this path will be
        normalized to::
        
        /name/restofpath
        
        No two temporary directories can be created with the same name.  A
        directory created with tmpdir can be removed with rmdir and recreated.
        
        Note that the sample_buildout directory is created by calling this
        function.
        
        ``write(*path_and_contents)``
        Create a file.  The file path is provided as one or more strings,
        to be joined with os.path.join. The last argument is the file contents.
        
        ``system(command, input='')``
        Execute a system command with the given input passed to the
        command's standard input.  The output (error and regular output)
        from the command is returned.
        
        ``get(url)``
        Get a web page.
        
        ``cd(*path)``
        Change to the given directory.  The directory path is provided as one or
        more strings, to be joined with os.path.join.
        
        The directory will be reset at the end of the test.
        
        ``join(*path)``
        A convenient reference to os.path.join.
        
        ``register_teardown(func)``
        Register a tear-down function.  The function will be called with
        no arguments at the end of the test.
        
        ``start_server(path)``
        Start a web server on the given path.  The server will be shut
        down at the end of the test.  The server URL is returned.
        
        ``sdist(setup, dest)``
        Create a source distribution by running the given setup file and
        placing the result in the given destination directory.  If the
        setup argument is a directory, the thge setup.py file in that
        directory is used.
        
        ``bdist_egg(setup, executable, dest)``
        Create an egg by running the given setup file with the given
        Python executable and placing the result in the given destination
        directory.  If the setup argument is a directory, then the
        setup.py file in that directory is used.
        
        ``find_python(version)``
        Find a Python executable for the given version, where version is a
        string like "2.4".
        
        This function uses the following strategy to find a Python of the
        given version:
        
        - Look for an environment variable of the form PYTHON%(version)s.
        
        - On windows, look for \Pythonm%(version)s\python
        
        - on Unix, try running python%(version)s or just python to get the
        executable
        
        ``zc.buildout.testing.buildoutTearDown(test)``
        ----------------------------------------------
        
        Tear down everything set up by zc.buildout.testing.buildoutSetUp.  Any
        functions passed to register_teardown are called as well.
        
        ``install(project, destination)``
        ---------------------------------
        
        Install eggs for a given project into a destination.  If the
        destination is a test object, then the eggs directory of the
        sample buildout (sample_buildout) defined by the test will be used.
        Tests will use this to install the distributions for the packages
        being tested (and their dependencies) into a sample buildout. The egg
        to be used should already be loaded, by importing one of the modules
        provided, before calling this function.
        
        ``install_develop(project, destination)``
        -----------------------------------------
        
        Like install, but a develop egg is installed even if the current egg
        if not a develop egg.
        
        ``Output normalization``
        ------------------------
        
        Recipe tests often generate output that is dependent on temporary file
        locations, operating system conventions or Python versions.  To deal
        with these dependencies, we often use
        zope.testing.renormalizing.RENormalizing to normalize test output.
        zope.testing.renormalizing.RENormalizing takes pairs of regular
        expressions and substitutions. The zc.buildout.testing module provides
        a few helpful variables that define regular-expression/substitution
        pairs that you can pass to zope.testing.renormalizing.RENormalizing.
        
        
        ``normalize_path``
        Converts tests paths, based on directories created with tmpdir(),
        to simple paths.
        
        ``normalize_script``
        On Unix-like systems, scripts are implemented in single files
        without suffixes.  On windows, scripts are implemented with 2
        files, a -script.py file and a .exe file.  This normalization
        converts directory listings of Windows scripts to the form
        generated on UNix-like systems.
        
        ``normalize_egg_py``
        Normalize Python version and platform indicators, if specified, in
        egg names.
        
        Python API for egg and script installation
        ==========================================
        
        The easy_install module provides some functions to provide support for
        egg and script installation.  It provides functionality at the python
        level that is similar to easy_install, with a few exceptions:
        
        - By default, we look for new packages *and* the packages that
        they depend on.  This is somewhat like (and uses) the --upgrade
        option of easy_install, except that we also upgrade required
        packages.
        
        - If the highest-revision package satisfying a specification is
        already present, then we don't try to get another one.  This saves a
        lot of search time in the common case that packages are pegged to
        specific versions.
        
        - If there is a develop egg that satisfies a requirement, we don't
        look for additional distributions.  We always give preference to
        develop eggs.
        
        - Distutils options for building extensions can be passed.
        
        Distribution installation
        -------------------------
        
        The easy_install module provides a function, install, for installing one
        or more packages and their dependencies.  The install function takes 2
        positional arguments:
        
        - An iterable of setuptools requirement strings for the distributions
        to be installed, and
        
        - A destination directory to install to and to satisfy requirements
        from.  The destination directory can be None, in which case, no new
        distributions are downloaded and there will be an error if the
        needed distributions can't be found amoung those already installed.
        
        It supports a number of optional keyword arguments:
        
        find-links
        A sequence of URLs, file names, or directories to look for
        links to distributions.
        
        index
        The URL of an index server, or almost any other valid URL. :)
        
        If not specified, the Python Package Index,
        http://cheeseshop.python.org/pypi, is used.  You can specify an
        alternate index with this option.  If you use the links option and
        if the links point to the needed distributions, then the index can
        be anything and will be largely ignored.  In the examples, here,
        we'll just point to an empty directory on our link server.  This
        will make our examples run a little bit faster.
        
        executable
        A path to a Python executable.  Distributions will ne installed
        using this executable and will be for the matching Python version.
        
        path
        A list of additional directories to search for locally-installed
        distributions.
        
        always_unzip
        A flag indicating that newly-downloaded distributions should be
        directories even if they could be installed as zip files.
        
        working_set
        An exsiting working set to be augmented with additional
        distributions, if necessary to satisfy requirements.  This allows
        you to call install multiple times, if necessary, to gather
        multiple sets of requirements.
        
        newest
        A boolian value indicating whether to search for new distributions
        when already-installed distributions meet the requirement.  When
        this is true, the default, and when the destination directory is
        not None, then the install function will search for the newest
        distributions that satisfy the requirements.
        
        The install method returns a working set containing the distributions
        needed to meet the given requirements.
        
        We have a link server that has a number of eggs:
        
        >>> print get(link_server),
        <html><body>
        <a href="demo-0.1-py2.4.egg">demo-0.1-py2.4.egg</a><br>
        <a href="demo-0.2-py2.4.egg">demo-0.2-py2.4.egg</a><br>
        <a href="demo-0.3-py2.4.egg">demo-0.3-py2.4.egg</a><br>
        <a href="demoneeded-1.0.zip">demoneeded-1.0.zip</a><br>
        <a href="demoneeded-1.1.zip">demoneeded-1.1.zip</a><br>
        <a href="extdemo-1.4.zip">extdemo-1.4.zip</a><br>
        <a href="index/">index/</a><br>
        <a href="other-1.0-py2.4.egg">other-1.0-py2.4.egg</a><br>
        </body></html>
        
        Let's make a directory and install the demo egg to it, using the demo:
        
        >>> dest = tmpdir('sample-install')
        >>> import zc.buildout.easy_install
        >>> ws = zc.buildout.easy_install.install(
        ...     ['demo==0.2'], dest,
        ...     links=[link_server], index=link_server+'index/')
        
        We requested version 0.2 of the demo distribution to be installed into
        the destination server.  We specified that we should search for links
        on the link server and that we should use the (empty) link server
        index directory as a package index.
        
        The working set contains the distributions we retrieved.
        
        >>> for dist in ws:
        ...     print dist
        demo 0.2
        demoneeded 1.1
        
        And the actual eggs were added to the eggs directory.
        
        >>> ls(dest)
        -  demo-0.2-py2.4.egg
        -  demoneeded-1.1-py2.4.egg
        
        If we remove the version restriction on demo, but specify a false
        value for newest, no new didstributions will be installed:
        
        >>> ws = zc.buildout.easy_install.install(
        ...     ['demo'], dest, links=[link_server], index=link_server+'index/',
        ...     newest=False)
        >>> ls(dest)
        -  demo-0.2-py2.4.egg
        -  demoneeded-1.1-py2.4.egg
        
        If we leave off the newst option, we'll get an update for demo:
        
        >>> ws = zc.buildout.easy_install.install(
        ...     ['demo'], dest, links=[link_server], index=link_server+'index/')
        >>> ls(dest)
        -  demo-0.2-py2.4.egg
        -  demo-0.3-py2.4.egg
        -  demoneeded-1.1-py2.4.egg
        
        We can supply additional distributions.  We can also supply
        specifications for distributions that would normally be found via
        dependencies.  We might do this to specify a sprcific version.
        
        >>> ws = zc.buildout.easy_install.install(
        ...     ['demo', 'other', 'demoneeded==1.0'], dest,
        ...     links=[link_server], index=link_server+'index/')
        
        >>> for dist in ws:
        ...     print dist
        demo 0.3
        other 1.0
        demoneeded 1.0
        
        >>> ls(dest)
        -  demo-0.2-py2.4.egg
        -  demo-0.3-py2.4.egg
        -  demoneeded-1.0-py2.4.egg
        -  demoneeded-1.1-py2.4.egg
        d  other-1.0-py2.4.egg
        
        We can request that eggs be unzipped even if they are zip safe.  This
        can be useful when debugging.
        
        >>> rmdir(dest)
        >>> dest = tmpdir('sample-install')
        >>> ws = zc.buildout.easy_install.install(
        ...     ['demo'], dest, links=[link_server], index=link_server+'index/',
        ...     always_unzip=True)
        
        >>> ls(dest)
        d  demo-0.3-py2.4.egg
        d  demoneeded-1.1-py2.4.egg
        
        
        >>> rmdir(dest)
        >>> dest = tmpdir('sample-install')
        >>> ws = zc.buildout.easy_install.install(
        ...     ['demo'], dest, links=[link_server], index=link_server+'index/',
        ...     always_unzip=True)
        
        >>> ls(dest)
        d  demo-0.3-py2.4.egg
        d  demoneeded-1.1-py2.4.egg
        
        Script generation
        -----------------
        
        The easy_install module provides support for creating scripts from
        eggs.  It provides a function similar to setuptools except that it
        provides facilities for baking a script's path into the script.  This
        has two advantages:
        
        - The eggs to be used by a script are not chosen at run time, making
        startup faster and, more importantly, deterministic.
        
        - The script doesn't have to import pkg_resources because the logic
        that pkg_resources would execute at run time is executed at
        script-creation time.
        
        The scripts method can be used to generate scripts. Let's create a
        destination directory for it to place them in:
        
        >>> import tempfile
        >>> bin = tmpdir('bin')
        
        Now, we'll use the scripts method to generate scripts in this directory
        from the demo egg:
        
        >>> import sys
        >>> scripts = zc.buildout.easy_install.scripts(
        ...     ['demo'], ws, sys.executable, bin)
        
        the four arguments we passed were:
        
        1. A sequence of distribution requirements.  These are of the same
        form as setuptools requirements.  Here we passed a single
        requirement, for the version 0.1 demo distribution.
        
        2. A working set,
        
        3. The Python executable to use, and
        
        3. The destination directory.
        
        The bin directory now contains a generated script:
        
        >>> ls(bin)
        -  demo
        
        The return value is a list of the scripts generated:
        
        >>> import os, sys
        >>> if sys.platform == 'win32':
        ...     scripts == [os.path.join(bin, 'demo.exe'),
        ...                 os.path.join(bin, 'demo-script.py')]
        ... else:
        ...     scripts == [os.path.join(bin, 'demo')]
        True
        
        Note that in Windows, 2 files are generated for each script.  A script
        file, ending in '-script.py', and an exe file that allows the script
        to be invoked directly without having to specify the Python
        interpreter and without having to provide a '.py' suffix.
        
        The demo script run the entry point defined in the demo egg:
        
        >>> cat(bin, 'demo') # doctest: +NORMALIZE_WHITESPACE
        #!/usr/local/bin/python2.4
        <BLANKLINE>
        import sys
        sys.path[0:0] = [
        '/sample-install/demo-0.3-py2.4.egg',
        '/sample-install/demoneeded-1.1-py2.4.egg',
        ]
        <BLANKLINE>
        import eggrecipedemo
        <BLANKLINE>
        if __name__ == '__main__':
        eggrecipedemo.main()
        
        Some things to note:
        
        - The demo and demoneeded eggs are added to the beginning of sys.path.
        
        - The module for the script entry point is imported and the entry
        point, in this case, 'main', is run.
        
        Rather than requirement strings, you can pass tuples containing 3
        strings:
        
        - A script name,
        
        - A module,
        
        - An attribute expression for an entry point within the module.
        
        For example, we could have passed antry point information directly
        rather than passing a requirement:
        
        >>> scripts = zc.buildout.easy_install.scripts(
        ...     [('demo', 'eggrecipedemo', 'main')],
        ...     ws, sys.executable, bin)
        
        >>> cat(bin, 'demo') # doctest: +NORMALIZE_WHITESPACE
        #!/usr/local/bin/python2.4
        <BLANKLINE>
        import sys
        sys.path[0:0] = [
        '/sample-install/demo-0.3-py2.4.egg',
        '/sample-install/demoneeded-1.1-py2.4.egg',
        ]
        <BLANKLINE>
        import eggrecipedemo
        <BLANKLINE>
        if __name__ == '__main__':
        eggrecipedemo.main()
        
        Passing entry-point information directly is handy when using eggs (or
        distributions) that don't declare their entry points, such as
        distributions that aren't based on setuptools.
        
        The interpreter keyword argument can be used to generate a script that can
        be used to invoke the Python interactive interpreter with the path set
        based on the working set.  This generated script can also be used to
        run other scripts with the path set on the working set:
        
        >>> scripts = zc.buildout.easy_install.scripts(
        ...     ['demo'], ws, sys.executable, bin, interpreter='py')
        
        
        >>> ls(bin)
        -  demo
        -  py
        
        >>> if sys.platform == 'win32':
        ...     scripts == [os.path.join(bin, 'demo.exe'),
        ...                 os.path.join(bin, 'demo-script.py'),
        ...                 os.path.join(bin, 'py.exe'),
        ...                 os.path.join(bin, 'py-script.py')]
        ... else:
        ...     scripts == [os.path.join(bin, 'demo'),
        ...                 os.path.join(bin, 'py')]
        True
        
        The py script simply runs the Python interactive interpreter with
        the path set:
        
        >>> cat(bin, 'py') # doctest: +NORMALIZE_WHITESPACE
        #!/usr/local/bin/python2.4
        import sys
        <BLANKLINE>
        sys.path[0:0] = [
        '/sample-install/demo-0.3-py2.4.egg',
        '/sample-install/demoneeded-1.1-py2.4.egg',
        ]
        <BLANKLINE>
        _interactive = True
        if len(sys.argv) > 1:
        import getopt
        _options, _args = getopt.getopt(sys.argv[1:], 'ic:')
        _interactive = False
        for (_opt, _val) in _options:
        if _opt == '-i':
        _interactive = True
        elif _opt == '-c':
        exec _val
        <BLANKLINE>
        if _args:
        sys.argv[:] = _args
        execfile(sys.argv[0])
        <BLANKLINE>
        if _interactive:
        import code
        code.interact(banner="", local=globals())
        
        If invoked with a script name and arguments, it will run that script, instead.
        
        An additional argumnet can be passed to define which scripts to install
        and to provide script names. The argument is a dictionary mapping
        original script names to new script names.
        
        >>> bin = tmpdir('bin2')
        >>> scripts = zc.buildout.easy_install.scripts(
        ...    ['demo'], ws, sys.executable, bin, dict(demo='run'))
        
        >>> if sys.platform == 'win32':
        ...     scripts == [os.path.join(bin, 'run.exe'),
        ...                 os.path.join(bin, 'run-script.py')]
        ... else:
        ...     scripts == [os.path.join(bin, 'run')]
        True
        >>> ls(bin)
        -  run
        
        >>> print system(os.path.join(bin, 'run')),
        3 1
        
        Including extra paths in scripts
        --------------------------------
        
        We can pass a keyword argument, extra paths, to caue additional paths
        to be included in the a generated script:
        
        >>> scripts = zc.buildout.easy_install.scripts(
        ...    ['demo'], ws, sys.executable, bin, dict(demo='run'),
        ...    extra_paths=['/foo/bar'])
        
        >>> cat(bin, 'run') # doctest: +NORMALIZE_WHITESPACE
        #!/usr/local/bin/python2.4
        <BLANKLINE>
        import sys
        sys.path[0:0] = [
        '/sample-install/demo-0.3-py2.4.egg',
        '/sample-install/demoneeded-1.1-py2.4.egg',
        '/foo/bar',
        ]
        <BLANKLINE>
        import eggrecipedemo
        <BLANKLINE>
        if __name__ == '__main__':
        eggrecipedemo.main()
        
        Providing script arguments
        --------------------------
        
        An "argument" keyword argument can be used to pass arguments to an
        entry point.  The value passed is a source string to be placed between the
        parentheses in the call:
        
        >>> scripts = zc.buildout.easy_install.scripts(
        ...    ['demo'], ws, sys.executable, bin, dict(demo='run'),
        ...    arguments='1, 2')
        
        >>> cat(bin, 'run') # doctest: +NORMALIZE_WHITESPACE
        #!/usr/local/bin/python2.4
        import sys
        sys.path[0:0] = [
        '/sample-install/demo-0.3-py2.4.egg',
        '/sample-install/demoneeded-1.1-py2.4.egg',
        ]
        <BLANKLINE>
        import eggrecipedemo
        <BLANKLINE>
        if __name__ == '__main__':
        eggrecipedemo.main(1, 2)
        
        Passing initialization code
        ---------------------------
        
        You can also pass script initialization code:
        
        >>> scripts = zc.buildout.easy_install.scripts(
        ...    ['demo'], ws, sys.executable, bin, dict(demo='run'),
        ...    arguments='1, 2',
        ...    initialization='import os\nos.chdir("foo")')
        
        >>> cat(bin, 'run') # doctest: +NORMALIZE_WHITESPACE
        #!/usr/local/bin/python2.4
        import sys
        sys.path[0:0] = [
        '/sample-install/demo-0.3-py2.4.egg',
        '/sample-install/demoneeded-1.1-py2.4.egg',
        ]
        <BLANKLINE>
        import os
        os.chdir("foo")
        <BLANKLINE>
        import eggrecipedemo
        <BLANKLINE>
        if __name__ == '__main__':
        eggrecipedemo.main(1, 2)
        
        
        Handling custom build options for extensions provided in source distributions
        -----------------------------------------------------------------------------
        
        Sometimes, we need to control how extension modules are built.  The
        build function provides this level of control.  It takes a single
        package specification, downloads a source distribution, and builds it
        with specified custom build options.
        
        The build function takes 3 positional arguments:
        
        spec
        A package specification for a source distribution
        
        dest
        A destination directory
        
        build_ext
        A dictionary of options to be passed to the distutils build_ext
        command when building extensions.
        
        It supports a number of optional keyword arguments:
        
        links
        a sequence of URLs, file names, or directories to look for
        links to distributions,
        
        index
        The URL of an index server, or almost any other valid URL. :)
        
        If not specified, the Python Package Index,
        http://cheeseshop.python.org/pypi, is used.  You can specify an
        alternate index with this option.  If you use the links option and
        if the links point to the needed distributions, then the index can
        be anything and will be largely ignored.  In the examples, here,
        we'll just point to an empty directory on our link server.  This
        will make our examples run a little bit faster.
        
        executable
        A path to a Python executable.  Distributions will ne installed
        using this executable and will be for the matching Python version.
        
        path
        A list of additional directories to search for locally-installed
        distributions.
        
        newest
        A boolian value indicating whether to search for new distributions
        when already-installed distributions meet the requirement.  When
        this is true, the default, and when the destination directory is
        not None, then the install function will search for the newest
        distributions that satisfy the requirements.
        
        
        Our link server included a source distribution that includes a simple
        extension, extdemo.c::
        
        #include <Python.h>
        #include <extdemo.h>
        
        static PyMethodDef methods[] = {};
        
        PyMODINIT_FUNC
        initextdemo(void)
        {
        PyObject *m;
        m = Py_InitModule3("extdemo", methods, "");
        #ifdef TWO
        PyModule_AddObject(m, "val", PyInt_FromLong(2));
        #else
        PyModule_AddObject(m, "val", PyInt_FromLong(EXTDEMO));
        #endif
        }
        
        The extension depends on a system-dependnt include file, extdemo.h,
        that defines a constant, EXTDEMO, that is exposed by the extension.
        
        We'll add an include directory to our sample buildout and add the
        needed include file to it:
        
        >>> mkdir('include')
        >>> write('include', 'extdemo.h',
        ... """
        ... #define EXTDEMO 42
        ... """)
        
        Now, we can use the build function to create an egg from the source
        distribution:
        
        >>> zc.buildout.easy_install.build(
        ...   'extdemo', dest,
        ...   {'include-dirs': os.path.join(sample_buildout, 'include')},
        ...   links=[link_server], index=link_server+'index/')
        '/sample-install/extdemo-1.4-py2.4-unix-i686.egg'
        
        The function returns the list of eggs
        
        Now if we look in our destination directory, we see we have an extdemo egg:
        
        >>> ls(dest)
        d  demo-0.3-py2.4.egg
        d  demoneeded-1.1-py2.4.egg
        d  extdemo-1.4-py2.4-unix-i686.egg
        
        Let's update our link server with a new version of extdemo:
        
        >>> update_extdemo()
        >>> print get(link_server),
        <html><body>
        <a href="demo-0.1-py2.4.egg">demo-0.1-py2.4.egg</a><br>
        <a href="demo-0.2-py2.4.egg">demo-0.2-py2.4.egg</a><br>
        <a href="demo-0.3-py2.4.egg">demo-0.3-py2.4.egg</a><br>
        <a href="demoneeded-1.0.zip">demoneeded-1.0.zip</a><br>
        <a href="demoneeded-1.1.zip">demoneeded-1.1.zip</a><br>
        <a href="extdemo-1.4.zip">extdemo-1.4.zip</a><br>
        <a href="extdemo-1.5.zip">extdemo-1.5.zip</a><br>
        <a href="index/">index/</a><br>
        <a href="other-1.0-py2.4.egg">other-1.0-py2.4.egg</a><br>
        </body></html>
        
        The easy_install caches information about servers to reduce network
        access. To see the update, we have to call the clear_index_cache
        function to clear the index cache:
        
        >>> zc.buildout.easy_install.clear_index_cache()
        
        If we run build with newest set to False, we won't get an update:
        
        >>> zc.buildout.easy_install.build(
        ...   'extdemo', dest,
        ...   {'include-dirs': os.path.join(sample_buildout, 'include')},
        ...   links=[link_server], index=link_server+'index/',
        ...   newest=False)
        '/sample-install/extdemo-1.4-py2.4-linux-i686.egg'
        
        >>> ls(dest)
        d  demo-0.3-py2.4.egg
        d  demoneeded-1.1-py2.4.egg
        d  extdemo-1.4-py2.4-unix-i686.egg
        
        But if we run it with the default True setting for newest, then we'll
        get an updated egg:
        
        >>> zc.buildout.easy_install.build(
        ...   'extdemo', dest,
        ...   {'include-dirs': os.path.join(sample_buildout, 'include')},
        ...   links=[link_server], index=link_server+'index/')
        '/sample-install/extdemo-1.5-py2.4-unix-i686.egg'
        
        d  demo-0.3-py2.4.egg
        d  demoneeded-1.1-py2.4.egg
        d  extdemo-1.4-py2.4-unix-i686.egg
        d  extdemo-1.5-py2.4-unix-i686.egg
        
        
        Handling custom build options for extensions in develop eggs
        ------------------------------------------------------------
        
        The develop function is similar to the build function, except that,
        rather than building an egg from a source directory containing a
        setup.py script.
        
        The develop function takes 2 positional arguments:
        
        setup
        The path to a setup script, typically named "setup.py", or a
        directory containing a setup.py script.
        
        dest
        The directory to install the egg link to
        
        It supports some optional keyword argument:
        
        build_ext
        A dictionary of options to be passed to the distutils build_ext
        command when building extensions.
        
        executable
        A path to a Python executable.  Distributions will ne installed
        using this executable and will be for the matching Python version.
        
        We have a local directory containing the extdemo source:
        
        >>> ls(extdemo)
        -  MANIFEST
        -  MANIFEST.in
        -  README
        -  extdemo.c
        -  setup.py
        
        Now, we can use the develop function to create a develop egg from the source
        distribution:
        
        >>> zc.buildout.easy_install.develop(
        ...   extdemo, dest,
        ...   {'include-dirs': os.path.join(sample_buildout, 'include')})
        '/sample-install/extdemo.egg-link'
        
        The name of the egg link created is returned.
        
        Now if we look in our destination directory, we see we have an extdemo
        egg link:
        
        >>> ls(dest)
        d  demo-0.3-py2.4.egg
        d  demoneeded-1.1-py2.4.egg
        d  extdemo-1.4-py2.4-linux-i686.egg
        d  extdemo-1.5-py2.4-linux-i686.egg
        -  extdemo.egg-link
        
        And that the source directory contains the compiled extension:
        
        >>> ls(extdemo)
        -  MANIFEST
        -  MANIFEST.in
        -  README
        d  build
        -  extdemo.c
        d  extdemo.egg-info
        -  extdemo.so
        -  setup.py
        
        Download
        **********************
        
Keywords: development build
Platform: UNKNOWN
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: License :: OSI Approved :: Zope Public License
Classifier: Topic :: Software Development :: Build Tools
Classifier: Topic :: Software Development :: Libraries :: Python Modules
