I am pleased to announce version 2.27.91 of the Python bindings for GObject. We found some major blockers from the last release so this is a second pre-release for the upcoming 2.28.0 stable release. There is currently one more crasher bug on the blocker list. Once that is fixed and if there are no more blockers we will be releasing the stable version.
Fixes in this release include the following:
* ignore ginterfaces when doing method resolutions to avoid diamond inheritance issues
* Fix union inheritance issues for Gdk.Event (e.g. Gdk.EventButton structure can be passed to interfaces which expect a Gdk.Event)
* Override all Gdk.Event union members to export Gdk.Event methods
* Leak instead of crashing if marshalling a C array and an error occurs - future releases will fix the leak
* When setting rows in a TreeModel you can now pass None to indicate you wish to ignore a column
* Fix setting types not represented in Python such as GObject.TYPE_UINT, when setting a TreeModel column
* Flag and enum behaviour fixes
* Typelibs now loaded at import time instead of lazy loading to fix name resolution issues from factories which return objects where the typelib is not yet loaded (e.g. GStreamer plugins) - this requires that application authors call the gi.require_version API BEFORE importing a module from gi.repository if they wish to specify a typelib version (e.g. gi.require_verison('Gtk', '3.0'))
* don't load the gi module when using the static bindings
* Gtk.Menu.popup fixed
* Gtk.Cursor now API equivalent to PyGtk
* Signal callbacks now convert foreign types (e.g. you get a PyCairo compatible context object in a 'draw' signal callback)
* Gdk.Rectangle aliases cairo.RectangleInt correctly
* fix the demos in gtk-demo.py
* For a complete list of changes please read the NEWS file
The new release is available from ftp.gnome.org and its mirrors:
GObject is a object system library used by GTK+ and GStreamer.
PyGObject provides a convenient wrapper for the GObject 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 PyGTK, PyORBit and gnome-python, it can be used to write full featured GNOME 2.0 applications.
Like the GObject library itself PyGObject 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 featured applications.
PyGObject requires glib >= 2.22.4 and Python >= 2.5.1 to build.
GIO bindings require glib >= 2.22.4.
The Introspection module is the next generation Python GObject library bindings. Instead of statically wrapping every GObject based library we can now dynamically accesses any of those libraries using GObject Introspection. It replaces the need for separate modules such as PyGTK, GIO and python-gnome to build a full GNOME 3.0 application. Once new functionality is added to gobject library it is instantly available as a Python API without the need for an intermediate Python module.
Introspection/Python 2 bindings requires gobject-introspection >= 0.9.5 and pycairo >=1.0.2 or py2cairo >=1.8.10
Introspection/Python 3 bindings requires gobject-introspection >= 0.9.5, pycairo >=1.8.10 and Python >= 3.1
John (J5) Palmieri
Red Hat, Inc.
I'm pleased to announce the release of SciPy 0.9.0.
SciPy is a package of tools for science and engineering for Python. It
includes modules for statistics, optimization, integration, linear
algebra, Fourier transforms, signal and image processing, ODE solvers,
and more. This release comes seven months after the 0.8.0 release and
contains several new features, numerous bug-fixes, improved test
coverage, and better documentation. This is the first release that
supports Python 3 (with the exception of the scipy.weave module).
Sources, binaries, documentation and release notes can be found at
Thank you to everybody who contributed to this release.
The SciPy developers
SciPy 0.9.0 Release Notes
SciPy 0.9.0 is the culmination of 6 months of hard work. It contains
many new features, numerous bug-fixes, improved test coverage and
better documentation. There have been a number of deprecations and
API changes in this release, which are documented below. All users
are encouraged to upgrade to this release, as there are a large number
of bug-fixes and optimizations. Moreover, our development attention
will now shift to bug-fix releases on the 0.9.x branch, and on adding
new features on the development trunk.
This release requires Python 2.4 - 2.7 or 3.1 - and NumPy 1.5 or greater.
Please note that SciPy is still considered to have "Beta" status, as
we work toward a SciPy 1.0.0 release. The 1.0.0 release will mark a
major milestone in the development of SciPy, after which changing the
package structure or API will be much more difficult. Whilst these
pre-1.0 releases are considered to have "Beta" status, we are
committed to making them as bug-free as possible.
However, until the 1.0 release, we are aggressively reviewing and
refining the functionality, organization, and interface. This is being
done in an effort to make the package as coherent, intuitive, and
useful as possible. To achieve this, we need help from the community
of users. Specifically, we need feedback regarding all aspects of the
project - everything - from which algorithms we implement, to details
about our function's call signatures.
Scipy 0.9.0 is the first SciPy release to support Python 3. The only module
that is not yet ported is ``scipy.weave``.
Scipy source code location to be changed
Soon after this release, Scipy will stop using SVN as the version control
system, and move to Git. The development source code for Scipy can from then on
be found at
Delaunay tesselations (``scipy.spatial``)
Scipy now includes routines for computing Delaunay tesselations in N
dimensions, powered by the Qhull_ computational geometry library. Such
calculations can now make use of the new ``scipy.spatial.Delaunay``
.. _Qhull: http://www.qhull.org/
N-dimensional interpolation (``scipy.interpolate``)
Support for scattered data interpolation is now significantly
improved. This version includes a ``scipy.interpolate.griddata``
function that can perform linear and nearest-neighbour interpolation
for N-dimensional scattered data, in addition to cubic spline
(C1-smooth) interpolation in 2D and 1D. An object-oriented interface
to each interpolator type is also available.
Nonlinear equation solvers (``scipy.optimize``)
Scipy includes new routines for large-scale nonlinear equation solving
in ``scipy.optimize``. The following methods are implemented:
* Newton-Krylov (``scipy.optimize.newton_krylov``)
* (Generalized) secant methods:
- Limited-memory Broyden methods (``scipy.optimize.broyden1``,
- Anderson method (``scipy.optimize.anderson``)
* Simple iterations (``scipy.optimize.diagbroyden``,
The ``scipy.optimize.nonlin`` module was completely rewritten, and
some of the functions were deprecated (see above).
New linear algebra routines (``scipy.linalg``)
Scipy now contains routines for effectively solving triangular
equation systems (``scipy.linalg.solve_triangular``).
Improved FIR filter design functions (``scipy.signal``)
The function ``scipy.signal.firwin`` was enhanced to allow the
design of highpass, bandpass, bandstop and multi-band FIR filters.
The function ``scipy.signal.firwin2`` was added. This function
uses the window method to create a linear phase FIR filter with
an arbitrary frequency response.
The functions ``scipy.signal.kaiser_atten`` and ``scipy.signal.kaiser_beta``
Improved statistical tests (``scipy.stats``)
A new function ``scipy.stats.fisher_exact`` was added, that provides Fisher's
exact test for 2x2 contingency tables.
The function ``scipy.stats.kendalltau`` was rewritten to make it much faster
(O(n log(n)) vs O(n^2)).
Obsolete nonlinear solvers (in ``scipy.optimize``)
The following nonlinear solvers from ``scipy.optimize`` are
- ``broyden_modified`` (bad performance)
- ``broyden1_modified`` (bad performance)
- ``broyden_generalized`` (equivalent to ``anderson``)
- ``anderson2`` (equivalent to ``anderson``)
- ``broyden3`` (obsoleted by new limited-memory broyden methods)
- ``vackar`` (renamed to ``diagbroyden``)
The deprecated modules ``helpmod``, ``pexec`` and ``ppimport`` were removed
The ``output_type`` keyword in many ``scipy.ndimage`` interpolation functions
has been removed.
The ``econ`` keyword in ``scipy.linalg.qr`` has been removed. The same
functionality is still available by specifying ``mode='economic'``.
Old correlate/convolve behavior (in ``scipy.signal``)
The old behavior for ``scipy.signal.convolve``, ``scipy.signal.convolve2d``,
``scipy.signal.correlate`` and ``scipy.signal.correlate2d`` was deprecated in
0.8.0 and has now been removed. Convolve and correlate used to swap their
arguments if the second argument has dimensions larger than the first one, and
the mode was relative to the input with the largest dimension. The current
behavior is to never swap the inputs, which is what most people expect, and is
how correlation is usually defined.
Many functions in ``scipy.stats`` that are either available from numpy or have
been superseded, and have been deprecated since version 0.7, have been removed:
`std`, `var`, `mean`, `median`, `cov`, `corrcoef`, `z`, `zs`, `stderr`,
`samplestd`, `samplevar`, `pdfapprox`, `pdf_moments` and `erfc`. These changes
are mirrored in ``scipy.stats.mstats``.
Several methods of the sparse matrix classes in ``scipy.sparse`` which had
been deprecated since version 0.7 were removed: `save`, `rowcol`, `getdata`,
`listprint`, `ensure_sorted_indices`, `matvec`, `matmat` and `rmatvec`.
The functions ``spkron``, ``speye``, ``spidentity``, ``lil_eye`` and
``lil_diags`` were removed from ``scipy.sparse``. The first three functions
are still available as ``scipy.sparse.kron``, ``scipy.sparse.eye`` and
The `dims` and `nzmax` keywords were removed from the sparse matrix
constructor. The `colind` and `rowind` attributes were removed from CSR and CSC
A duplicated interface to the ARPACK library was removed.
ARPACK interface changes
The interface to the ARPACK eigenvalue routines in
``scipy.sparse.linalg`` was changed for more robustness.
The eigenvalue and SVD routines now raise ``ArpackNoConvergence`` if
the eigenvalue iteration fails to converge. If partially converged results
are desired, they can be accessed as follows::
import numpy as np
from scipy.sparse.linalg import eigs, ArpackNoConvergence
m = np.random.randn(30, 30)
w, v = eigs(m, 6)
except ArpackNoConvergence, err:
partially_converged_w = err.eigenvalues
partially_converged_v = err.eigenvectors
Several bugs were also fixed.
The routines were moreover renamed as follows:
- eigen --> eigs
- eigen_symmetric --> eigsh
- svd --> svds
I'm pleased to announce the release of circuits-1.5
This release brings to circuits.web a new dispatcher: WebSockets
This allows you to build a web application and process WebSocket
connections in the same process/thread. (See the test)
This release also includes a number of minor bug fixes
and greater test coverage.
For more information see the PyPi page:
-- James Mills
-- "Problems are solved by method"
I'm happy to announce the release of the planar 0.3 2D geometry
library for Python. The project, although still under development,
already has quite a few useful features. The focus of the library is
to provide a clean, simple, documented 2D geometry api, with high
performance implementations in both Python and C, available under a
You can check out the docs and grab it from pypi here:
Need to get up-to-speed with Python as quickly and as in-depth as
possible? Already coding Python but still have areas of uncertainty
you need to fill? Then come join me, Wesley Chun, author of
Prentice-Hall's bestseller "Core Python" for a comprehensive
intro/intermediate course coming up this May in Northern California,
then enjoy the Memorial Day weekend afterwards in San Francisco, the
beautiful city by the bay.
Please pass on this note to whomever you think may be interested. I
look forward to meeting you and your colleagues! feel free to pass
around the PDF flyer linked down below.
(Comprehensive) Introduction to Python
Tue-Thu, 2010 May 24-26, 9am-5pm
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
(COMPREHENSIVE) INTRO+INTERMEDIATE PYTHON
Although this course may appear to those new to Python, it is also
perfect for those who have tinkered with it and want to "fill in the
gaps" and/or want to get more in-depth formal training. It combines
the best of both an introduction to the language as well as a "Python
Internals" training course.
We will immerse you in the world of Python in only a few days, showing
you more than just its syntax (which you don't really need a book to
learn, right?). Knowing more about how Python works under the covers,
including the relationship between data objects and memory management,
will make you a much more effective Python programmer coming out of
the gate. 3 hands-on labs each day will help hammer the concepts home.
Come find out why Google, Yahoo!, Disney, ILM/LucasFilm, VMware,
NASA, Ubuntu, YouTube, and Red Hat all use Python. Users supporting or
jumping to Plone, Zope, TurboGears, Pylons, Django, Google App Engine,
Jython, IronPython, and Mailman will also benefit!
PREVIEW 1: you will find (and can download) a video clip of a
class session recorded live to get an idea of my lecture style and
the interactive classroom environment (as well as sign-up) at:
PREVIEW 2: Partnering with O'Reilly and Pearson, Safari Books
Online has asked me to deliver a 1-hour webcast a couple of years ago
called "What is Python?". This was an online seminar based on a
session that I've delivered at numerous conferences in the past. It
will give you an idea of lecture style as well as an overview of the
covered in the course.
download (reg req'd):
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
WHERE: near the San Francisco Airport (SFO/San Bruno), CA, USA
LOCALS: easy freeway (101/280/380) with lots of parking plus public
transit (BART and CalTrain) access via the San Bruno stations, easily
accessible from all parts of the Bay Area
VISITORS: free shuttle to/from the airport, free high-speed internet,
free breakfast and regular evening receptions; fully-equipped suites
See website for costs, venue info, and registration. There is a
significant discounts available for full-time students, secondary
teachers, and others.
Hope to see you there!
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
"Core Python Programming", Prentice Hall, (c)2007,2001
"Python Fundamentals", Prentice Hall, (c)2009
wesley.chun : wescpy-gmail.com : @wescpy
python training and technical consulting
cyberweb.consulting : silicon valley, ca
There is a new release of mock: mock 0.7.0 rc1
This is intended to be the last release of mock before 0.7.0 final and
the only changes anticipated are documentation changes which I've
finally started work on.
mock is a Python library for simple mocking and patching (replacing
objects with mocks during test runs). The "headline features" in 0.7.0
are Python 3 support and the ability to mock magic methods. You can
now mock objects that behave like containers or are used as context
managers. mock is designed for use with unittest, based on the "action
-> assertion" pattern rather than "record -> replay". People are
happily using mock with Python test frameworks like nose and py.test.
0.7.0 is a major new release with a bunch of other new features and
bugfixes as well.
https://code.google.com/p/mock/ (repo and issue tracker)
Changes since beta 4:
* Tested with jython, pypy and Python 3.2 and 3.1
* Decorated functions / methods have their docstring and __module__
preserved on Python 2.4
* BUGFIX: mock.patch now works correctly with certain types of objects
that proxy attribute access, like the django settings object
* BUGFIX: reset_mock caused infinite recursion when a mock is set as
its own return value
ActiveState is pleased to announce ActivePython 188.8.131.52, a complete,
ready-to-install binary distribution of Python 3.2.
What's New in ActivePython-184.108.40.206
New Features & Upgrades
- First ActivePython release based on Python 3.2 core
- PyPM (beta) for Python 3.2
- Distribute (setuptools)
- [Windows] Upgrade to PyWin32 CVS snapshot as of 2011-01-16
- [MacOSX] ``readline`` support via Apple's ``libedit`` library
- OpenSSL 1.0.0d
- [Windows] Fix a ``tarfile`` performance issue (`issue11224
What's new in Python 3.2
* Stable ABI: Extension modules built for 3.2 can continue to work with
3.3, 3.4 and so on.
* argparse: argparse, an improved alternative to optparse included in
Python 2.7, is now available in 3.2 as well.
* concurrent.futures: Inspired by java.util.concurrent.package, this
module abstracts threads/processes/RPC-calls by way of abstract
executors with support for status checks, timeouts, cancellations,
callbacks, access to results or exceptions. futures makes it easier to
switch from one concurrent implementation to another, eg: from thread to
* PYC repository directories: Ever faced with ".pyc conflicts" between
multiple Python versions? Python 3.2 introduced a new bytecode caching
mechanism: foo.pyc gets a new name: __pycache__/foo.cpython-32.pyc
(similarly for .so files) ... thus properly fixing such conflicts, even
across different Python interpreter implementations.
* WSGI for Python 3: The WSGI spec is now adapted for Python3's
bytes/text distinction. See PEP 3333 for details.
For the complete list of changes, see
What is ActivePython?
ActivePython is ActiveState's binary distribution of Python. Builds for
Windows, Mac OS X, Linux are made freely available. Solaris, HP-UX and
AIX builds, and access to older versions are available in ActivePython
Business, Enterprise and OEM editions:
ActivePython includes the Python core and the many core extensions: zlib
and bzip2 for data compression, the Berkeley DB (bsddb) and SQLite
(sqlite3) database libraries, OpenSSL bindings for HTTPS support, the
Tix GUI widgets for Tkinter, ElementTree for XML processing, ctypes (on
supported platforms) for low-level library access, and others. The
Windows distribution ships with PyWin32 -- a suite of Windows tools
developed by Mark Hammond, including bindings to the Win32 API and
ActivePython also includes a binary package manager for Python (PyPM)
that can be used to install packages much easily. For example:
C:\>pypm install numpy
>>> import numpy.linalg
PyPM module availability for 3.2 can be seen at:
See this page for full details:
As well, ActivePython ships with a wealth of documentation for both new
and experienced Python programmers. In addition to the core Python docs,
ActivePython includes the "What's New in Python" series, "Dive into
Python", the Python FAQs & HOWTOs, and the Python Enhancement Proposals
An online version of the docs can be found here:
We would welcome any and all feedback to:
Please file bugs against ActivePython at:
ActivePython is available for the following platforms:
- Windows (x86 and x64)
- Mac OS X (x86 and x86_64; 10.5+)
- Linux (x86 and x86_64)
- Solaris/SPARC (32-bit and 64-bit) (Business, Enterprise or OEM edition
- Solaris/x86 (32-bit) (Business, Enterprise or OEM edition only)
- HP-UX/PA-RISC (32-bit) (Business, Enterprise or OEM edition only)
- HP-UX/IA-64 (32-bit and 64-bit) (Enterprise or OEM edition only)
- AIX/PowerPC (32-bit and 64-bit) (Business, Enterprise or OEM edition only)
More information about the Business Edition can be found here:
Custom builds are available in the Enterprise Edition:
Thanks, and enjoy!
The Python Team
sridharr at activestate.com
To celebrate the release of Wing IDE version 4.0 we are offering 20% off
all new licenses, upgrades, and Support+Upgrades subscriptions through
March 17th, 2011. Start at https://wingware.com/store and enter
discount code w4sale when prompted.
For more information on Wing IDE 4.0 see http://wingware.com/news/2011-02-19
Wingware | Python IDE
Advancing Software Development
Wingware has released version 4.0 of Wing IDE, an integrated development
environment designed specifically for the Python programming language.
Wing IDE is a cross-platform Python IDE that provides a professional code
editor with vi, emacs, and other key bindings, auto-completion, call tips,
refactoring, a powerful graphical debugger, version control, unit testing,
search, and many other features.
**Changes in Version 4.0**
Version 4.0 adds the following new major features:
* Refactoring -- Rename and move symbols, and extract code to function
* Find Uses -- Find all points of use of a symbol
* Diff/Merge -- Graphical file and repository comparison and merge
* Django Support -- Debug Django templates, run Django unit tests, and more
* matplotlib Support -- Maintains live-updating plots in shell and debugger
* Simplified Licensing -- Includes all OSes and adds Support+Upgrades
Complete Change Log:
Details on Licensing Changes: http://wingware.com/news/2011-02-16
**About Wing IDE**
Wing IDE is an integrated development environment designed specifically for
the Python programming language. It provides powerful editing, testing, and
debugging features that help reduce development and debugging time, cut down
on coding errors, and make it easier to understand and navigate Python code.
Wing IDE can be used to develop Python code for web, GUI, and embedded
Wing IDE is available in three product levels: Wing IDE Professional is
the full-featured Python IDE, Wing IDE Personal offers a reduced feature
set at a low price, and Wing IDE 101 is a free simplified version designed
for teaching beginning programming courses with Python.
Version 4.0 of Wing IDE Professional includes the following major features:
* Professional quality code editor with vi, emacs, and other keyboard
* Code intelligence for Python: Auto-completion, call tips, find uses,
goto-definition, error indicators, refactoring, smart indent and
and source navigation
* Advanced multi-threaded debugger with graphical UI, command line
conditional breakpoints, data value tooltips over code, watch tool, and
externally launched and remote debugging
* Powerful search and replace options including keyboard driven and
UIs, multi-file, wild card, and regular expression search and replace
* Version control integration for Subversion, CVS, Bazaar, git,
* Integrated unit testing with unittest, nose, and doctest frameworks
* Django support: Debugs Django templates, provides project setup tools,
and runs Django unit tests
* Many other features including project manager, bookmarks, code snippets,
diff/merge tool, OS command integration, indentation manager, PyLint
integration, and perspectives
* Extremely configurable and may be extended with Python scripts
* Extensive product documentation and How-Tos for Django, matplotlib,
Plone, wxPython, PyQt, mod_wsgi, Autodesk Maya, and many other frameworks
Please refer to http://wingware.com/wingide/features for a detailed listing
of features by product level.
System requirements are Windows 2000 or later, OS X 10.3.9 or later
X11 Server), or a recent Linux system (either 32 or 64 bit). Wing IDE
Python versions 2.0.x through 3.2.x and Stackless Python.
For more information, see the http://wingware.com/
Wing IDE Professional and Wing IDE Personal are commercial software and
require a license to run. A free trial can be obtained directly from the
product when launched.
Wing IDE Pro -- Full-featured product:
Wing IDE Personal -- A simplified IDE:
Wing IDE 101 -- For teaching with Python:
**Purchasing and Upgrading**
Wing 4.0 requires an upgrade for Wing IDE 2.x and 3.x users at a cost of
1/2 the full product pricing.
Upgrade a license: https://wingware.com/store/upgrade
Purchase a new license: https://wingware.com/store/purchase
The Wingware Team
Wingware | Python IDE
Advancing Software Development