Text::CSV::Hashify is designed for the case where you simply want to turn a CSV
file into a Perl hash. In particular, it is designed for the case where (a) the
CSV file's first record is a list of fields in the ancestral database table and
(b) one field (column) of which functions as a primary key, i.e., each record's
entry in that field is distinct from every other record's entry therein.
Text::CSV::Hashify turns that kind of CSV file into one big hash of hashes.
Elements of this hash are keyed on the entries in the designated primary key
field and the value for each element is a hash reference of all the data in a
particular database record (including the primary key field and its value).
The confget utility examines a INI-style configuration file and retrieves
the value of the specified variables from the specified section.
Its intended use is to let shell scripts use the same INI-style
configuration files as other programs, to avoid duplication of data.
The confget utility may retrieve the values of one or more variables,
list all the variables in a specified section, list only those whose names
or values match a specified pattern (shell glob or regular expression), or
check if a variable is present in the file at all. It has a "shell-quoting"
output mode that quotes the variable values in a way suitable for passing
them directly to a Bourne-style shell.
PyStemmer provides access to efficient algorithms for calculating a
"stemmed" form of a word. This is a form with most of the common
morphological endings removed; hopefully representing a common
linguistic base form. This is most useful in building search engines
and information retrieval software; for example, a search with stemming
enabled should be able to find a document containing "cycling" given the
query "cycles".
PyStemmer provides algorithms for several (mainly european) languages,
by wrapping the libstemmer library from the Snowball project in a Python
module. It also provides access to the classic Porter stemming algorithm
for english: although this has been superceded by an improved algorithm,
the original algorithm may be of interest to information retrieval
researchers wishing to reproduce results of earlier experiments.
The re_graph.pl program graphs regular expressions. The guts of the regular
expression engine is a simple state machine. The various states and
operations in the regular expression parser can be displayed using a
surprisingly simple diagram.
A few notes on what you are looking at:
* The nodes Start and Stop denote the beginning and end of the regular
expression.
* The solid squares denote atoms. Lines indicate the next state. When a
line splits, the state machine will take the top line first. If it's
path is blocked it will backup and take the next lower line. This is
repeated until it finds a path to the end or all paths are exhausted.
* Brown boxes indicate a grouping operation, i.e. ().
* Green boxes indicate a zero with test. The state machine will perform
the test inside the box before moving ahead.
Redet allows the user to construct regular expressions and test them against
input data by executing any of a variety of search programs, editors, and
programming languages that make use of regular expressions. When a suitable
regular expression has been constructed it may be saved to a file. redet stands
for Regular Expression Development and Execution Tool. For each program, a
palette showing the available regular expression syntax is provided. Selections
from the palette may be copied to the regular expression window with a mouse
click. Users may add their own definitions to the palette via their
initialization file. Redet also keeps a list of the regular expressions
executed, from which entries may be copied back into the regular expression
under construction. The history list is saved to a file and restored on
startup, so it persists across sessions. So long as the underlying program
supports Unicode, redet allows UTF-8 Unicode in both test data and regular
expressions
HTML::Breadcrumbs is a module used to create HTML 'breadcrumb trails'
i.e. an ordered set of html links locating the current page within
a hierarchy.
HTML::Breadcrumbs splits the given path up into a list of elements,
derives labels to use for each of these elements, and then renders
this list as N-1 links using the derived label, with the final
element being just a label.
Both procedural and object-oriented interfaces are provided. The OO
interface is useful if you want to separate object creation and
initialisation from rendering or display, or for subclassing.
Both interfaces allow you to munge the path in various ways, to set
labels either explicitly via a hashref or via a callback subroutine,
and to control the formatting of elements via sprintf patterns or a
callback subroutine.
The HTML::Field set of modules creates objects that represent HTML form fields
which try to make it easier to interact with CGI objects, databases, and
HTML::Template objects.
The objective of an HTML::Field object is to know how to write its own HTML,
how to get its value out of a CGI object or from a hash,
how to add their value to a hash suitable for passing into a HTML::Template
or into a SQL::Abstract object, for example, and thus re-use some of the code
which is typically repeated several times in a CGI script.
This bundle includes also HTML::FieldForm, which is a very simple module to
manage sets of HTML::Field objects.
Load, configure, and compose WSGI applications and servers
Paste Deployment is a system for finding and configuring WSGI
applications and servers. For WSGI application consumers it provides a
single, simple function (loadapp) for loading a WSGI application from
a configuration file or a Python Egg. For WSGI application providers
it only asks for a single, simple entry point to your application, so
that application users don't need to be exposed to the implementation
details of your application.
The result is something a system administrator can install and manage
without knowing any Python, or the details of the WSGI application or
its container.
This tool provides code to load WSGI applications and servers from
URIs; these URIs can refer to Python Eggs for INI-style configuration
files. Paste Script provides commands to serve applications based on
this configuration file.
TurboGears 2 is a reinvention of the TurboGears project to take
advantage of new components, and to provide a fully customizable
WSGI (Web Server Gateway Interface) stack. From the beginning
TurboGears was designed to be a Full Stack framework built from
best-of-breed components. New components have been released which
improved on the ones in the original TGstack, and the Python web
world has been increasingly designed around WSGI.
This has enabled a whole new world of reuse, and TG2 is designed
to take advantage of this fact in order to make a framework which
provides easy to use, productive defaults, while still providing
flexibility where it is useful.
TG2 represents a change from some of the components in TurboGears 1,
but we have now invested in a set of components that we think will
continue to be at the center of python web development for years to
come.
Wysiwyg API allows to use client-side editors (a.k.a. WYSIWYG editors) for
editing content in the Drupal CMS. It simplifies installation of editors
and allows you to define which editor to use depending on the input format.
This module replaces all existing editor integration modules and no other
Drupal module is required.
It is capable of supporting any kind of client-side editor as long as there
are support files for it that integrate the external library with Wysiwyg
API. A client-side editor can be a regular HTML-based editor, a
"pseudo-editor" (that just provides buttons to insert HTML markup into a
plain textarea), or even a Flash-based editor. Support for various editor
libraries is built-in.
The Wysiwyg API also allows Drupal modules to register plugins (or
"buttons") for editors.