What is it?
PuDB is a full-screen, console-based visual debugger for Python.
Its goal is to provide all the niceties of modern GUI-based debuggers in a
more lightweight and keyboard-friendly package. PuDB allows you to debug code
right where you write and test it--in a terminal. If you've worked with the
excellent (but nowadays ancient) DOS-based Turbo Pascal or C tools, PuDB's UI
might look familiar.
Where can I get it?
You may find the most recent version (0.92.1 as of this writing) here:
(like screencasts? there is one!)
* Syntax-highlighted source, the stack, breakpoints and variables are all
visible at once and continuously updated. This helps you be more aware of
what's going on in your program. Variable displays can be expanded, collapsed
and have various customization options.
* Simple, keyboard-based navigation using single keystrokes makes debugging
quick and easy. PuDB understands cursor-keys and Vi shortcuts for navigation.
Other keys are inspired by the corresponding pdb coomands.
* Use search to find relevant source code, or use "m" to invoke the module
browser that shows loaded modules, lets you load new ones and reload existing
* Breakpoints can be set just by pointing at a source line and hitting "b" and
then edited visually in the breakpoints window. Or hit "t" to run to the line
under the cursor.
* Drop to a Python shell in the current environment by pressing "!".
* PuDB places special emphasis on exception handling. A post-mortem mode makes
it easy to retrace a crashing program's last steps.
License and Dependencies
PuDB is distributed under the MIT license. It is based on Ian Ward's Urwid
library and can optionally make use of Georg Brandl's Pygments for syntax
dbfconverter.py 0.02 has been released.
What is dbfconverter.py?
dbfconverter.py is platform independent python script. It converts
database with dbf files or single dbf file into sql code, wich you can
load into any sql database.
dbfconverter.py supports encoding changing, changing sql file format
(now it has 3 formats: mssql, mysql, postgresql). If you need, you can
create your own sql file format.
dbfconverter.py need python to be installed.
it is available from https://sourceforge.net/projects/dbfconverter
Version 0.02 changes:
* Removed db api sinchronization
* Added some extended sql formats. Now user can change, what format will
be the sql file.
* Now you can create your own format of sql file (see formats.txt in
A new unstable development release of the Python bindings
for GTK+ has been released.
The new release is available from ftp.gnome.org and its mirrors
as soon as its synced correctly:
Thanks to Paul Pogonyshev who has done all the hard job preparing this release.
GTK+ is a toolkit for developing graphical applications that run on
systems such as Linux, Windows and MacOS X. It provides a comprehensive set
of GUI widgets, can display Unicode bidi text. It links into the Gnome
Accessibility Framework through the ATK library.
PyGTK provides a convenient wrapper for the GTK+ library for use in
Python programs, and takes care of many of the boring details such as
managing memory and type casting. When combined with PyORBit and
gnome-python, it can be used to write full featured Gnome applications.
Like the GTK+ library itself PyGTK is licensed under the GNU LGPL, so is
suitable for use in both free software and proprietary applications. It
is already in use in many applications ranging from small single purpose
scripts up to large full features applications.
What's new since 2.15.1?
- Rename gtk.Statusbar.remove() to gtk.Statusbar.remove_message (Paul)
- Allow pango.Context creation (Paul, #550855)
- Make gtk.gdk.Pixbuf.add_alpha accept integers, retaining backward
compatibility accepting also chars (Paul, #586094)
- Protect window obj from GC in gtk.window_get_toplevels (Gustavo, #574259)
- Plug huge number of memory leaks in Pango wrappers (Paul)
- Add gtk.gdk.WINDOWING constant (Paul, #555112)
- Wrap gdk_pixbuf_apply_embedded_orientation (Chris Wilson)
- Modernize constructors of seven more types (Paul)
- Don't free a string we don't own (Paul, #585458)
- Some docs tweaking (Gian)
Bug reports, as always, should go to Bugzilla; check out
http://pygtk.org/developer.html and http://pygtk.org/feedback.html for
links to posting and querying bug reports for PyGTK.
Gian Mario Tagliaretti
GNOME Foundation member
what is it
A simple script calling the W3C HTML Validator in batch mode. Adapted
from Perl version.
changes since the last full release
- BUGFIX: checks for Valid or Invalid adapted to changes of W3C HTML
Validator HTML (the check is really naive!)
- BUGFIX: fixed saving of reports
- improvement of output
- added valid and invalid example HTML
download validate-1.7 - 090620 from http://cthedot.de/batchvalidator/
tested on Python 2.6.2 only but should work on other versions as it is
Included is a (modified) httplib_multipart.py script (originally from
http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/146306) to be
able to POST fields and files to an HTTP host as multipart/form-data.
any comment appreciated...
The discover module is a backport of the automatic test discovery from
python-trunk (what will become Python 2.7 & 3.2) to work with Python
2.4 or more recent (including Python 3.0).
Test discovery allows you to run all the unittest based tests (or just
a subset of them) in your project without you having to write your own
test collection or running machinery. Once installed, test discovery
can be invoked with ``python -m discover``. I've tested the discover
module with Python 2.4 and 3.0.
The discover module also implements the ``load_tests`` protocol which
allows you to customize test loading from modules and packages. Test
discovery and ``load_tests`` are implemented in the
``DiscoveringTestLoader`` which can be used from your own test
* discover module on PyPI http://pypi.python.org/pypi/discover
discover can be installed with pip or easy_install. After installing
current directory to the top level directory of your project and run::
python -m discover
This will discover all tests (with certain restrictions) from the
directory. The discover module has several options to control its
usage options are displayed with ``python -m discover -h``)::
Usage: discover.py [options]
-v, --verbose Verbose output
-s directory Directory to start discovery ('.' default)
-p pattern Pattern to match test files ('test*.py'
-t directory Top level directory of project (default to
For test discovery all test modules must be importable from the
level directory of the project.
For example to use a different pattern for matching test modules run::
python -m discover -p '*test.py'
(Remember to put quotes around the test pattern or shells like bash
shell expansion rather than passing the pattern through to discover.)
Test discovery is implemented in
well as using discover as a command line script you can import
``DiscoveringTestLoader``, which is a subclass of
use it in your test framework.
This method finds and returns all test modules from the specified
directory, recursing into subdirectories to find them. Only test files
match *pattern* will be loaded. (Using shell style pattern matching.)
All test modules must be importable from the top level of the project.
the start directory is not the top level directory then the top level
directory must be specified separately.
The ``load_tests`` protocol allows test modules and packages to
they are loaded. This is implemented in
``discover.DiscoveringTestLoader.loadTestsFromModule``. If a test
a ``load_tests`` function then tests are loaded from the module by
``load_tests`` with three arguments: `loader`, `standard_tests`,
If a test package name (directory with `__init__.py`) matches the
pattern then the package will be checked for a ``load_tests``
function. If this exists then it will be called with *loader*,
If ``load_tests`` exists then discovery does *not* recurse into the
``load_tests`` is responsible for loading all tests in the package.
The pattern is deliberately not stored as a loader attribute so that
packages can continue discovery themselves. *top_level_dir* is stored
``load_tests`` does not need to pass this argument in to
discover.py is maintained in a google code project (where bugs and
requests should be posted): http://code.google.com/p/unittest-ext/
The latest development version of discover.py can be found at:
I am glad to announce the version 3.0 of the Python web framework
Karrigell has been around since 2002 and after numerous versions,
until 2.4.0 last year, it needed a complete rewriting. Some modules
had been written long ago, using out-of-date patterns ; the global
architecture needed cleaning up, to replace an accumulation of modules
added one release after the other ; most important, the previous
versions were unable to run reliably in a multithreaded environment,
which was a serious limitation for professional web developement
The decision was taken more than one year ago to rewrite almost
everything, while stricking to the same guidelines of simplicity for
the programmer and administrator :
- no configuration needed to get started : just unzip the package and
run "python Karrigell.py" to start the built-in web server
- URLs match scripts in the file system
- no imposed ORM, templating engine : all you need to know is Python
and HTML, plus a few built-in names for access to environment, form
- the most usual tasks in web programing (sessions, user management,
redirection, etc) are accessible though built-in functions and
exceptions with a very intuitive syntax : Session() returns the
session object, Login() checks if a user is logged in and redirects to
a login page otherwise, "raise HTTP_REDIRECTION, url" redirects to the
specified url, etc
- clear debugging info
- a choice between a variety of coding styles : while the recommended
way is to use "Karrigell services" (Python scripts with the whole
logic of a web application in one script), other options are possible,
including a PHP-like format with Python code inside HTML markup
The most efficient and flexible way to run Karrigell is to use the
built-in multithreaded or multi-process web server ; for Windows user,
an exe file is available and allows running the framework from a USB
key on any machine, even if no Python interpreter is installed. The
built-in server has been tested by hundreds of users on all possible
configurations, it is robust, reliable and fast enough for 99% of web
Of course, it can also be integrated to other web servers, with a
special effort on Apache integration (CGI mode, mod_python) ; you can
also configure your server to serve static files and proxy the
requests to the built-in server
Karrigell does not impose anything on database choice : since scripts
are pure Python, any db engine with a Python API can be used, either
directly or through an ORM like SQLAlchemy. All template engines are
Though it's an almost complete rewriting, the syntax remains almost
100% compatible with previous versions. Migrating from 2.x to 3.0
should be easy (much easier than from Python 2.x to 3.0). The two main
changes, introduced for multithread support, are relative to :
- relative paths in the file system : in previous versions, they were
converted to absolute path relative to the script's path ; in version
3.0, they must be converted by a built-in function REL()
- import of user-defined modules : instead of the standard Python
statement "import foo", the syntax is now foo = Import("foo")
A tool to detect potential migration issues in provided in the package
I thank all the people on the Karrigell group who helped by their
advices, suggestions, support and code
It's my pleasure to announce the release of rst2pdf version 0.11, available at
Rst2pdf is a tool to generate PDF files directly from restructured text
sources via reportlab.
This version includes many bugfixes and some new features compared to the
previous 0.10.1 version, including but not limited to embedding PDF images,
much improved image sizing, nicer list layouts, better styling, page
backgrounds, and more than 15 bugs fixed. A full changelog is included at the
bottom of this message.
Rst2pdf aims to support the full restructured text feature set, and is very
close to that goal, while also including some of the more experimental
features, like a source code directive with syntax highlighting and math
notation support with LaTeX-like syntax.
It supports embedding arbitrary fonts, both True Type and PS Type 1, both
raster and vector images (including SVG), page transition effects, multiple,
flexible page layouts, cascading styles, and much, much more.
You can find more information about rst2pdf in its home page (
http://rst2pdf.googlecode.com), and ask anything you want in the rst2pdf-
discuss mailing list (http://groups.google.com/group/rst2pdf-discuss)
Here are the changes in this version compared to 0.10.1:
* Degrade more gracefully when one or more wordaxe hyphenators are
broken (currently DWC is the broken one)
* Fixed issue 132: in some cases, with user-defined fontAlias, bold and
italic would get confused (getting italic instead of bold in inline
markup, for instance).
* New stylesheet no-compact-lists to make lists... less compact
* SVG images now handle % as a width unit correctly.
* Implemented issue 127: support images in PDF format. Right now they
are rasterized, so it's not ideal. Perhaps something better will come up
* Fixed issue 129: make it work around a prblem with KeepTogether in RL 2.1
it probably makes the output look worse in some cases when using that.
RL 2.1 is not really supported, so added a warning.
* Fixed issue 130: use os.pathsep instead of ":" since ":" in windows is used
in disk names (and we still pay for DOS idiocy, in 2009)
* Fixed issue 128: headings level 3+ all looked the same
* Ugly bugfix for Issue 126: crashes when using images in header + TOC
* New tstyles section in the stylesheet provides more configurable list
and more powerful table styling.
* Better syntax highlighting (supports bold/italic)
* Workaround for issue 103 so you can use borderPadding as a list (but it will
if you are using wordaxe <= 0.3.2)
* Added fieldvalue style for field lists
* Added optionlist tstyle, for option lists
* Added collection of utility stylesheets and documented it
* Improved command line parsing and stylesheet loading (guess
extension like latest rst2latex does)
* Fixed Issue 67: completely new list layouting code
* Fixed Issue 116: crashes caused by huge images
* Better support for %width in images, n2ow it's % of the container frame's
width, not of the text area.
* Fixed bug in SVG scaling
* Better handling of missing images
* Added missing styles abstract, contents, dedication to the default
* Tables style support spaceBefore and spaceAfter
* New topic-title style for topic titles (obvious ;-)
* Vertical alignment for inline images (:align: parameter)
* Issue 118: Support for :scale: in images and handle resizing of inline
* Issue 119: Fix placement of headers and footers
* New background property for page templates (nice for presentations, for
* Default to px for image width specifications instead of pt
* Support all required measurement units ("em" "ex" "px" "in" "cm"
"mm" "pt" "pc" "%" "")
* New automated scripts to check test cases for "visual differences"
* Respect images DPI property a bit like rst2latex does.
* Issue 110: New --inline-footnotes option
* Tested with reportlab from SVN trunk
* Support for Dinu Gherman's svglib. If both svglib and uniconvertor are
svglib is preferred (for SVG, of course). Patch originally by rute.
* Issue 109: Separate styles for each kind of admonition
* For Issue 109: missing styles are not a fatal error
* Issue 117: TOCs with more than 6 levels now supported (raised limit to 9,
is silly deep)
("\''/").__..-''"`-. . Roberto Alsina
`9_ 9 ) `-. ( ).`-._.`) KDE Developer (MFCH)
(_Y_.)' ._ ) `._`. " -.-' http://lateral.netmanagers.com.ar
_..`-'_..-_/ /-'_.' The 6,855th most popular site of Slovenia
(l)-'' ((i).' ((!.' according to alexa.com (27/5/2007)
"Our opponent is an alien starship packed with atomic bombs, I said.
We have a protractor. Okay, I’ll go home and see if I can scrounge up a
ruler and a piece of string." — Neal Stephenson
I'm pleased to finally get around to announcing the release of ErrorHandler.
This is a handler for the python standard logging framework that can
be used to tell whether messages have been logged at or above a
This can be useful when wanting to ensure that no errors have been
logged before committing data back to a database.
Here's an example:
First, you set up the error handler:
>>> from logging import getLogger
>>> from errorhandler import ErrorHandler
>>> logger = getLogger()
>>> e = ErrorHandler()
The handler started off being un-fired:
Then you do whatever else you need to do, which may involve logging:
>>> logger.info('some information')
However, if any logging occurs at an error level or above:
>>> logger.error('an error')
Then the error handler becomes fired:
You use this as a condition to only do certain actions when no errors
have been logged:
>>> if e.fired:
... print "Not updating files as errors have occurred"
Not updating files as errors have occurred
If your code does work in batches, you may wish to reset the error
handler at the start of each batch:
For more information, please see:
Simplistix - Content Management, Zope & Python Consulting
I'm pleased to announce a new release of Mailinglogger.
Mailinglogger provides two handlers for the standard python
logging framework that enable log entries to be emailed either as the
entries are logged or as a summary at the end of the running process.
The handlers have the following features:
- customisable and dynamic subject lines for emails sent
- emails sent with an X-Mailer header for easy filtering
- flood protection to ensure the number of emails sent is not excessive
- support for SMTP servers that require authentication
- fully documented and tested
In addition, extra support is provided for configuring the handlers when
using ZConfig, Zope 2 or Zope 3.
The latest releases of ZConfig, in particular, provide a great way to
configure the python logging framework without having to resort to the
appalling .ini-based configuration stuff:
>>> from ZConfig import configureLoggers
... level INFO
... PATH STDOUT
... format %(levelname)s %(name)s %(message)s
This release of MailingLogger adds the ability to use %(levelname)s in
subject-line formatting for SummarisingLoggers to include the highest
For more information, please see:
Simplistix - Content Management, Zope & Python Consulting