PyQuante is a suite of programs for writing quantum chemistry
software. The program is written in the Python programming language,
but has many "rate-determining" modules also written in C for
speed. The resulting code is not nearly as fast as Jaguar, Gaussian,
or GAMESS, but the resulting code is much easier to understand and
The goal of this software is not necessarily to provide a working
quantum chemistry program (although it will hopefully do that), but
rather to provide a well-engineered set of tools so that scientists
can construct their own quantum chemistry programs without going
through the tedium of having to write everything.
The program is released under the GNU General Public License and is
thus freeware. PyQuante can be downloaded from
http://pyquante.sourceforge.net. People can subscribe to the
pyquante-users mailing list at
Here is an example of what the closed-shell Hartree-Fock scripts look
(best viewed in a fixed-width font...)
"General wrapper for restricted closed-shell hartree fock"
from basis_631ss import basis
bfs = getbasis(atomlist,basis)
S,h = get1ints(bfs,atomlist)
Ints = get2ints(bfs)
energy = scf(atomlist,S,h,Ints)
"Run the self-consistent field optimization of the wave function"
evecs = get_guess(h,S)
nel = get_nel_from_atomlist(atomlist,charge)
nclosed,nopen = divmod(nel,2)
enuke = get_enuke_from_atomlist(atomlist)
print "nocc, enuke: ",nocc,enuke
eold = 0.
for i in range(MaxIter):
D = mkdens(evecs,0,nocc)
G = get2JmK(Ints,D)
F = h+G
evals,evecs = GHeigenvectors(F,S)
energy = get_energy(h,F,D,enuke)
if abs(energy-eold) < ConvCriteria: break
eold = energy
Announce: pyPgSQL - Version 2.2 is released.
pyPgSQL v2.2 has been released. It is a bug fix release to version 2.1.
It is available at http://pypgsql.sourceforge.net.
pyPgSQL is a package of two (2) modules that provide a Python DB-API 2.0
compliant interface to PostgreSQL databases. The first module, libpq,
exports the PostgreSQL C API to Python. This module is written in C and
can be compiled into Python or can be dynamically loaded on demand. The
second module, PgSQL, provides the DB-API 2.0 compliant interface and
support for various PostgreSQL data types, such as INT8, NUMERIC, MONEY,
BOOL, ARRAYS, etc. This module is written in Python and works with
PostgreSQL 7.0 or later and Python 2.0 or later.
Note: It is highly recommended that you use PostgreSQL 7.1 or later and
Python 2.1 or later.
PostgreSQL is a sophisticated Object-Relational DBMS, supporting almost all
SQL constructs, including sub-selects, transactions, and user-defined types
and functions. It is the most advanced open-source database available any-
where More information about PostgreSQL can be found at the PostgreSQL home
page at http://www.postgresql.org.
Python is an interpreted, interactive, object-oriented programming lang-
uage. It combines remarkable power with very clear syntax. It has mod-
ules, classes, exceptions, very high level dynamic data types, and dynamic
typing. There are interfaces to many system calls and libraries, as well
as to various windowing systems (X11, Motif, Tk, Mac, MFC). New builtin
modules are easily written in C or C++. Python is also usable as an exten-
sion language for applications that need a programmable interface. Python
is copyrighted but freely usable and distributable, even for commercial
use. More information about Python can be found on the Python home page at
Changes since pyPgSQL Version 2.1
The following source code files were added to Version 2.2 of pyPgSQL:
pyPgSQL.spec - RPM spec file, contributed by Sean Reifschneider.
Changes to README
* Added note about case-insensitiveness of column access in PgResultSet.
Changes to PgSQL.py
* Fixed various problems with the PgResultSet: Column (attribute and
dictionary) access is now case-insensitive. A __contains__ method was added
and the __setattr__ method was fixed. The get method got an optional default
* Fixed various problems with the PgNumeric type:
- Added code to allow a float as an argument to the PgNumeric constructor.
- You can now change the precision/scale of a PgNumeric by:
a = PgNumeric(pgnumeric, new prec, new scale).
This can be used to 'cast' a PgNumeric to the proper precision and scale
before storing it in a field.
- The arithmatic routines (__add__, __radd__, etc) now ensure that the
arguments are properly coerced to the correct types.
- Added support for the augmented arithmetic operations (__iadd__, etc).
- The math routines would lose precision because the precision/ scale were
set to be the same as the first operand. This is no longer the case all
precision is retained for the +, -, and * operations.
* Fixed problem that occurs when a query on an OID field doesn't return any
rows. [Bug #589370].
* Applied patch #569203 and also added __pos__ and __abs__ special methods to
* Ensure proper SQL-quoting of long ints.
Changes to PgSQLTestcases.py
* 14 new tests, mostly for PgNumeric and PgResultSet.
The new home page for the Puffin Automation Framework is live!
Check it out:
New documentation. New navigational structure.
What are you waiting for, start automating with Puffin today!
What is the Puffin Automation Framework?
As it's name implies, Puffin allows you to automate "actions."
An action, in terms of Puffin, is any "high level" execution item
that may require inputs, may produce outputs, and whose results may
be validated for success or failure. For example, an action may
involve making an HTTP request to a dynamic web page. It may
involve grabbing a file's contents or even retrieving a specific
email based on a keyword in the subject line. All of these are
actions in the sense that they can be automated by Puffin. Puffin
will manage all inputs, outputs, and validation for these actions.
Many technologies will allow you to do that. So why use Puffin?
The real differentiators for Puffin are the following:
1) No programming is required! If there is an action type for
your desired task already in the framework (and more are being
added all the time), then all you need is XML to configure your
2) You can create a transactional grouping of actions that succeed
only if every action in the group succeed.
3) You can automate tasks in a connected fashion (use the outputs
of action #1 as the inputs of actions #2 and #3).
4) You can automate intelligent repetition of task execution
(execute this action until X happens).
5) You can add dependencies to your action execution (execute
this action only if this other action's execution is successful).
6) Though programming is not required, you CAN extend any part
of the Puffin Automation Framework in your own Python programs.
The keyword is "framework." You can build applications that
leverage Puffin and all it provides.
7) You get failed task alerting (via email, file logs, etc) and
reporting as part of the framework.
8) Workspaces allow you to separate your problem space (places
where you would want to automate actions) into discrete chunks
with separate configurations and action definitions.
DAXFi 0.9 is available here:
DAXFi is a Python package that helps configure several different kinds
of firewalls in a consistent way.
The rules can be described with XML files, XML strings, or generated
directly by the code.
It comes with a Python package, useful to build other applications aimed
to manipulate different firewalls in a homogeneous way and includes some
useful example programs.
DAXFi is release under the GPL license.
In this release: the XML syntax was modified, many bugs were fixed, and
the C modules were compiled for the i386, Alpha, PPC, and Sparc64
architectures. Other changes were introduced to improve performance.
Personal home page: http://digilander.iol.it/alberanid/
<P><A HREF="http://daxfi.sourceforge.net/">DAXFi 0.9</A> - configure
several different kinds of firewalls in a consistent way. (07-Sep-02)
pysqlite - Extension module for SQLite databases.
A Python-DB API 2.0 compliant extension module that connects to
SQLite is a powerful, embedded relational database in a compact C
library. It supports a large subset of SQL92, multiple tables and indices,
transactions, and triggers. It has a simple C/C++ interface requiring
only three functions to perform queries. It has ODBC, JDBC, Perl-DBI, PHP,
Tcl, Delphi, Ruby, DBExpress, wxWindows, Eiffel, and Lua bindings.
Its source code is uncopyrighted and can be used for any purpose. More
information can be found at <http://www.hwaci.com/sw/sqlite/index.html>.
conn = sqlite.connect("db")
cursor = conn.cursor()
SQL = """ select category, family, genus, species
from calflora order by genus, species limit 10"""
for col in cursor.description:
print "\t %12s - %3s bytes" % (col, repr(col))
row = cursor.fetchone()
while row != None:
print "%14s, %15s, %19s, %8s, %25s" % tuple(row)
row = cursor.fetchone()
SQL = "insert into calflora (family,genus,species) values(%s,%s,%s)"
cursor.execute(SQL, ('greenus', 'weedus', 'maximus'))
Linux(source) and Windows (binary) downloads are available at
Gerhard Häring <haering_postgresql(a)gmx.de>
Michael Owens <mike(a)mikesclutter.com>
William Trenker <wtrenker(a)shaw.ca>
PySQLite has been tested on FreeBSD, Linux, and Windows with both Python 2.1
and 2.2. The latest versions of SQLite (v. 2.6 and greater) are recommended.
Version 0.3.0 fixed a lot of bugs, while also adding new features. Users of
PySQLite are recommended to upgrade.
The following are some of the changes and enhancements since the last
- Squashed a few memory leaks.
- Exposed the sqlite_exec, sqlite_last_insert_rowid and
sqlite_changes functions of SQLite to Python as methods of the
- Add support for Date types, if mxDateTime is
- Support for optional DB-API extensions from PEP 0249
- Added files for creating a PySQLite Debian package.
- setup.py: - Added Cygwin as platform that's supported by default
- Added third example: program to dump a table in XML format.
- Use bool type and custom bool converter for boolean fields.
- Set cursor.rowcount appropriately after DML (insert/update/delete)
- Fixed a bug with the SQL-quoting of longs.
- Inline documentation improvement.
- Change invocation of ReferenceError to work with Python 2.1
- (really) implemented weak references from cursors to connections
- Added new test suite.
- Adapted test for threadsafety attribute.
- Added checks with user-defined float and string functions.
- Removed Connection.begin(). Transactions are now started
implicitely. - Use DB-API quoting instead of manual Python
quoting. - Use string methods instead of the string module.
- Added checks for functions/aggreagates that raise exceptions or
return None (NULL).
- Added tests for proper commit/rollback behaviour. Added tests
for autocommit feature.
- Implemented autocommit feature. Renamed the parameter of
Connection.__init__ from "filename" to "db". Commit and rollback
now check if the connection is open at all. Started adapting the
weak reference code from pyPgSQL to loosely couple cursors and
connections. This is needed when you want to check if there are
any open cursors for a given connection, for example.
- Simplified version numbers, removed the check for equal version
numbers in _sqlite and sqlite. This looked like overhead to
me. The version number scheme is now only: major.minor.micro Set
threadsafety to level 1. I believe we can guarantee than sharing
the module among threads will do no harm. Sharing the connection
The System Modeling Workbench is a collection of tools for editing, storing,
analyzing and verifying models. It is based on the OMG MOF and UML standards
and it is implemented using the Python programming language. It is still
under development, but we think it already contains many interesting ideas.
It is distributed under the GNU General Public License and is available from
SMW is built from the following components:
- SMW Kernel. It implements a MOF-based metamodel as a collection of Python
classes. It supports OCL-like queries, bidirectional associations,
well-formed rules and XMI input and output.
- Repository. A central repository and version control system for MOF and
- Transformation Framework. A collection of classes for transforming models
into other artifacts: code, metrics, test cases, etc... It can also be used
to refactor models.
- Modeler. A graphical editor. It is still under construction but it already
has some cool features. It supports the following profiles:
* Plain UML 1.4 as defined in the OMG Standard. (www.omg.org/uml)
* Stepwise Feature Introduction for Python Profile. A profile for creating
Python programs based on UML 1.4 and the Stepwise Feature Introduction
* SA/RT. A profile for creating Real-Time Structured Analysis models.
The main contact person for the SMW Application is Ivan Porres. Send e-mail
to iporres(a)abo.fi or see
There's been a ton of press about applying Bayesian classifiers to
spam detection lately, spurred on by Paul Graham's recent paper "A
Plan for Spam"
Tim Peters has done an incredible amount of work on our Python
implementation of this idea. Some of the reasons why I think Tim's
work is so cool is that he's brought along his deep knowledge of
speech recognition's related issues, and his obsessive devotion to
reducing the amount of spam I ultimately have to delete <wink>.
In order to encourage more participation from the wider open source
community, we've moved the code from a backwater of the Python cvs
tree to its own project on SourceForge. The hope is that more people
will be able to contribute to ideas, testing, and integration of the
basic algorithms with other systems such as mail daemons, mailing list
managers, and mail clients.
The project is called "spambayes" (for lack of creativity on our part
:) and is hosted here:
If you're interested in becoming a developer on the project, let me
know. Otherwise you can of course get anonymous checkouts of the code.
There are also two mailing lists related to the spambayes project.
The first is a general discussion list:
and the other is a list for cvs checkin message notices:
Feel free to join those lists (and help be a guinea pig for Mailman
PS to Python-devers: the code has been removed from
nondist/sandbox/spambayes, so you won't be able to hack on it there.
Also, please move discussion about this from python-dev(a)python.org to
Version 0.5 of the scgi package is now available from:
The SCGI protocol is a replacement for the Common Gateway Interface
(CGI) protocol. It is a standard for applications to interface with
HTTP servers. It is similar to FastCGI but is designed to be easier to
Included in this package is mod_scgi, an Apache module that implements
the client side of the protocol. There is also a a Python package
called scgi which implements the server side of the protocol.
Changes in version 0.5
* Rewrite most of the scgi_server parent code. Drop the table of
busy children and the shared pipe between the parent and children.
Instead, the children write a byte on the Unix domain pipe when they
are ready for a request. In the process, fix a bug that caused the
parent to wait until all the children were ready before delegating a
request (found by Changjune Kim).
* Pass REMOTE_USER to SCGI servers (patch from Hamish Lawson).
Neil Schemenauer <nas(a)mems-exchange.org> | MEMS Exchange
Software Engineer | http://www.mems-exchange.org/
SC-Track Roundup 0.4.4 - an issue tracking system
Note: If you have an existing roundup installation, make a backup of your
database. Make sure you read doc/upgrading.txt!
This is probably the last 0.4 maintenance release, since I hope to release
the first 0.5 beta next week :)
Roundup requires python 2.1.1 for correct operation. Support for dumbdbm
requires python 2.1.2 or 2.2. 2.1.3 and 2.2.1 are recommended.
This is a bugfix release, fixing:
. bug in database opening
. sf bug #596155: bug with multilink
. sf bug #600699: documentation in doc/getting_started.txt
. sf bug #600700: doc/upgrading.txt: no info about 0.4.3
. sf bug #603696: Mail followup not inserted
. sf bug #603703: way to unassign issues
Source and documentation is available at the website:
Release Info (via download page):
Mailing lists - the place to ask questions:
Roundup is a simple-to-use and -install issue-tracking system with
command-line, web and e-mail interfaces. It is based on the winning design
from Ka-Ping Yee in the Software Carpentry "Track" design competition.
Note: Ping is not responsible for this project. The contact for this project
Roundup manages a number of issues (with flexible properties such as
"description", "priority", and so on) and provides the ability to:
(a) submit new issues,
(b) find and edit existing issues, and
(c) discuss issues with other participants.
The system will facilitate communication among the participants by managing
discussions and notifying interested parties when issues are edited. One of
the major design goals for Roundup that it be simple to get going. Roundup
is therefore usable "out of the box" with any python 2.0+ installation. It
doesn't even need to be "installed" to be operational, though a
disutils-based install script is provided.
It comes with two issue tracker templates and three database back-ends.