Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

Click here to view the latest version of this page.

C++ Boost

Boost.Python

May 2002 Progress Report


Contents

Introduction
New Features
Shared Library Support for AIX
Class Enhancements
Operators
Iterators
Properties
setattr
__module__ Attribute
back_reference
Documentation
Miscellaneous
Converters
Checkins Mailing List
Shared Libraries
What's Next

Introduction

Aside from library development, work on Boost.Python in May was focused on reducing the support burden. In recent weeks, responding to requests for support, espcially surrounding building the library, had begun to impede progress on development. There was a major push to release a stable 1.28.0 of Boost, including documentation of Boost.Build and specific instructions for building Boost.Python v1. The documentation for Boost.Python v2 was also updated as described here.

New Features

Shared Library Support for AIX

The Kull group required the ability to build and test Boost.Python extensions on AIX, a platform with "creatively designed" shared library semantics. Making this work was a multi-pronged effort, involving changes to Boost.Build and some great research by Martin Casado which uncovered the key mechanism required to allow shared libraries to use functions from the Python executable. The current solution used in Boost.Build relies on a Python Script as part of the build process. This is not a problem for Boost.Python, as Python will be available. However, the commands issued by the script are so simple that a 100%-pure-Boost.Jam solution is surely possible. Linking on AIX is sufficiently interesting to have skewed the Boost.Python development schedule a bit.

Class Enhancements

Operators

Support for exposing C++ operators and functions as the corresponding Python special methods was added. Thinking that the Boost.Python v1 interface was a little too esoteric (especially the use of left_operand<...>/right_operand<...> for asymmetric operands), I introduced a simple form of expression templates which allow users to simply write the expressions that should be wrapped, as in this example.

Iterators

Python iterator support as required by the Kull project resulted in a highly flexible interface allowing:
Direct exposure of a class' begin() and end() functions:
    ...
    .def("__iter__", iterator<list_int>())
Creation of iterators from member functions...
    ...
    .def("__iter__"
         , range(&my_class::x_begin, &my_class::x_end))
    )
...and member data:
    ...
    .def("__iter__"
         , range(&std::pair<char*,char*>::first, &std::pair<char*,char*>::second))
    )
The ability to specify CallPolicies, e.g. to prevent copying of heavyweight values:
    ...
    .def("__iter__", 
         , range<return_value_policy<copy_non_const_reference> >(
               &my_sequence<heavy>::begin
             , &my_sequence<heavy>::end))

Properties

The Kull iteration interfaces also required the ability to iterate over a sequence specified by an instance's attribute:
>>> f = field()
>>> for e in f.elements:
...     print e,
This forced the exposure of the property interface used internally to implement the data member exposure facility described in March. Properties are an incredibly useful idiom, so it's good to be able to provide them at little new development cost.

setattr

class_<> acquired a setattr member function which allows users to easily add new Python objects as class attributes.

__module__ Attribute

Ralf Grosse-Kunstleve has been working on pickling support for v2. To make it work correctly, he had to make sure that a class' __module__ attribute was set correctly.

back_reference

The new back_reference<T> template can be used as a function parameter when the user needs access to both a T argument and to the Python object which manages it. The function will only match in the overload resolution process if it would match the same function signature with T substituted for back_reference<T>. This feature is not yet documented.

Documentation

In a major effort to prepare Boost.Python v2 to replace v1, many pages of new reference documentation were added:
CallPolicies.html
Dereferenceable.html
Extractor.html
HolderGenerator.html
ResultConverter.html
call_method.html
callbacks.html
data_members.html
has_back_reference.html
implicit.html
instance_holder.html
operators.html
ptr.html
type_id.html
with_custodian_and_ward.html
Major updates were made to the following pages:
call.html
updated
class.html
reference.html
As usual, careful documentation forces one to consider the interface again, and there were many interface changes associated with this effort, including the elevation of the following components from implementation detail to first-class library citizen:
type_id.hpp
pointee.hpp
lvalue_from_pytype.hpp

Miscellaneous

Converters

It appears that the world of C++ <==> Python conversion rules is an endlessly-rich area of exploration. Completing the conversions for char and char const* types, as described at the end of April's report, uncovered some interesting new shades to the problem. It turns out to be worth distinguishing mutable and immutable lvalue conversions, because despite the fact that Python doesn't understand const, it does understand immutability (c.f. Python strings, which expose an immutable char pointer). It is also worth recognizing types which represent lvalue sequences, to prevent Python "foobar" from being silently truncated to C++ 'f'. More details on this insight can be found in the mailing list archive. I don't plan to do anything about this immediately, but I do think it's the right direction to go in the long run.

Checkins Mailing List

In order to better coordinate changes made by multiple developers, I enabled syncmail for the Boost.Python CVS trees, and established an associated mailing list. Subscribe to this list to receive notices of each new checkin.

Shared Libraries

Beyond the vagaries of dynamic linking on AIX, I have been participating in a more-general discussion of dynamic linking for C++. Needless to say, C++ dynamic linking is of critical importance to Boost.Python: all extension modules are normally built as shared libraries, and Boost.Python extension modules share a common library as well. In fact, there are at least two separate conversations. One in the C++ standard extensions mailing list concerns what can be standardized for C++ and shared libraries; the other, mostly on the gcc mailing list, concerns the behavior of GCC on Posix/ELF platforms. Some of the GCC threads are here:
http://gcc.gnu.org/ml/gcc/2002-05/msg02002.html
http://gcc.gnu.org/ml/gcc/2002-05/msg02945.html
http://gcc.gnu.org/ml/gcc/2002-05/msg01758.html

What's Next

Development is focused on what's needed to be able to retire Boost.Python v1. At the moment, that means deciding the user-friendly interfaces for to_/from_python conversion, and formally exposing the Python object smart pointers and object wrapper classes. Quite a few questions have also been showing up recently about how to embed Python with Boost.Python, and how to link with it statically; the solutions to these issues will probably have to be formalized before long.

Revised 13 November, 2002

© Copyright Dave Abrahams 2002. All Rights Reserved.