The 188.8.131.52 release of wxPython is now available for download at
http://wxpython.org/download.php. This release has had some bugs
fixed, some minor patches applied, and also incorporates the Google
Summer of Code 2007 version of XRCed, and adds the Editra source code
Source code is available, as well as binaries for Python 2.3, 2.4 and
2.5, for Windows and Mac, as well some packages for various Linux
distributions. A summary of changes is listed below and also at
NOTE: On Mac OS X 10.5 (Leopard) the Python 2.5 binaries of wxPython
expect to be used with the user-installed version of MacPython, not
the Apple installed version. A fix for this issue is being worked on
for the next release. In the meantime you can either install
MacPython 2.5.1 and adjust your paths so that that Python is used, or
you can stick with Apple's Python and the wxPython 184.108.40.206 that comes
What is wxPython?
wxPython is a GUI toolkit for the Python programming language. It
allows Python programmers to create programs with a robust, highly
functional graphical user interface, simply and easily. It is
implemented as a Python extension module that wraps the GUI components
of the popular wxWidgets cross platform library, which is written in
wxPython is a cross-platform toolkit. This means that the same program
will usually run on multiple platforms without modifications.
Currently supported platforms are 32-bit Microsoft Windows, most Linux
or other Unix-like systems using GTK2, and Mac OS X 10.3+, in most
cases the native widgets are used on each platform to provide a 100%
native look and feel for the application.
Changes in 220.127.116.11
Applied Patch [ 1783958 ] to use the native renderer for drawing the
checkboxes in CheckListCtrlMixin.
Incorporated the new version of XRCed. This is the result of a Google
Summer of Code 2007 project by Roman Rolinsky, and includes a number
of UI enhancements, as well as a mechanism for adding support for new
components without needing changes to XRCed itself. These new
components can be those supported at the C++ layer of XRC, as well as
custom XRC handlers written in Python. See
wxMac: Fixed wx.BusyInfo so it doesn't steal the activated status
from the parent window. (This actually applies to all frames with the
wx.FRAME_TOOL_WINDOW style and no decorations.)
wxMac: Fixed the lack of painting the area between scrollbars on
wxMac: Fixed assertion errors dealing with toolbars on Leopard.
wxMac: Multiline textcontrols now support attributes for margins and
alignement; only a single tab distance can be set though.
Added the wx.Image.AdjustChannels method. This function muliplies all
4 channels (red, green, blue, alpha) with a factor (around
1.0). Useful for gamma correction, colour correction and to add a
certain amount of transparency to a image.
Added Editra to the distribution, to give us a simple yet powerful
programmer's code editor to replace the never finished PyAlaMode
editor and related tools. Many thanks to Cody Precord for the work he
has done on this tool and for allowing us to make it part of wxPython.
Editra has syntax highlighting and other support for over 40
programming languages, excellent OS X integration, is extendable via
plugins, and for those that are on the VI side of the fence there is a
VI emulation mode. For more information see the Editra website at
wxGTK: wx.Frame.ShowFullScreen now preserves the menubar's
wxGTK: wx.GetClientDisplayRect fixed.
Applied patch , which adds a demo of the wx.RendererNative
Applied patch , which uses wx.RenderNative for drawing the
combo button in the PopupControl.
Added GetDirItemData to wx.GenericDirCtrl, which returns a reference
to the data object associated with an item in the control. (Patch
http://wxPython.org Java give you jitters? Relax with wxPython!
We're happy to announce the release 1.2.2 of ViTables, the GUI for the PyTables
and PyTables Pro packages.
The current release focuses on fixing usability issues and bugs. It also gives
support for larger datasets (up to 2**64 rows). You can see the change log for
If you are curious about how it looks like just watch the first introductory
Once more, you are encouraged to buy ViTables, test it, use it, and spread the
And now, the official announcement:
Announcing ViTables 1.2.2
We are proud to present ViTables 1.2.2, the latest release of our viewer for
As it happens with the entire PyTables family, the main strength of ViTables is
its ability to manage really large datasets in a fast and comfortable manner.
For example, with ViTables you can open a table with several thousand million
rows almost instantaneously, and throw queries on it that run in typically less
than a few tenths of second (if PyTables Pro is behind it) with very low memory
requirements. The fact that it runs on top of PyTables ensures its speed and
memory efficiency. Being a multiplatform application, ViTables runs flawlessly
in Unix (and hence, GNU/Linux), Mac OS X and Windows. Finally, for a better
user experience, we have created binary installers for Windows and Mac OS X.
The Unix version is installable using Python distutils.
In this release you will find some bug fixes and usability enhancements,
- capability for navigating datasets whith even 2**64 rows
- enhanced displaying of datasets
- Spanish translation added
At the moment, ViTables has been fully tested only on GNU/Linux, Windows
and MacOS X platforms, but as it is made on top of Python, PyQt and
PyTables, its portability should be really good and it should work just
fine in other Unices.
How to get it
to find directions on how to buy it. You can get it under a personal license or
a site one.
Remember that, when you buy a license, you are contributing to the liberation
process of PyTables Pro and ViTables. See:
Share your experience
We are very interested in your feedback about ViTables. Please send your
opinions, suggestions, bugs, etc. to vitables(a)carabos.com.
Enjoy Data with ViTables, the troll of the PyTables family!
\ / Vicent Mas http://www.carabos.com
/ \ Cárabos Coop. Enjoy Data
The second version of alsaseq, bindings to the ALSA sequencer has been
released. Fixed some bugs in alsaseq.c, added id() function. Added
funtions in alsamidi.py, and a class to read and write ALSA events into
a CSV file.
alsaseq is a Python module that allows to interact with ALSA sequencer
clients. It can create an ALSA client, connect to other clients, send
and receive ALSA events immediately or at a scheduled time using a
sequencer queue. It provides a subset of the ALSA sequencer
capabilities in a simplified model.
It is implemented in C language and licensed under the Gnu GPL license
version 2 or later.
Patricio Páez pp at pp.com.mx
The second version of Underscode, the Python identifier-like encoding,
has been released. The only change from 0.1.0 is that underscores are
encoded as 0x5f and spaces as __, which makes most encoded strings a lot
more readable. I know this breaks backwards compatibility, but at this
stage of the project I think that not many people (if any) are affected
by the change. So toy'n'enjoy!
A Python identifier-like encoding
:Author: `Ivan Vilata i Balaguer <ivan(a)selidor.net>`__
Underscode_ is an encoding which is capable of representing *any*
Unicode string as a valid (and quite similar) Python identifier. The
way Unicode strings are encoded minimises the chances of clashing with
other existing names, while not obscuring the resulting string too much.
Some method decorators are provided which allow arbitrary objects to be
accessed as normal instance attributes, with optional tab-completion
support for interactive usage. The standard Python codec API is also
Underscode-encoded (or *underscoded*) strings can be quickly spotted
because they end with an *odd* number of underscores, and they contain
escape sequences beginning with an underscore where characters not
allowed in identifiers would be found. Some examples of underscoded
* ``_`` encodes the empty string.
* ``foo_`` encodes ``foo``.
* ``class_`` encodes ``class``.
* ``foo__bar_`` encodes ``foo bar``.
* ``foo_x5fbar_`` encodes ``foo_bar``.
* ``_2006_09_18_``, like ``_20060918_``, encodes ``20060918``.
* ``_x2fbin_x2fls_``, encodes ``/bin/ls``.
* ``The__Knights__Who__Say___u201cNi_x21_u201d_`` encodes the properly
quoted ``The Knights Who Say “Ni!”``.
As you see, underscoded strings are quite similar to their decoded
counterparts when these are more or less identifier-like, but complex
strings can still be handled.
Underscode is a very basic tool which may have several uses:
* Avoiding clashes between method names and table field names in ORMs.
* Enabling interactive attribute-like completion for children in
hierarchically arranged structures (DOM trees, filesystems...), with
full Unicode support.
* As an aid in the generation of RPC stubs for identifiers which are not
allowed by Python.
* Computing unique IDs for sections in automatically generated XML or
* Naming page handlers for web server frameworks like CherryPy.
* ... just use your imagination!
The Underscode package is released under the GNU Lesser General Public
License (LGPL) version 3 or later (see http://www.gnu.org/licenses/).
Underscoded strings as attributes
Underscode provides a module with decorators that allow you to use plain
attribute access as a flexible way of accessing all kinds of "child
objects" without polluting the normal attribute namespace, and with
optional interactive completion if you wish so. For instance, you can
make the (string) keys of a dictionary accessible as attributes::
from underscode.decorators import proxy_method
def __getattr__(self, name):
return super(AttributedDict, self).__getattr__(name)
def __setattr__(self, name, value):
super(AttributedDict, self).__setattr__(name, value)
def __delattr__(self, name):
Then, access to an attribute which looks like an underscoded string gets
the name decoded and used as an argument to ``__getitem__()``:
>>> d = AttributedDict()
>>> d.foo = 1
>>> d.foo_ = 42
>>> d.foo_, d['foo'], d.foo
(42, 42, 1)
>>> del d.foo_
Adding tab-completion on underscoded attributes to this simple example
is as easy as applying some ready-to-use decorators on the methods used
as arguments to ``proxy_method``. See the documentation of the
``underscode.decorators`` module for more information and examples.
Python codec API support
Since the Underscode package is compliant with the standard Python codec
API, you can use Underscode to encode and decode strings with the usual
``unicode.encode()`` and ``str.decode()`` calls at any time just by
importing the ``underscode.codec`` subpackage (it is not automatically
imported by the main ``underscode`` package):
>>> import underscode.codec
>>> print u'this is \u201ca test\u201d'
this is “a test”
>>> u'this is \u201ca test\u201d'.encode('underscode')
u'this is \u201ca test\u201d'
You can download the source code distribution of Underscode from the
Python Package Index at http://pypi.python.org/. It uses the standard
``setup.py`` method for installation, runs on any platform and has no
additional dependencies but Python version 2.4 or greater.
You may also be interested in following the development of Underscode;
you can get a copy of its development `Bazaar-NG`_ branch with::
$ bzr get https://bzr.selidor.net/selidor/underscode/trunk underscode
There is a discussion group for Underscode at Google Groups:
It would be great to discuss your opinions and feelings on Underscode in
the group, to know how you used it in your project, and to help solving
yours and others problems there! If you come across a bug or you have
some enhancement proposal, you may use the Trac_ instance available at
.. _Underscode: http://underscode.selidor.net/
.. _Bazaar-NG: http://bazaar-ng.org/
.. _Trac: http://trac.edgewall.org/
Ivan Vilata i Balaguer @ Welcome to the European Banana Republic! @
http://www.selidor.net/ @ http://www.nosoftwarepatents.com/ @
We're happy to announce version 3.0.2 of Wing IDE, an advanced development
environment for the Python programming language. It is available from:
This release focuses on fixing usability issues found in Wing 3.0.1, including
missed Search in Project matches, failure to offer auto-completion for code
in extension modules, and about 25 other bugs.
See the change log for details:
It is a free upgrade for all Wing 3.x users.
*About Wing IDE*
Wing IDE is an integrated development environment for the Python programming
language. It provides powerful debugging, editing, code intelligence,
testing, and search capabilities that reduce development and debugging
time, cut down on coding errors, and make it easier to understand
and navigate Python code.
New features added in Wing 3.0 include:
* Multi-threaded debugger
* Debug value tooltips in editor, debug probe, and interactive shell
* Autocompletion and call tips in debug probe and interactive shell
* Automatically updating project directories
* Testing tool, currently supporting unittest derived tests (*)
* OS Commands tool for executing and interacting with external commands (*)
* Rewritten indentation analysis and conversion (*)
* Introduction of Wing IDE 101, a free edition for beginning programmers
* Available as a .deb package for Debian and Ubuntu
* Support for Stackless Python
* Support for 64 bit Python on Windows and Linux
(*)'d items are available in Wing IDE Professional only.
System requirements are Windows 2000 or later, OS X 10.3.9 or later for PPC or
Intel (requires X11 Server), or a recent Linux system (either 32 or 64 bit).
*Purchasing & Upgrading*
Wing IDE Professional & Wing IDE Personal are commercial software and require
a license to run. To upgrade a 2.x license or purchase a new 3.x license:
Any 2.x license sold after May 2nd 2006 is free to upgrade; others cost
1/2 the normal price to upgrade.
The Wingware Team
Wingware | Python IDE
Advancing Software Development
We at Carabos are happy to announce the simultaneous release of the new
2.0.2 versions of both PyTables and PyTables Pro. They are mainly
bugfix releases, and users of previous versions are encouraged to
And now the official announce:
Announcing PyTables and PyTables Pro 2.0.2
PyTables is a library for managing hierarchical datasets and designed to
efficiently cope with extremely large amounts of data with support for
full 64-bit file addressing. PyTables runs on top of the HDF5 library
and NumPy package for achieving maximum throughput and convenient use.
PyTables Pro adds OPSI, a powerful indexing engine for executing
very fast queries in large tables.
In this version, some bugs have been fixed, being the most important a
problem when moving or renaming a group. Some small improvements have
been added as well. Besides, a *critical* bug has been fixed in the Pro
version (the problem arose when doing repeated queries using the same
index). Because of this, an upgrade is strongly recommended.
In case you want to know more in detail what has changed in this
version, have a look at ``RELEASE_NOTES.txt``. Find the HTML version
for this document at:
You can download a source package of the version 2.0.2 with
generated PDF and HTML docs and binaries for Windows from
For an on-line version of the manual, visit:
Migration Notes for PyTables 1.x users
If you are a user of PyTables 1.x, probably it is worth for you to look
at ``MIGRATING_TO_2.x.txt`` file where you will find directions on how
to migrate your existing PyTables 1.x apps to the 2.x versions. You can
find an HTML version of this document at
Go to the PyTables web site for more details:
About the HDF5 library:
To know more about the company behind the development of PyTables, see:
Thanks to many users who provided feature improvements, patches, bug
reports, support and suggestions. See the ``THANKS`` file in the
distribution package for a (incomplete) list of contributors. Many
thanks also to SourceForge who have helped to make and distribute this
package! And last, but not least thanks a lot to the HDF5 and NumPy
(and numarray!) makers. Without them, PyTables simply would not exist.
Share your experience
Let us know of any bugs, suggestions, gripes, kudos, etc. you may
-- The PyTables Team
Ivan Vilata i Balaguer >qo< http://www.carabos.com/
Cárabos Coop. V. V V Enjoy Data