A universal feed parser module for Python that handles RSS 0.9x, RSS 1.0, RSS
2.0, CDF, Atom 0.3, Atom 1.0 feeds.

Restkit is an HTTP resource kit for Python. It allows you to easily access to HTTP resource and build objects around it. It's the base of couchdbkit a Python CouchDB framework.

Restkit is a full HTTP client using pure socket calls and its own HTTP parser. It's not based on httplib or urllib2.

The Zope Object Database provides an object-oriented database for
Python that provides a high-degree of transparency. Applications can
take advantage of object database features with few, if any, changes
to application logic. ZODB includes features such as a plugable storage
interface, rich transaction support, and undo.

As of now, writing custom decorators correctly requires some experience and it
is not as easy as it could be. For instance, typical implementations of
decorators involve nested functions, and we all know that flat is better than
nested. Moreover, typical implementations of decorators do not preserve the
signature of decorated functions, thus confusing both documentation tools and
developers.

The aim of the decorator module it to simplify the usage of decorators for the
average programmer, and to popularize decorators usage giving examples of
useful decorators, such as memoize, tracing, redirecting_stdout, locked, etc.

Distribute is a fork of the Setuptools project.

Distribute is intended to replace Setuptools as the standard method for working
with Python module distributions.

This class facilitates building frameworks of several classes that inter-
operate. It was first designed and built for HTML::Mason, in which the
Compiler, Lexer, Interpreter, Resolver, Component, Buffer, and several
other objects must create each other transparently, passing the appropriate
parameters to the right class, possibly substituting other subclasses for
any of these objects.

This module provide a single function called dump() that takes a list of
values as argument and produce a string as result. The string contains perl
code that when evaled will produce a deep copy of the original arguments. The
string is formatted for easy reading.

The Devel::StackTrace module contains two classes, Devel::StackTrace and
Devel::StackTrace::Frame. The goal of this object is to encapsulate the
information that can found through using the caller() function, as well as
providing a simple interface to this data.

The Devel::StackTrace object contains a set of Devel::StackTrace::Frame
objects, one for each level of the stack. The frames contain all the data
available from 'caller()'.

This code was created to support my the Exception::Class::Base manpage
class (part of Exception::Class) but may be useful in other contexts.

This class implements a regex-based RFC 2822 parser that locates email
addresses in strings and returns a list of 'Email::Address' objects found.
Alternatley you may construct objects manually. The goal of this software
is to be correct, and very very fast.

Message-ids are optional, but highly recommended, headers that identify a
message uniquely. This software generates a unique message-id.

'Email::Simple' is the first deliverable of the "Perl Email Project." The
Email:: namespace was begun as a reaction against the increasing complexity
and bugginess of Perl's existing email modules. 'Email::*' modules are
meant to be simple to use and to maintain, pared to the bone, fast, minimal
in their external dependencies, and correct.

This module determines whether an email address is well-formed, and
optionally, whether a mail host exists for the domain.

Please note that there is no way to determine whether an address is
deliverable without attempting delivery (for details, see perlfaq 9).

This Perl module is an Encode::Encoding subclass that uses
Encode::Detect::Detector to determine the charset of the input data and then
decodes it using the encoder of the detected charset.

It is similar to Encode::Guess, but does not require the configuration of a set
of expected encodings. Like Encode::Guess, it only supports decoding--it cannot
encode.

Exception::Class allows you to declare exception hierarchies in your modules in
a "Java-esque" manner.

It features a simple interface allowing programmers to 'declare' exception
classes at compile time. It also has a base exception class,
Exception::Class::Base, that can be easily extended.

It is designed to make structured exception handling simpler and better by
encouraging people to use hierarchies of exceptions in their applications,
as opposed to a single catch-all exception class.

This module does not implement any try/catch syntax. Please see the
"OTHER EXCEPTION MODULES (try/catch syntax)" section for more information on
how to get this syntax.

You will also want to look at the documentation for Exception::Class::Base,
which is the default base class for all exception objects created
by this module.

Author: Dave Rolsky

This is an alternative to Exporter intended to provide a lightweight subset
of its functionality. It supports 'import()', '@EXPORT' and '@EXPORT_OK'
and not a whole lot else.

Unlike Exporter, it is not necessary to inherit from Exporter::Lite (ie. no
'@ISA = qw(Exporter::Lite)' mantra). Exporter::Lite simply exports its
import() function. This might be called a "mix-in".

Setting up a module to export its variables and functions is simple:

package My::Module;
use Exporter::Lite;

@EXPORT = qw($Foo bar);

now when you 'use My::Module', '$Foo' and 'bar()' will show up.

In order to make exporting optional, use @EXPORT_OK.

package My::Module;
use Exporter::Lite;

@EXPORT_OK = qw($Foo bar);

when My::Module is used, '$Foo' and 'bar()' will _not_ show up. You have to
ask for them. 'use My::Module qw($Foo bar)'.

HTML-Element-Extended is a package of several enhanced HTML::Element
classes, most of which arose during the effort to implement an
HTML::Element based table class.

The modules are:
HTML::ElementTable
HTML::ElementSuper
HTML::ElementGlob
HTML::ElementRaw

The resulting functionality enables:
tables
element globs
element coordinates
content replacement
content wrapping
element cloning
raw HTML string adoption

If you wanna "scrub" or "sanitize" html input in a reliable and flexible
fashion, then this module is for you.

I wasn't satisfied with HTML::Sanitizer because it is based on
HTML::TreeBuilder, so I thought I'd write something similar that works
directly with HTML::Parser.

************************** CAUTION ********************************
* This is 'JSON module version 2' and there are many differences *
* to version 1.xx *
* Please check your applications useing old version. *
* See to 'INCOMPATIBLE CHANGES TO OLD VERSION' *
*******************************************************************

JSON (JavaScript Object Notation) is a simple data format. See to the
http://www.json.org/ manpage and 'RFC4627'(the
http://www.ietf.org/rfc/rfc4627.txt manpage).

This module converts Perl data structures to JSON and vice versa using
either the JSON::XS manpage or the JSON::PP manpage.

JSON::XS is the fastest and most proper JSON module on CPAN which must be
compiled and installed in your environment. JSON::PP is a pure-Perl module
which is bundled in this distribution and has a strong compatibility to
JSON::XS.

This module try to use JSON::XS by default and fail to it, use JSON::PP
instead. So its features completely depend on JSON::XS or JSON::PP.

See to the BACKEND MODULE DECISION manpage.

To distinguish the module name 'JSON' and the format type JSON, the former
is quoted by C<> (its results vary with your using media), and the latter
is left just as it is.

Module name : 'JSON'

Format type : JSON

Use the GMP library for Math::BigInt routines

"diff()" provides a basic set of services akin to the GNU "diff"
utility. It is not anywhere near as feature complete as GNU "diff", but
it is better integrated with Perl and available on all platforms. It is
often faster than shelling out to a system's "diff" executable for small
files, and generally slower on larger files.

Relies on Algorithm::Diff for, well, the algorithm. This may not produce
the same exact diff as a system's local "diff" executable, but it will
be a valid diff and comprehensible by "patch". We haven't seen any
differences between Algorithm::Diff's logic and GNU diff's, but we have
not examined them to make sure they are indeed identical.