SciParam 1.0.0 is a Python package to easily add additional quality
control for entering scientific parameters in wxPython-based user
See http://great-er.intevation.org/sciparam/ for download,
documentation and screenshots.
Copyright (C) 2002, 2003
Intevation GmbH <intevation(a)intevation.de>
Thomas Koester <tkoester(a)intevation.de>
After my wedding on July 30th, 2003:
Thomas Arendsen Hein <thomas(a)intevation.de>
SciParam is released under the GNU General Public License.
Email: rufus(a)o-town.de (at work: tkoester(a)intevation.de)
Announcing PyTables 0.7
PyTables is a hierarchical database package designed to efficently
manage very large amounts of data. PyTables is built on top of the
HDF5 library and the numarray package and features an object-oriented
interface that, combined with C-code generated from Pyrex sources,
makes it a fast, yet extremely easy to use tool for interactively save
and retrieve large amounts of data.
Release 0.7 is the third public beta release. The version 0.6 was
internal and will never be released.
On this release you will find:
- new AttributeSet class
- 25% I/O speed improvement
- fully multidimensional table cells support
- new column descriptors
- row deletion in tables is finally here
- much more!
More in detail:
- A new AttributeSet class has been added. This will allow the
addition and deletion of generic attributes (any scalar type plus
any Python object supported by Pickle) as easy as this:
table.attrs.date = "2003/07/28 10:32" # Attach a string to table
group._v_attrs.tempShift = 1.2 # Attach a float to group
array.attrs.detectorList = [1,2,3,4] # Attach a list to array
del array.attrs.detectorList # Detach detectorList attr from array
- PyTables now has support for fully multidimensional table cells. This
has been made possible in part by implementation of multidimensional
cells in numarray.records.RecArray object. Thanks to numarray crew,
and especially to Jin-chung Hsu, for willingly accepting to do
that, and also for including some cache improvements in RecArray.
- New column descriptors added: IntCol, Int8Col, UInt8Col, Int16Col,
UInt16Col, Int32Col, UInt32Col, Int64Col, UInt64Col, FloatCol,
Float32Col, Float64Col and StringCol. I think they are more explicit
and easy-to-use than the now deprecated (but still supported)
Col() descriptor. All the examples and user's manual has been
- The new Table.removeRows(start, stop) function allows you to remove
rows from tables. This feature was requested a long time ago. There
are still limitations, however: you cannot delete rows in extremely
large Tables (as the remaining rows after the stop parameter
are stored in memory). Nor is the performance optimized. These issues
will hopefully be addressed in future releases.
- Added iterators to File, Group and Table (they now support the special
__iter__() method). They make the object much more user-friendly,
especially in interactive mode. See documentation for usage examples.
- Added a __getitem__() method to Table that works more or less like
read(), but with extended slices support.
- As a consequence of rewriting table iterators in C (with the help of
Pyrex, of course) the table read performance has been improved
between 20% and 30%. Data selections in PyTables are now starting to
beat powerful relational databases like SQLite, even compared to
in-core selects (!). I think there is still room for another 20% or
30% speed improvement, so stay tuned.
- A checksum is now added automatically when using LZO (not with UCL
where I'm having some difficulties implementing that
capability). The Adler32 algorithm has been chosen because of its
speed. With that, the compressing/decompressing speed has dropped 1%
or 2%, which is hardly noticeable. I think this addition will allow
the cautious user to be a bit more confident about this excellent
compressor. Code has been added to be able to read files created
without this checksum (so you can be confident that you will be able
to read your existing files compressed with LZO and UCL).
- Recursion has been removed from PyTables. Before, this made the
maximum depth tree to be less than the Python recursion limit (which
depends on implementation, but is around 900, at least in
Linux). Now, the limit has been set (somewhat arbitrarily) at
2048. Thanks to John Nielsen for implementing the new iterative
- A new rootUEP parameter to openFile() has been added. You can now
define the root from which you want to start to build the object tree.
Thanks to John Nielsen for the suggestion and a first implementation.
- A small bug fixed when dealing with non-native PyTables files that
prevented the use of the "classname" filter during a listNodes()
call. Thanks to Jeff Robbins for reporting that.
- Some (non-serious) bugs were discovered and fixed.
- Updated documentation to explain all these new bells and whistles. It
is also available on the web:
- Added more unit tests (more than 350 now!)
- PyTables 0.7 *needs* numarray 0.6 or higher and HDF-1.6.0 or higher
to compile and work. It has been tested with Python 2.2 and 2.3 and
should work fine on both versions.
What is a table?
A table is defined as a collection of records whose values are stored
in fixed-length fields. All records have the same structure and all
values in each field have the same data type. The terms
"fixed-length" and "strict data types" seems to be quite a strange
requirement for an language like Python, that supports dynamic data
types, but they serve a useful function if the goal is to save very
large quantities of data (such as is generated by many scientific
applications, for example) in an efficient manner that reduces demand
on CPU time and I/O resources.
What is HDF5?
For those people who know nothing about HDF5, it is is a general
purpose library and file format for storing scientific data made at
NCSA. HDF5 can store two primary objects: datasets and groups. A
dataset is essentially a multidimensional array of data elements, and
a group is a structure for organizing objects in an HDF5 file. Using
these two basic constructs, one can create and store almost any kind of
scientific data structure, such as images, arrays of vectors, and
structured and unstructured grids. You can also mix and match them in
HDF5 files according to your needs.
I'm using Linux as the main development platform, but PyTables should
be easy to compile/install on other UNIX machines. This package has
also passed all the tests on a UltraSparc platform with Solaris 7 and
Solaris 8. It also compiles and passes all the tests on a SGI
Origin2000 with MIPS R12000 processors and running IRIX 6.5.
Regarding Windows platforms, PyTables has been tested with Windows
2000 and Windows XP, but it should also work with other flavors.
For online code examples, have a look at
Go to the PyTables web site for more details:
Share your experience
Let me know of any bugs, suggestions, gripes, kudos, etc. you may
-- Francesc Alted
HarvestMan, is a mulyithreaded, highly customizable command line
offline browser written completely in python. It allows one to
download websites or specific files from websites to the hard disk
for offline browsing.
The project page is situated at
Version 1.1 with many changes, fixes and updates is
available for download and review.
Thanks to everyone who used the program, reviewed it and sent
in their suggestions.
dnspython 1.1.0b2 has been released; here's the README file:
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.
To see a few of the ways dnspython can be used, look in the examples/
dnspython originated at Nominum where it was developed to facilitate
the testing of DNS software. Nominum has generously allowed it to be
open sourced under a BSD-style license, and helps support its future
development by continuing to employ the author :).
ABOUT THIS RELEASE
This is dnspython 1.1.0b2.
New in this release:
Zones now have find_rrset() and find_rdataset() convenience
methods. They let you retrieve rdata with the specified name
and type in one call, e.g.:
rrset = zone.find_rrset('foo', 'mx')
Nodes no longer have names; owner names are associated with
nodes in the Zone object's nodes dictionary. (It is my hope
that this is the last non-backwards compatible change that
will be made to the API.)
The Zone class now implements more of the standard mapping
interface. E.g. you can say zone.keys(), zone.get('name'),
zone.iteritems(), etc. __iter__() has been changed to iterate
the keys rather than values to match the standard mapping
The IPv6 version of inet_ntoa now emits embedded IPv4
addresses using the preferred syntax.
This release fixes all known bugs from 1.1.0b1.
See the ChangeLog file for more detailed information on changes since
the prior release.
Python 2.2 or later.
To build and install dnspython, type
python setup.py install
For the latest in releases, documentation, and information, visit the
dnspython home page at
Documentation is sparse at the moment. Use pydoc, or read the HTML
documentation at the dnspython home page, or download the HTML
Bug reports may be sent to bugs(a)dnspython.org
A number of mailing lists are available. Visit the dnspython home
page to subscribe or unsubscribe.
The python libraries like urllib and httplib do not support ssl
through a proxy.
Urllib2 supports http through a proxy or https alone, but not https
through a proxy.
A while ago my wife complained to me that perl had trouble w/https. I
was surprised since perl has a lot of networking libraries. Preferring
python, I took a look a python and found the same problem. Eventually
I figured out what python was missing: tunnelling. Though she may
_coax_ me to port the code to perl, I'm writing it first in my
Pytunnel offers a tunnel that can be used for (among other things)
tunnelling the ssl through a proxy.
I'd be willing to offer suggestions or myself add the necessary code
to urllib2. Anyone know how one goes about doing either?
Your python code does not need to be changed except that the port and
ip are supplied by the tunnel. Pytunnel uses a custom recvall which is
like sendall but for recv. Recvall uses non-blocking sockets,timeouts
and sleeps to attempt to get all of the data. If you have a bad
network connection you'd want to set the timeout to be high. Recvall
will probably be slower than a standard recvall.
The code is rough and needs better error handling, comments and such.
But since I got it working I decided to post it.
You can find it at:
Example of usage:
conn = httplib.HTTPSConnection(ip,port=port)
response = conn.getresponse()
Version 0.8.3 of the Python/XML distribution is now available. It
should be considered a beta release, and can be downloaded from
the following URLs:
Changes in this version, compared to 0.8.2:
* Fix memory leak in Expat bindings (content model information
provided by Expat was not freed as required).
* New convenience classes in the xml.ns module:
* The symbol "_" is no longer inserted into the built-in
namespace via the gettext module; I18N support is no longer
* expatreader now implements feature_namespace_prefixes.
* drv_xmlproc now supports EntityResolvers that return system IDs.
* Various bugs have been fixed:
677768: 0.8.2 setup.py errors on OS X
684522: ns_parse parsing error for ampersands in description field
696457: public/system ID swapped [in expatreader]
725010: Script text not contained in script element
728810: Forgotten print statement [in wddx]
733890: Memory Leak in expatparser.py
757799: Correct XmlWriter.processingInstruction()
765249: Problems building PyXML 0.8.2 on MacOSX
767130: Invalid charset breaks installation with Python 2.3(beta)
774091: minidom CharacterData string methods fail when offset=length
774095: minidom hasAttributes method only available on Element
774100: minidom removeAttributeNode return value
774104: minidom setNamedItem unlinks replaced attributes
774108: 4DOM setAttributeNode[NS] setting attribute already on node
The Python/XML distribution contains the basic tools required for
processing XML data using the Python programming language, assembled
into one easy-to-install package. The distribution includes parsers
and standard interfaces such as SAX and DOM, along with various other
The package currently contains:
* XML parsers: Pyexpat (Jack Jansen), xmlproc (Lars Marius
Garshol), sgmlop (Fredrik Lundh).
* SAX interface (Lars Marius Garshol)
* minidom DOM implementation (Paul Prescod, others)
* 4DOM and 4XPath from Fourthought (Uche Ogbuji, Mike Olson)
* Schema implementations: TREX (James Tauber)
* Various utility modules and functions (various people)
* Documentation and example programs (various people)
The code is being developed bazaar-style by contributors from the
Python XML Special Interest Group, so please send comments and
questions to <xml-sig(a)python.org>. Bug reports may be filed on
For more information about Python and XML, see:
Martin v. Löwis http://loewis.de/martin
The first beta release of the Python bindings for the FLTK toolkit
is now ready for download from http://pyfltk.sourceforge.net.
FLTK is a lightweight cross-platform (Windows, Linux, Unix, Mac) GUI toolkit,
available from http://www.fltk.org.
Changes since pyFLTK-1.1.a1 include:
- Updated documentation.
- No need to set thiswon=0 anymore.
- Fixed bug that caused stack overflow on handling polymorphisms.
- Added polymorphism for Fl_Overlay_Window.draw_overlay.
- Added polymorphism for Fl_Widget.handle.
- Added polymorphism for Fl_Box.draw().
- Added polymorphism for Fl_Single_Window.draw() and Fl_Double_Window.draw().
- Added method getScrollbar to Fl_Scroll and Fl_Browser_.
- Applied patch 742665 (thanks to Jerome Laheurte).
- Fixed bug (patch) 745651.
- Cleaned up enums for boxtypes.
- Fixed bug in Fl_Adjuster that prevented updating.
- Added contrib/ListSelect.
- Created new cross-platform (Windows and Linux) setup script setup.py.
- Fixed and expanded test files.
Please direct all bug reports and feature requests to the mailing list:
pyfltk-user at lists dot sourceforge dot net.
On behalf of the Python development team and the Python community, I'm
happy to announce the release of Python 2.3 (final).
Nineteen months in the making, Python 2.3 represents a commitment to
stability and improved performance, with a minimum of new language
features. Countless bugs and memory leaks have been fixed, many new
and updated modules have been added, and the new type/class system
introduced in Python 2.2 has been significantly improved. Python 2.3
can be up to 30% faster than Python 2.2.
For more information on Python 2.3, including download links for
various platforms, release notes, and known issues, please see:
Highlights of this new release include:
- A brand new version of IDLE, the Python IDE, from the IDLEfork
project at SourceForge.
- Many new and improved library modules including: sets, heapq,
datetime, textwrap, optparse, logging, bsddb, bz2, tarfile,
ossaudiodev, itertools, platform, csv, timeit, shelve,
DocXMLRPCServer, imaplib, imp, trace, and a new random number
generator based on the highly acclaimed Mersenne Twister algorithm
(with a period of 2**19937-1). Some obsolete modules have been
- New and improved built-ins including:
o enumerate(): an iterator yielding (index, item) pairs
o sum(): a new function to sum a sequence of numbers
o basestring: an abstract base string type for str and unicode
o bool: a proper type with instances True and False
o compile(), eval(), exec: fully support Unicode, and allow input
not ending in a newline
o range(): support for long arguments (magnitude > sys.maxint)
o dict(): new constructor signatures
o filter(): returns Unicode when the input is Unicode
o int() can now return long
o isinstance(), super(): Now support instances whose type() is not
equal to their __class__. super() no longer ignores data
descriptors, except for __class__.
o raw_input(): can now return Unicode objects
o slice(), buffer(): are now types rather than functions
- Many new doctest extensions, allowing them to be run by unittest.
- Extended slices, e.g. "hello"[::-1] returns "olleh".
- Universal newlines mode for reading files (converts \r, \n and \r\n
all into \n).
- Source code encoding declarations. (PEP 263)
- Import from zip files. (PEP 273 and PEP 302)
- FutureWarning issued for "unsigned" operations on ints. (PEP 237)
- Faster list.sort() is now stable.
- Unicode filenames on Windows. (PEP 227)
- Karatsuba long multiplication (running time O(N**1.58) instead of
- pickle, cPickle, and copy support a new pickling protocol for more
efficient pickling of (especially) new-style class instances.
- The socket module now supports optional timeouts on all operations.
- ssl support has been incorporated into the Windows installer.
- Many improvements to Tkinter.
Python 2.3 contains many other improvements, including the adoption of
many Python Enhancement Proposals (PEPs). For details see:
Python 2.3 Release Manager
(and the PythonLabs team: Tim, Fred, Jeremy, and Guido)
Rebuild is a python module that replaces make. It is not a drop-in
replacement, and does not use "makefiles." Instead, it includes a
number of modules which try to be more intelligent about building
Rebuild is reasonably stable, as I have been using it for my own
projects for the past year or so. Obviously it will contain problems
that I have not run into yet. Questions and bug reports can be sent to
paradox(a)bbhc.org Please put [rebuild] somewhere in the subject line if
mailing regarding this project.
The homepage for rebuild contains a download link, some documentation,
and some examples. It can be found at:
+Intelligent parsing heuristics for C/C++ source and headers, as well as
nasm assembler source.
+Automatic gathering of dependencies for supported languages and a more
intelligent build process reduces overall time spent in the building
+Flexible options and a black-box approach to compilers.
+Supports compiling with gcc and nasm. Easily extensible for other
+Supports user-defined actions (Python functions) that can be linked
into dependency chains for autobuilding source files like configuration
ebuild 1.0</A> - Python make replacement. (July 29, 2003) </p>