This module exports two functions, nsort and ncmp; they are used in implementing
my idea of a "natural sorting" algorithm. Under natural sorting, numeric
substrings are compared numerically, and other word-characters are compared
lexically.
This is the way I define natural sorting:
* Non-numeric word-character substrings are sorted lexically,
case-insensitively: "Foo" comes between "fish" and "fowl".
* Numeric substrings are sorted numerically: "100" comes after "20",
not before.
* \W substrings (neither words-characters nor digits) are ignored. Our use
* of \w, \d, \D, and \W is locale-sensitive: Sort::Naturally
uses a use locale statement.
* When comparing two strings, where a numeric substring in one place
is not up against a numeric substring in another, the non-numeric always comes
first. This is fudged by reading pretending that the lack of a number substring
has the value -1, like so:
* The start of a string is exceptional: leading non-\W (non-word,
non-digit) components are ignored, and numbers come before letters.
* I define "numeric substring" just as sequences matching m/\d+/ --
scientific notation, commas, decimals, etc., are not seen. If your data has
thousands separators in numbers ("20,000 Leagues Under The Sea" or "20.000
lieues sous les mers"), consider stripping them before feeding them to nsort or
ncmp.
This is a pure-Tcl implementation of an HTTP protocol server. It runs as
a script on top of a vanilla Tcl interpreter using tcllib scripts and,
optionally, two binary libraries (crypt and limit).
The Tcl I/O system provides event-driven I/O facilities and a primitive
that copies data from one I/O channel to another. The server does the
HTTP protocol handling and then simply directs the I/O system to blast
data from disk to a network socket. The server has suprisingly good
performance because of Tcl's sophisticated I/O system.
The HTTP protocol is perhaps the least interesting aspect of the server.
The cool stuff is the framework for generating dynamic page content, and
the support for embedding the server directly into legacy applications
to "web-enable" them.
A Tcl-based web server is ideal for embedding because Tcl was designed
to support embedding into other applications. The interpreted nature of
Tcl allows dynamic reconfiguration of the server. Once the core
interface between the web server and the hosting application is defined,
it is possible to manage the web server, upload Safe-Tcl control
scripts, download logging information, and otherwise debug the Tcl part
of the application without restarting the hosting application.
LeechCraft is a free open source cross-platform modular live environment.
It has modules for everything:
* Full-featured web-browser with support for all major web-standards.
* Advanced multiprotocol modular IM client currently supporting XMPP (Jabber),
IRC, WLM/MSN, MRIM and quite a few other protocols and with a bunch of
features from metacontacts and Off-The-Record support to audio calls.
* Collection-oriented media player with a lot of features from gapless
playback and transcoding for removable devices to social features like
recommended artists and nearby events.
* Efficient and fast BitTorrent client with full support for the BitTorrent
protocol and all its widespread extensions and magnet links.
* Modular document viewer supporting PDF, DjVu, PostScript, MOBI and other
formats.
* RSS feed reader supporting common feed formats with extensions like MediaRSS
or GeoRSS as well as with extensive support for Broadcatching and podcasts and
their automatic retrieval.
* User-space package manager with its own repository of plugins, themes, icons
and much more.
* A bunch of Desktop Environment-enabling modules from window manager
controller to power manager, taskbar, tray and a customizable panel.
* The "Summary" tab that displays all your downloads, updates and statuses.
Cdparanoia is a Compact Disc Digital Audio (CDDA) Digital Audio Extraction
(DAE) tool, commonly known on the net as a 'ripper'. The application is
built on top of the Paranoia library, which is doing the real work (the
Paranoia source is included in the cdparanoia source distribution).
Cdparanoia reads audio from the CDROM directly as data, with no analog step
between, and writes the data to a file or pipe in WAV, AIFC, or raw 16 bit
linear PCM.
Cdparanoia is a bit different than most other CDDA extraction tools. It
contains few-to-no 'extra' features, concentrating only on the ripping
process and knowing as much as possible about the hardware performing it.
Cdparanoia will read correct, rock-solid audio data from inexpensive drives
prone to misalignment, frame jitter, and loss of streaming during atomic
reads. Cdparanoia will also read and repair data from CDs that have been
damaged in some way.
Cdparanoia is easy to use and administrate. It has no compile time
configuration, happily autodetecting the CDROM, its type, its interface and
other aspects of the ripping process at runtime. A single binary can serve
the diverse hardware of the do-it-yourself computer laboratory from Hell.
This program allows you to record the output of any standard OSS
program (one that uses /dev/dsp for sound) without having to modify or
recompile the program. It uses the same idea as the esddsp wrapper
from the Enlightened Sound Daemon (in fact, vsound is based on
esddsp). That is, it preloads a library that intercepts calls to open
/dev/dsp, and instead returns a handle to a normal file. It also
intercepts ioctl's on that file handle and logs them, to help convert
the audio data from its raw form. Vsound then uses sox to convert the
raw data to the desired file format.
The upshoot of this is that instead of playing sound to the sound card
in your computer, the data is recorded to a file. This is similar to
if you connected a loopback cable to the line in and line out jacks on
your sound card, but no DA or AD conversions take place, so quality is
not lost.
CIDER is a mixed-level circuit and device simulator. CIDER attempts to
provide greater simulation accuracy than a stand-alone circuit or device
simulator can provide. CIDER is based on the sequential mixed-level
circuit and device simulator, CODECS. In common with CODECS, CIDER embeds
the circuit simulator, SPICE3, which provides circuit simulation
capabilities, analytical models for semiconductor devices, and an
interactive user interface. An interface to the captive device simulator,
DSIM, provides accurate, one- and two-dimensional numerical models based
on the solution of Poisson's equation, and the electron and hole current-
continuity equations. The input format of CIDER couples SPICE-like
circuit descriptions to a device description format similar to the one
used by the PISCES device simulator developed at Stanford University.
As a result, CIDER should seem reasonably familiar to designers already
accustomed to both these tools.
SPICE is a general-purpose circuit simulation program for nonlinear DC,
nonlinear transient, and linear AC analyses. Circuits may contain resistors,
capacitors, inductors, mutual inductors, independent voltage and current
sources, four types of dependent sources, lossless and lossy transmission
lines (two separate implementations), switches, uniform distributed RC
lines, and the five most common semiconductor devices: diodes, BJTs, JFETs,
MESFETs, and MOSFETs.
Lots of times, Class::DBI is used in web-based applications. (In fact, coupled
with a templating system that allows you to pass objects, such as
Template::Toolkit, Class::DBI is very much your friend for these.)
And, as we all know, one of the most irritating things about writing web-based
applications is the monotony of writing much of the same stuff over and over
again. And, where there's monotony there's a tendency to skip over stuff that
we all know is really important, but is a pain to write - like Taint Checking
and sensible input validation. (Especially as we can still show a 'working'
application without it!). So, we now have CGI::Untaint to take care of a lot of
that for us.
It so happens that CGI::Untaint also plays well with Class::DBI. All you need
to do is to 'use Class::DBI::FromCGI' in your class (or in your local
Class::DBI subclass that all your other classes inherit from. You do do that,
don't you?).
pgloader imports data from a flat file and inserts it into one or
more PostgreSQL database tables. It uses a flat file per database
table, and you can configure as many Sections as you want, each one
associating a table name and a data file.
Data are parsed and rewritten, then given to PostgreSQL COPY command.
Parsing is necessary for dealing with end of lines and eventual trailing
separator characters, and for column reordering: your flat data file may
not have the same column order as the database table has.
pgloader is also able to load some large objects data into PostgreSQL,
as of now only Informix UNLOAD data files are supported. This command
gives large objects data location information into the main data file.
pgloader parse it add the text or bytea content properly escaped to the
COPY data.
pgloader issues some timing statistics every "commit_every" commits. At
the end of processing each section, a summary of overall operations,
numbers of rows copied and commits, time it took in seconds, errors
logged and database errors is issued.
The apptools project includes a set of packages that Enthought has
found useful in creating a number of applications.
- apptools.appscripting: Framework for scripting applications.
- apptools.help: Provides a plugin for displaying documents and examples.
- apptools.io: Provides an abstraction for files and folders in a
file system.
- apptools.logger: Convenience functions for creating logging handlers
- apptools.naming: Manages naming contexts, supporting non-string data
types and scoped preferences
- apptools.permissions: Supports limiting access to parts of an application
unless the user is appropriately authorised (not full-blown security).
- apptools.persistence: Supports pickling and restoring the state of an
object.
- apptools.preferences: Manages application preferences.
- apptools.selection: Manages the communication between providers and
listener of selected items in an application.
- apptools.scripting: A framework for automatic recording of Python scripts.
- apptools.sweet_pickle: Handles class-level versioning, to support
loading of saved data that exist over several generations of
internal class structures.
- apptools.template: Supports creating templatizable object hierarchies.
- apptools.type_manager: Manages type extensions, including factories to
generate adapters, and hooks for methods and functions.
- apptools.undo: Supports undoing and scripting application commands.
mercurial-server gives your developers remote read/write access to centralized
Mercurial repositories using SSH public key authentication; it provides
convenient and fine-grained key management and access control.
All of the repositories controlled by mercurial-server are owned by a single
user (the "hg" user in what follows), but many remote users can act on them,
and different users can have different permissions. We don't use file
permissions to achieve that - instead, developers log in as the "hg" user
when they connect to the repository host using SSH, using SSH URLs of the
form "ssh://hg@repository-host/repository-name". A restricted shell prevents
them from using this access for unauthorized purposes. Developers
are authenticated only using SSH keys; no other form of authentication is
supported.
To give a user access to the repository, place their key in an
appropriately-named subdirectory of "/usr/lcoal/etc/mercurialserver/keys"
and run "refresh-auth". You can then control what access they have to what
repositories by editing the control file
"/usr/local/etc/mercurialserver/access.conf", which can match the names of
these keys against a glob pattern.
For convenient remote control of access, you can instead (if you have the
privileges) make changes to a special repository called "hgadmin", which
contains its own "access.conf" file and "keys" directory. Changes pushed to
this repository take effect immediately. The two "access.conf" files are
concatenated, and the keys directories merged.