Provides easy parsing of URLs and their constituent parts.

Services_Weather searches for given locations and retrieves current
weather data and, dependent on the used service, also forecasts. Up to
now, GlobalWeather from CapeScience, Weather XML from EJSE (US only),
a XOAP service from Weather.com and METAR/TAF from NOAA are supported.
Further services will get included, if they become available, have a
usable API and are properly documented.

Implementation of SOAP protocol and services

Implementation of CAPTCHAs (completely automated public Turing test to tell computers and humans apart)
http://pear.php.net/manual/.

Engine for use FIGlet fonts to rendering text

Text_Password allows one to create pronounceable and unpronounceable
passwords. The full functional range is explained in the manual at
http://pear.php.net/manual/.

XML_Serializer serializes complex data structures like arrays or object as XML
documents.

This class helps you generating any XML document you require without the need
for DOM.

Furthermore this package can be used as a replacement to serialize() and
unserialize() as it comes with a matching XML_Unserializer that is able to
create PHP data structures (like arrays and objects) from XML documents, if
type hints are available.

If you use the XML_Unserializer on standard XML files, it will try to guess
how it has to be unserialized. In most cases it does exactly what you expect
it to do. Try reading a RSS file with XML_Unserializer and you have the whole
RSS file in a structured array or even a collection of objects,
similar to XML_RSS.

Since version 0.8.0 the package is able to treat XML documents similar to the
simplexml extension of PHP 5.

Author:
-------
Stephan Schmidt

This package provides an object-oriented API for building SVG documents.

Beautiful Soup is a Python HTML/XML parser designed for quick turnaround
projects like screen-scraping. Three features make it powerful:

* Beautiful Soup won't choke if you give it bad markup. It yields a parse tree
that makes approximately as much sense as your original document. This is
usually good enough to collect the data you need and run away

* Beautiful Soup provides a few simple methods and Pythonic idioms for
navigating, searching, and modifying a parse tree: a toolkit for dissecting a
document and extracting what you need. You don't have to create a custom
parser for each application

* Beautiful Soup automatically converts incoming documents to Unicode and
outgoing documents to UTF-8. You don't have to think about encodings, unless
the document doesn't specify an encoding and Beautiful Soup can't autodetect
one. Then you just have to specify the original encoding

Beautiful Soup parses anything you give it, and does the tree traversal stuff
for you. You can tell it "Find all the links", or "Find all the links of class
externalLink", or "Find all the links whose urls match "foo.com", or "Find the
table heading that's got bold text, then give me that text."

Valuable data that was once locked up in poorly-designed websites is now within
your reach. Projects that would have taken hours take only minutes with
Beautiful Soup.

CherryPy is a pythonic, object-oriented web development framework.

CherryPy allows developers to build web applications in much the same way they
would build any other object-oriented Python program. This usually results in
smaller source code developed in less time.

CherryPy is now more than three years old and it is has proven very fast and
stable. It is being used in production by many sites, from the simplest ones
to the most demanding ones.

Oh, and most importantly: CherryPy is fun to work with :-)

ClientForm is a Python module for handling HTML forms on the client side,
useful for parsing HTML forms, filling them in and returning the completed
forms to the server. It developed from a port of Gisle Aas' Perl module
HTML::Form, from the libwww-perl library, but the interface is not the same.

ConfigObj is a simple but powerful config file reader and writer: an ini file
round tripper. Its main feature is that it is very easy to use, with a
straightforward programmer's interface and a simple syntax for config files.

It has lots of other features though :
* Nested sections (subsections), to any level
* List values
* Multiple line values
* String interpolation (substitution)
* Integrated with a powerful validation system
including automatic type checking/conversion, repeated sections,
and allowing default values
* All comments in the file are preserved
* The order of keys/sections is preserved
* No external dependencies
* Full Unicode support
* A powerful unrepr mode for storing basic datatypes

PycURL is a Python module interface to the cURL library. PycURL can be
used to fetch objects identified by an URL within a Python program.

dnspython is a DNS toolkit for Python. It supports almost all record
types. It can be used for queries, zone transfers, and dynamic updates.
It supports TSIG authenticated messages and EDNS0.

dnspython provides both high and low level access to DNS. The high
level classes perform queries for data of a given name, type, and
class, and return an answer set. The low level classes allow direct
manipulation of DNS zones, messages, names, and records.

Jinja2 is a template engine written in pure Python. It provides a
Django inspired non-XML syntax but supports inline expressions and
an optional sandboxed environment.

matplotlib is a python 2D plotting library which produces publication
quality figures in a variety of hardcopy formats and interactive
environments across platforms. matplotlib can be used in python
scripts, the python and ipython shell (ala matlab or mathematica), web
application servers, and six graphical user interface toolkits.

Stateful programmatic web browsing, after Andy Lester's Perl module
WWW::Mechanize.

The library is layered: mechanize.Browser (stateful web browser),
mechanize.UserAgent (configurable URL opener), plus urllib2 handlers.

Features include: ftp:, http: and file: URL schemes, browser history,
high-level hyperlink and HTML form support, HTTP cookies, HTTP-EQUIV and
Refresh, Referer [sic] header, robots.txt, redirections, proxies, and Basic and
Digest HTTP authentication. mechanize's response objects are (lazily-)
.seek()able and still work after .close().

Much of the code originally derived from Perl code by Gisle Aas (libwww-perl),
Johnny Lee (MSIE Cookie support) and last but not least Andy Lester
(WWW::Mechanize). urllib2 was written by Jeremy Hylton.

nose provides an alternate test discovery and running process for unittest, one
that is intended to mimic the behavior of py.test as much as is reasonably
possible without resorting to magic. By default, nose will run tests in files
or directories under the current working directory whose names include "test".

nose also supports doctest tests and may optionally provide a test coverage
report.

The pyparsing module is an alternative approach to creating and executing
simple grammars, vs. the traditional lex/yacc approach, or the use of regular
expressions. The pyparsing module provides a library of classes that client
code uses to construct the grammar directly in Python code.

pyinotify is a Python module for watching filesystems changes. By its design
pyinotify can be used for any kind of fs monitoring.

pyinotify relies on a recent Linux Kernel feature (merged in kernel 2.6.13)
called inotify. inotify is an event-driven notifier, its notifications are
exported from kernel space to user space. The raw interface of inotify is
compounded of three system calls. pyinotify binds these system calls and
provides an implementation on top of them offering a generic and abstract way
to use inotify with Python. Pyinotify doesn't requires much detailed knowledge
of inotify. Moreover, it only needs few statements for initializing, watching,
handling (eventually trough a new separate thread), and processing events
notifications through subclassing. The only things to know is the path of items
to watch, the kind of events to monitor and the actions to execute on these
notifications.

Note: pyinotify requires Python 2.3 and above, and Linux 2.6.13 at least.

Sphinx is a tool that makes it easy to create intelligent and beautiful
documentation for Python projects (or other documents consisting of multiple
reStructuredText sources), written by Georg Brandl. It was originally created
for the new Python documentation, and has excellent facilities for Python
project documentation, but C/C++ is supported as well, and more languages are
planned.

Sphinx uses reStructuredText as its markup language, and many of its strengths
come from the power and straightforwardness of reStructuredText and its parsing
and translating suite, the Docutils.

pytz brings the Olson tz database into Python. This library allows
accurate and cross platform timezone calculations using Python 2.3 or
higher. It also solves the issue of ambiguous times at the end of
daylight savings, which you can read more about in the Python Library
Reference (datetime.tzinfo).

Sarg -- Squid Analysis Report Generator is a tool that allows you to
view "where" your users are going to on the Internet. Sarg generate
reports in html, with fields such as: users, IP Addresses, bytes,
sites, and times.

The stable version of the Squid WWW Proxy Server.

Home page: http://www.squid-cache.org

A recent development snapshot of the squid V3.0 WWW proxy server.