[Subversion] / PEAK / INSTALL.txt  

View of /PEAK/INSTALL.txt

Parent Directory | Revision Log
Revision: 1713 - (download)
Sun Mar 7 23:51:25 2004 UTC (20 years ago) by pje
File size: 8488 byte(s)
Overhaul setup.py to simplify installation and maintenance.  It's no longer
necessary to manually add packages or files to setup.py.  Optional features
can now be controlled with '--with-X' and '--without-X' options.  Bumped
version number to 0.5a4.  (XXX Need to update INSTALL.txt w/options info!)
Installing PEAK

 PEAK Release 0.5 alpha 4

 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":http://homepages.cwi.nl/~aeb/std/shebang/, 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:

   - 'persistence'

   - 'ZConfig'

   (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.













cvs-admin@eby-sarna.com

Powered by ViewCVS 1.0-dev

ViewCVS and CVS Help