I'm adding this package list because I've noticed the zope repository is relatively hard to navigate and see what packages are available. On this page I'm providing just a small description to each package, which will hopefully make it easier to find the right package for a given task.

svn.zope.org is the single most important repository of Zope 3 related code and extensions. It is used as repository for the development of Zope 2, Zope 3 and various packages provided by other parties (Zope Corporation - zc.*, the Zope 3 Community (z3c.*), Lovely Systems (lovely.*), etc.

To checkout the code from this repository follow the FAQ instructions. Many packages can be also installed as eggs. (XXX: explain procedure)

Grokstar

A blogging application using grok. Still in alpha.

Zem

The External Editor version targeted at Macs

Zelenium

Zope 2 product allows developers to create TTW Selenium test suites inside their Zope instance, in order to do browser-based functional testing of their site.

ZConfig

is a configuration library intended for general use. It is used in Zope 2 and Zope 3 to parse configuration files.

book

The code for the Zope 3 Book (by Stephen Richter)

bugtracker

A bugtracker implemented in Zope 3

cc.buildout_reports

cc.buildout_reports provides recipe[s] for generating developer reports using zc.buildout.

cc.gettext

cc.gettext provides recipe[s] for manipulating gettext message catalogs.

cxoracleda

A cx_Oracle based Database Adapter for Zope3

docutils

Readers, writers and parsers for various formats, including Restructured Text (general purpose library)

eventworkflow

Contains a prototype for workflow definitions, that solely uses Zope's event subscriptions as the workflow "engine". Meant as a prototype, proof of concept.

five.customerize

Provides the ability to locally customize Page Template-based browser views, much like it is possible to customize file-system based view templates in the CMF's portal_skin tools.

five.localsitemanager

Provides a local site manager based on the standard Zope 3 local site manager for Zope 2.

gocept.zope3instance

Buildout recipe to create a Zope 3 instance

grok

A project that is meant to provide an easy development environment for the Zope 3 platform, by providing "good defaults over configuration" and no need for ZCML files.

grokproject

Code skeleton generator for grok based projects.

jquery.demo

A Z3c Website demo helper package for the JQuery features.

jquery.javascript

This package contains the JQuery library. It also creates viewlets for the JAvascript resources.

jquery.jsonform

JQuery based JSON form validation

jquery.jsontree

The jsontree is a <ul> tag tree loading child items via JSON form a context.

jquery.layer

A browser skin layer that has the jQuery javascript library available as resources.

jquery.livesearch

JSON/jQuery based livesearch

jquery.widget

This package contains a collection of JQuery-based widgets. Right now it has a REST editor, which renders a textarea and a toolbar to format the text using the REST syntax.

ldapadapter

The LDAPAdapter provides a mechanism to connect to an LDAP server and send commands to it.

ldapauth

The ldapauth package is a plugable auth module for the "plugable authentication service" which supports authentication on LDAP. (old package which would probably need work to get it to work with latest Zope 3)

ldappas

This is a plugin for the pluggable authentication utility (located at ``zope.app.authentication``) to deal with LDAP principal sources. It depends on the ``ldapadapter`` module (which itself depends on `python-ldap`).

mysqldba

A MySQL database adapter for Zope 3

pdlib

A page design Javascript library - library for manipulating objects on a page with object selection, context menus, and drag and drop. Mostly DOM 2 oriented, with bits for IE compatibility.

photo

Utilities and helpers to have images with multiple sizes. The photoslide package comes with a container for photos and provides nice views for all photos.

psycopgda

Zope 3 PostgresSQL database adapter

projectsupport

Project Support provides a set of scripts which help developers work with individual zope projects.

profilestats

Utilities to profile various operations in Zope 3

p01json

JSON-RPC client javascript library

p01jsonform

JSON based form validation

p01xmlhttp

An xmlhttp javascript library

s5-themes

Themes for the html export function of docutils

soap

A SOAP implementation to provide SOAP views for objects.

web

Zope Foundation related documents (no code here)

Open source packages produced by Lovely Systems under the lovely namespace

lovely.buildouthttp

Extends the buildout to enable password protected package repositories

lovely.flickr

A Flickr API library

lovely.flickrconnector

Provides a Zope 3 utility to connect to Flickr using the lovely.flickr library

lovely.flvplayer

A flash video player for Zope 3

lovely.memcached

This package provides a zope3 utility that abstracts a client for memcached servers see: http://www.danga.com/memcached.

lovely.mount

A multi-zodb database support for Zope 3

lovely.rating

A rating system that can be plugged for any content type

lovely.recipe

A recipe that helps with creating files and folders in a buildout.

lovely.relation

This package provides functionality to realize relations using the zc.relationship package.

lovely.remoteinclude

This package allows to render include views of viewlets and views which implement the IContentProvider interface. This is done by a subscriber on BeforeUpdateEvent.

lovely.responsecache

This package allows to cache results of ContentProviders. Note that normal zope BrowserViews do not implement the IContentProvider interface, so in order to cache views, they have to implement the update and render methods. For a base class see z3c.viewtemplate.baseview.BaseView.

lovely.remotetask

This package provides an implementation of a remote task execution Web service that allows to execute pre-defined tasks on another server. It is also possible to run cron jobs at specific times.

lovely.skinbrowser

An APIDOC module that show pages and templates for skins and layers developed using z3c.viewtemplate

lovely.tag

A tagging engine implementation

lovely.viewcache

Facilitates caching of views

Packages to be used together with grok

grok

A project that is meant to provide an easy development environment for the Zope 3 platform, by providing "good defaults over configuration" and no need for ZCML files.

grokapps

A collection of tutorial apps created with grok

grokproject

Code skeleton generator for grok based projects.

megrok.cherry

An experimental integration of Zope 3 with the CherryPy WSGI server.

megrok.five

Provides integration of grok_ into Zope 2.

megrok.viewlet

A proof of concept of a way to support portlets in Grok.

martian

Martian provides infrastructure for declarative configuration of Python code. Martian is especially useful for the construction of frameworks that need to provide a flexible plugin infrastructure. (useful for Grok projects)

The z3c (Zope 3 Community) namespace

z3c.ajax

A formlib - ajax integration package providing a new namespace and traverser for widgets.

z3c.authentication

Sub-packages: cookie (cookie based authentication and auto-login) and simple (another implementation of an authentication utility with the purpose of providing a simple way of having custom members)

z3c.baseregistry

Allows configuring and defining local sites and components via ZCML. Think, for example, defining adapters at the site level instead of globally.

z3c.batching

A simple batching implementation that helps with the management of batching. (Batching = splitting a long list of elements in several pages)

z3c.breadcrumb

The z3c.breadcrumb package provides base classes for breadcrumb implementations. It allows you to write adapters for each content object which provides it's own rule for providing the breadcrumb name, url and selection.

z3c.componentdebug

Component Debugging provides a set of tools for inspecting the component registry of site managers. It also provides a patch that catches various different ComponentLookupError exceptions and adds more verbose reporting.

z3c.conditionalviews

This package intergrates with the zope publisher to validate conditional requests based on the `If-None-Match`, `If-Match`, and `If-Modified-Since`, `If-UnModifiedSince` protocols.

z3c.configurator

A dependency-tracking plugin-based utility to configure components after their initial creation. Usually it can be used to configure site utilities after the site object is created.

z3c.coverage

Script to convert unit test coverage reports to HTML.

z3c.csvvocabulary

Provides simple vocabularies using CSV files, which allows non-developers to update the vocabulary.

z3c.currency

A package implementing a currency field for ``zope.schema`` and support for using the field with ``z3c.form``.

z3c.datagenerator

Utilities to quickly create various sample data, useful in developing and testing applications.

z3c.dav

An implementation of the WebDAV protocol for Zope 3.

z3c.davapp.zopeappfile

This package defines and implements the WebDAV data model for all zope.app.file.file.File content objects.

z3c.davapp.zopefile

This package defines defines the WebDAV data model for all zope.file.file.File content objects.

z3c.davapp.zopelocking

Package to contain all the code to make WebDAV locking work with the zope.locking package. This is pretty much just of copy of the lockingutils, ftests/tests_z3_locking and tests modules from z3c.dav.

z3c.demo

Demos for z3c.website. Contains demos for Howto and Calculator ??

z3c.etestbrowser

This package is intended to provide extended versions of the Zope 3 testbrowser. Especially those extensions that introduce dependencies to more external products, like lxml.

z3c.etree

Provides a proxy for various ElementTree implementations by implementing an utility and various proxy objects for actual ElementTree-implementing libraries.

z3c.extfile

This package offers large file handling solutions for zope3. The first implementation is based on properties, the second on wsgi. The property implementation runs on plain zope 3.

z3c.evalexception

``paste.evalexception`` lets you interactively debug exceptions in your WSGI app. ``z3c.evalexception`` is a small wrapper around that so that it works with the stock Zope 3 application server.

z3c.flashmessage

Components to display small messages to users.

z3c.form

Provides various hooks, namespaces and utilities to enhance the widgets and formlib for various purposes, including AJAX type of development.

z3c.formui

This package provides a set of default layouts for the ``z3c.form`` framework. In particular it provides a DIV-based and a TABLE-based layout. The developer can use either layout by inheriting from a different base layer.

z3c.formjs

Package that provides javascript support/enhancements to the z3c.form library.

z3c.formjsdemo

This package is going to show off the different features of the ``z3c.formjs`` package.

z3c.formdemo

This package contains several small demo applications for the z3c.form and z3c.formui packages: Table vs div based layouts, simple 'Hello world' demo, a calculator demo, a linear wizard showing the subform capabilities, and a table/spreasheet example, showing how to use z3c.form with zc.table

z3c.i18n

i18n related convinience modules: translation domains for language names and territories and two vocabularies that contain all the languages and territories.

z3c.image

Image processor and utilities via PIL

z3c.imagewidget

Based on z3c.sessionwidget, it offers a set of forms to provide an image widget that displays and updates its data before the form is really submitted.

z3c.iplocation

This package implements an IP locator utility, which allows to look up the location (country, city, etc) for a given IP address.

z3c.language

The package contains a local negotiator, some base classes with a i18n switch adapter and a library for session handling support. This packages allows you to implement simply i18n aware content types and configure the server (negotiator) for handling language policies. Such a policy could be, that the server will lookup for a fix language or language settings set on a session or the setting from the browser.

z3c.layer

Some useful base layer. Contains subpackages: minimal - serves as a minimal base layer to be used in developing new sites not based on the default browser layer; trusted - the difference to the minimal layer is that this layer has trusted traverser adapters; pagelet - a base layer to be used when developing sites based on the z3c.pagelet patern.

z3c.livesearch

Provdes an AJAX based livesearch using scriptaculous and prototype

z3c.macro

This package provides an adapter and a TALES expression for a more explicit and more flexible macro handling using the adapter registry for macros.

z3c.macroviewlet

Allows the declaration of a macro in a template as a viewlet

z3c.menu

Contains only one package, z3c.menu.simple, a simple menu implementation which allows you to implement simply menus based on content providers and viewlets.

z3c.multiform

This Package provides an API to handle multiple forms with matching form fields on multiple items. The creation of multiforms is derived from the Form class of the formlib package.

z3c.objectpolicy

The objectpolicy package makes it easy to override the default zope.app.securitypolicy.zopepolicy on an object by object basis.

z3c.optionstorage

This is a generic solution for including editable and multi-lingual vocabulary-like information in any annotatable object.

z3c.pagelet

This package provides a very flexible base implementation for write view like components which can be higly customized later in custom project. This is needed if you have to write reusable components like needed in a framework. It does this by spliting the template registration from the view registration and providing content template / layout template.

z3c.password

This package provides an API and implementation of a password generation and verification utility. A high-security implementation is provided that is suitable for banks and other high-security institutions. The package also offers a field and a property for those fields.

z3c.pdftemplate

Provides the functionality of creating browser views that generate PDFs instead of HTML using reportlab's PDF writer technology. Also provides integration with z3c.rml

z3c.proxy

Provides location and container proxies for objects. (XXX: rewrite this)

z3c.quickentry

The quick entry processor allows a user to efficiently specify multiple values in one larger text block. The processor uses plugins to dynamically define the commands to handle. This type of input is not aimed at the average user, but at power users and users that can be trained. The syntax is purposefully minimized to maximize the input speed. This method of entry has been verified in a real life setting.

z3c.reference

Provides a reference engine, to be used with objects and schemas.

z3c.referrer

A package that uses the HTTP referer header to provide credentials.

z3c.resource

Allows content objects to provide resources. (XXX: rewrite this)

z3c.responseheaders

This package provides an implementation for setting response headers (e.g. for cache-control settings) on browser views by registering views on views. This way we do not have to change view code in order to set headers differently.

z3c.rml

An open source implementation of the RML language, to be used with ReportLab to generate PDF files.

z3c.sampledata

This package tries to do the best to support the development of sample data generators. A sample data generator is a pluggable tool to create data needed for tests.

z3c.schema

Provides several extension fields to be used in schema definitions: baseurl - useful if you need to append view names to a url and don't like to check every time if the url ends with a backslash before you append the view name; email - holds and validates email addresses; hostname - holds and validates IPs and hostnames; ip - holds and validates IPs; optchoice - a field that allows either to select a choice from a vocabulary or enter a custom value; regex - holds and validates regular expressions;

z3c.searchfilter

Browser pages and utilities to perform and filter catalog searches

z3c.sessionwidget

This package provides a widget that is only responsible for relaying the data of interest to a session. A sub-form or any other component can then use this session data and provide new data, if desired. The session data will also be publically available via a URL, so that the objects can also be displayed, such as images. This has the advantage that the data is *not* stored on the content until the overall form is submitted.

z3c.skin

A pagelet based Zope skin.

z3c.skin.pagelet

The z3c.skin.pagelet package provides a skin for the z3c.pagelet package. Note, the pagelet skin is only registered in the test layer. You can use this skin as a base for your own skins or just use it as a sample for the z3c.pagelet package.

s3c.sqlalchemy

A SQLAlchemy wrapper for Zope 2/3. The functionality of the wrapper is basically focused on easy integration with Zope 2 and Zope 3. The wrapper cares about connection handling, optional transaction integration with Zope 2/3 and wrapper management (caching, introspection). z3c.sqlalchemy gives you flexible control over the mapper creation. Mapper classes can be either auto-generated (with or without autodetection of table relationships) or configured by the developer. What z3c.sqlalchemy does not do and won't do: no support for Zope 3 schemas and no support for Archetypes schemas

z3c.tan

A Transaction Authorization Number, short TAN, is a security feature to give a principal additional permissions for a limited amount of time, either one transaction or a short time span, like a day or a week. This package implements a TAN system as a plugin to the authentication utility in zope.app.authentication

z3c.template

This package allows the separation of the registration of the view code and the layout (template). Similar, but has more features than z3c.viewtemplate

z3c.testing

Test Helpers for Zope3

z3c.traverser

A pluggable traverser for Zope 3 objects, which allows developers to develop new ways of composing URLs and traverse to objects.

z3c.viewlet

Provides an weight ordered viewlet manager.

z3c.viewtemplate

Separate the template registration from the view code.

z3c.website

The code that runs (will run) www.z3c.org

z3c.wfmcpersistent

This package has exactly the same functionality as the zope.wfmc, but all classes are redefined as persistent to be able to store the complete workflow process definition in the ZODB.

z3c.zalchemy

Integrates the object relational mapper SQLAlchemy into Zope 3 as SQLOS integrates sqlobject. zalchemy tries to do its best not to interfere with the standard SQLAlchemy usage. The main part of zalchemy is the integration of the SQLAlchemy transaction into the Zope transaction. This is solved by using a data manager which joins the Zope transaction for every newly created thread.

z3c.zodbbrowser

The ZODB Browser is a wxPython client application which can visualize the ZODB internals. After starting the ZODB Browser, you can open a Data.fs and traverse the database objects in a tree view.

z3c.zodbtracing

Package is meant to aid debugging/tracing ZODB. A special case was to determine from which point of the application a huge amount of object loading comes.

z3c.zrtresource

A simple templating engine to be used in generating free-form resources (not XML) - CSS files, JavaScript, etc.

z3c.vcsync

Takes an arbitrary object and syncs it through SVN. This means a serialization to text, and a deserialization from text. The text is stored in a SVN checkout. Newly appeared texts are svn added, removed texts are svn removed. svn move and svn copy are not supported. They will instead cause a svn delete/svn add combination.

z3c.widget.namespace

A custom traverser that allows getting rendered widgets independently of the form, by using the ++widget++ namespace. Useful mostly in AJAX based views.

Zope Corporation packages

zc.rebootstrap

Helper package to re-bootstrap packages for RPM construction.

zc.async

The zc.async package provides a way to make scalable asynchronous application calls.

zc.authorizedotnet

Authorize.Net provides credit card processing via a protocol on top of HTTPS.

zc.buildout

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.

zc.buildoutsftp

Provides a zc.buildout extension that provides support for SFTP.

zc.catalog

Is an extension to the Zope 3 catalog, Zope 3's indexing and search facility. zc.catalog contains a number of extensions to the Zope 3 catalog, such as some new indexes, improved globbing and stemming support, and an alternative catalog implementation.

zc.comment

The comment package is a simple way to add comments to any IAnnotatable Zope content. The datetime and current principals are stamped on to the comment. The comment body is currently simply unicode text but intended to be html snippets ("rich text") at a later date.

zc.copy

This is a Zope 3 extension that helps with pluggably copying objects.

zc.datetimewidget

Offers a popup javascript widget to enter dates.

zc.dict

A BTree-based persistent dict-like object that can be used as a base class. This is a bit of a heavyweight solution, as every zc.dict.Dict is at least 3 persistent objects. Keep this in mind if you intend to create lots and lots of these.

zc.displayname

A Zope 3 extension for pluggable display names. This could be used to generate names for content in lists or breadcrumbs.

zc.extrinsicreference

Extrinsic registries record a key and one or more values to which they refer.

zc.form

Contains various extra fields and widgets. (Most Recent Used widget, Union widget, Combination widget, etc)

zc.freeze

Pattern for freezing objects. State is informational--enforcement unspecified. Some enforcement approaches and helpers are included.

zc.i18n

Some date and duration conveniences, needed in zope.locking.browser.

zc.index

Provides various adapters that provide for searchable text extraction. Many of these adapters require running external applications over data stored in file objects (as defined in the `zope.file` package);

zc.listcontainer

A Zope-3-aware pseudo-list that generates events upon changes and maintains linked list information on its members. The difference to a standard container is that the standard container resembles a dictionary, while this imitates a list.

zc.mirrorshop

This package provides a mirror for the PyPI simple interface, http://cheeseshop.python.org/simple/.

zc.ngi

Network programs are typically difficult to test because they require setting up network connections, clients, and servers. In addition, application code gets mixed up with networking code. The Network Gateway Interface (NGI) seeks to improve this situation by separating application code from network code. This allows application and network code to be tested independently and provides greater separation of concerns.

zc.notification

Simple user notification framework. Currently includes email notification

zc.objectlog

The objectlog package provides a customizable log for a single object. The system was designed to provide information for a visual log of important object changes and to provide analyzable information for metrics. - It provides automatic recording for each log entry of a timestamp and the principals in the request when the log was made. - Given a schema of data to collect about the object, it automatically calculates and stores changesets from the last log entry, primarily to provide a quick and easy answer to the question "what changed?" and secondarily to reduce database size. - It accepts optional summary and detail values that allow the system or users to annotate the entries with human-readable messages. - It allows each log entry to be annotated with zero or more marker interfaces so that log entries may be classified with an interface.

zc.preview

This package contains a variety of preview views that are otherwise isolated. The previews are done based on the mimetype.

zc.queue

Queues that are optimized for persistency via the ZODB.

zc.recipe.cmmi

The configure-make-make-install recipe automates installation of configure-based source distribution into buildouts.

zc.recipe.deployment

The zc.recipe.deployment recipe provides support for deploying applications with multiple processes on Unix systems. (Perhaps support for other systems will be added later.) It creates directories to hold application instance configuration, log and run-time files. It also sets or reads options that can be read by other programs to find out where to place files.

zc.recipe.filestorage

This recipe can be used to define a file-storage. It creates a ZConfig file-storage database specification that can be used by other recipes to generate ZConfig configuration files

zc.recipe.rhrc

The zc.recipes.rhrc recipe creates Red-Hat Linux (chkconfig) rc scripts. It can create individual rc scripts, as well as combined rc scripts that start multiple applications.

zc.recipe.testrunner

This recipe generates zope.testing test-runner scripts for testing a collection of eggs. The eggs must already be installed (using the zc.recipe.egg recipe).

zc.recipe.zeo

The ZEO instance recipe (zc.recipe.zeoinstance) creates a ZEO instance. 

zc.recipe.zeoinstance

This recipe creates a basic ZEO instance.

zc.recipe.zope3checkout

Recipe for creating a Zope 3 checkout in a buildout.

zc.recipe.zope3instance

This recipe creates a Zope instance that has been extended by a collection of eggs.

zc.relationship

Low-level ZODB relationship index: supports intransitive and transitive n-ary relationships. Example usage of "relationship containers".

zc.resourcelibrary

The resource library is designed to make the inclusion of JavaScript, CSS, and other resources easy, cache-friendly, and component-friendly. For instance, if two widgets on a page need the same JavaScript library, the library should be only loaded once, but the widget designers should not have to concern themselves with the presence of other widgets.

zc.security

Enhanced UI for searching for principals: This package provides some Zope 3 user interfaces for searching for principals managed by the pluggable authentication utility.

zc.selenium

This package provides an easy way to use Selenium tests for Zope 3 applications. It provides Selenium itself as a resource directory, and it provides a test suite listing generated from registered views, allowing different packages to provide tests without a central list of tests to be maintained.

zc.set

Persistent sets are persistent objects that have the API of standard Python sets. The persistent set should work the same as normal sets, except that changes to them are persistent.

zc.sharing

"Sharing" Security Policy for Zope 3.

zc.shortcut

Symlinks for Zope 3.

zc.site

The `zc.site.search` module includes tools to support copying search results to the clipboard, which can be used for both portlet and non-portlet uses of searching. The support provided requires that search results are represented by sets of int ids and are presented using a table formatter based on `zc.table`.

zc.sourcefactories

Source factories are used to simplify the creation of sources for certain standard cases. Sources split up the process of providing input fields with choices for users into several components: a context binder, a source class, a terms class, and a term class.

zc.sshtunnel

This recipe creates a control script for an SSH tunnel. This is only expected to work on systems with the OpenSSH "ssh" binary on $PATH, and may require setting up the SSH configuration to use the expected usernames for each system.

zc.table

This is a Zope 3 extension that helps with the construction of (HTML) tables. Features include dynamic HTML table generation, batching and sorting.

zc.tokenpolicy

The tokenpolicy package supplies a modified sharing policy that honors tokens from the zope.locking package.

zc.twist

The twist package contains a few functions and classes, but primarily a helper for having a deferred call on a callable persistent object, or on a method on a persistent object. This lets you have a Twisted reactor call or a Twisted deferred callback affect the ZODB. Everything can be done within the main thread, so it can be full-bore Twisted usage, without threads.

zc.vault

Low-level versioning support similar to revision control systems, with an example usage and several example add-ons. ZODB-friendly.

zc.winauth

This package provides for authenticating windows users with their domain user names and passwords.

zc.z3monitor

The Zope 3 monitor server is a server that runs in a Zope 3 process and that provides a command-line interface to request various bits of information.

zc.zdaemonrecipe

The zdaemon recipe provides support for generating zdaemon-based run scripts.

zc.zodbactivitylog

This package provides an activity log that lets you track database activity.

zc.zodbrecipes

Recipes for working with ZODB.

zc.zope3recipes

Somewhat experimental recipes for creating Zope 3 instances with distinguishing features: - Don't use a skeleton- Separates application and instance definition - Don't support package-includes