Installing PEAK
PEAK Release 0.5 alpha 3
Copyright (C) 1996-2004 by Phillip J. Eby and Tyler C. Sarna.
All rights reserved. This software may be used under the same terms
as Zope or Python. THERE ARE ABSOLUTELY NO WARRANTIES OF ANY KIND.
Code quality varies between modules, from "beta" to "experimental
pre-alpha". :)
SYSTEM REQUIREMENTS
Python 2.2.2 or better is required. Some portions of PEAK may support only
POSIX-like and/or Windows operating systems. Installation from a source
distribution requires a C compiler that works with Python.
If you are modifying the source of PEAK extension modules, you will need
Pyrex version 0.7.2. You do not need Pyrex if you are just installing
PEAK as-is, but if you do have Pyrex installed, it must be version 0.7.2.
In general, it is best to uninstall previous versions of PEAK before
installing new ones, since some modules may have moved or been renamed.
Also, if you have Zope X3 installed on your Python path, you should ensure
that it is an up-to-date CVS version: "Milestone 2" is no longer supported.
BASIC INSTALLATION
PEAK is distributed using the now-standard Python distutils utilities.
Just unpack the archive, go to the directory containing setup.py , and
run:
python setup.py install
PEAK will be installed in the site-packages directory of your Python
installation. (Unless directed elsewhere; see the "Installing Python
Modules" section of the Python manuals for details on customizing
installation locations, etc.).
(Note: for the Win32 installer release, just run the .exe file.)
SCRIPTS, BATCH FILES, AND #!
PEAK installs a Python script named peak . peak is an application
bootstrap script that can invoke any object that is referenceable via
the PEAK naming system. Run the peak script for usage info, or see
the Bootstrap class in peak.running.commands for more on how to make
objects bootable via peak .
Note that on Windows, you cannot invoke the peak script directly. Instead
you must run it like this:
python C:\Python22\Scripts\peak
followed by the appropriate arguments. You should of course substitute the
correct path to your Python installation's "scripts" directory.
The peak script is designed for use as a #! command interpreter for
certain file types, such as ZConfig configuration files. Some Unixes,
however, do not support using scripts as #! interpreters. To work around
this, there is a (currently experimental) invoke program you can build. To
build the invoke program, go to the directory you unpacked the PEAK source
in, and type:
gcc -o invoke scripts/invoke.c
This will build an invoke executable, which you can then place on your
system's path or other appropriate location. You can then use '#! lines
like this (replacing /usr/local/bin' with the directory where you installed
invoke , of course):
#!/usr/local/bin/invoke peak EventDriven
...rest of config file goes here
invoke allows an arbitrary number of space-separated arguments to be passed
to the command it invokes, thus working around various Unixes' #! parsing
problems, as well as the "can't use a script as an interpreter" problem. It
also searches the system PATH for the specified command. You may find this
useful for non-PEAK script interpreters as well.
The interpretation of #! lines is highly OS-dependent. Some operating
systems limit the length of #! lines to 32, 80, 127, or 255 characters.
Some operating systems require a space after #! , and or require the path
that follows to be absolute. Some operating systems will search the PATH
environment variable for the specified interpreter, others will not. When
creating programs that use #! lines, or using such programs written by
others, be sure to adjust the line as appropriate for your operating system.
For more information on this subject, you can visit the
shebang site, which lists useful
#! line information for various operating systems.
Note that Windows does not support #! lines at all, so programs that use
them must be run using batch files when run on Windows, unless you have a
Unix-like shell available (e.g. Cygwin).
TESTING YOUR INSTALLATION
PEAK comes with a moderately-sized built-in test suite. If you wish to
run it after installation, you can do so like this:
peak test
This will run over 120 tests on various parts of PEAK. If you have
installed everything correctly, 100% of the tests should succeed. If
anything is broken, you will probably be unable to run the tests at all.
If you'd like to run only a portion of the test suite, you can supply
a specific test suite on the command line as follows:
peak test peak.util.tests.test_suite
For more options, run peak test --help .
If you've installed using the Windows binary installer, you can run the
tests like this:
python C:\Python22\Scripts\peak test
THIRD PARTY SOFTWARE INCLUDED WITH PEAK
Aaron Watters' kjbuckets Module
PEAK now includes a copy of Aaron Watters' kjbuckets module for
your convenience, and automatically installs it alongside PEAK in
your Python site-packages directory. (Note that this will overwrite
any existing installation of the kjbuckets module.)
kjbuckets is copyright Aaron Watters and contributors; please see
the src/kjbuckets/COPYRIGHT.txt file for details of its license.
The Zope 3 persistence and ZConfig Packages
PEAK includes a copy of the following packages from the Zope X3 Milestone 2
release, and will install them unless Zope X3 is available on sys.path
at the time setup.py is run:
(Also, if you are using a Python version that does not include the datetime
or csv packages (i.e. versions < 2.3), replacement versions are installed
as well.) These packages are automatically installed alongside PEAK in your
site-packages directory, unless you specify an alternate installation
location to setup.py . Note that this will overwrite any existing
installation of these packages.
To prevent overwriting versions of these packages that were installed
separately, setup.py attempts to detect the presence of Zope X3 by
importing zope.component (which is not distributed with PEAK). If you
have a zope.component package on your sys.path when setup.py runs,
setup.py will assume you have a complete Zope X3 installation, and it
will not install any of the Zope packages listed above, in order to avoid
overwriting newer versions from your Zope installation.
The datetime , persistence and ZConfig packages are Copyright Zope
Corporation and contributors; please see the LICENSE.txt files in their
directories for details of their licenses.
The fcgiapp Module
On platforms where os.name=="posix" (most Unixes and Cygwin), PEAK also
installs the fcgiapp module, which provides support for the FastCGI
protocol. You may experience problems building this module on some
platforms; check the fcgiconfig.h to see if you need to change anything
for your system. Or, you can simply disable it, by editing setup.py
and changing the include_fcgiapp flag to False .
The fcgiapp module is Copyright Digital Creations, LC (now Zope Corp.);
see the fcgiappmodule.c file for details of its license. In the same
directory are distributed portions of the FastCGI Development Kit, which
is Copyright Open Market, Inc. See the LICENSE.TERMS file in that
directory for details of its license.
EMBEDDING PEAK IN AN APPLICATION
If you are embedding PEAK in an application that you are distributing,
and space is at a premium, there are some modules you may want to omit
from the installation. For example, PEAK's test modules are probably
not useful in such an environment, and unless your application is a
CASE tool, you will probably not need to redistribute the UML and MOF
metamodels. In such situations, you may want to install a copy of PEAK
that does not contain these modules. You can disable installation of
either set of modules by editing setup.py , and changing the
include_tests and include_metamodels flags, located near the top of
the script.
|