SIG for development of Python/C++ integration

About Boost.Python

Development goals

Reference/Pointer support

Boost.Python currently refuses to wrap C++ functions which return pointers or non-const references, in order to prevent dangling pointers and references from causing crashes on the Python side. This limits the library's ability to export arbitrary C++ functions.

Goal: Implementation of a mechanism by which references and pointers to internal elements of function and method arguments can be returned safely. This will include a mechanism by which any argument object can be kept alive during the lifetime of any other argument object, so that Wrapped C++ objects can adopt one another without the direct use of smart pointers.

Globally Registered Type Coercions

Goal: Provide a mechanism for global registration of type relationships between arbitrary Python and C++ types, so that, for example, a Python tuple might be automatically converted to a C++ std::vector when passed to a wrapped function accepting a std::vector argument.

Full Cross-Module Support

Inheritance hierarchies which span Python extension modules are not currently supported by Boost.Python. Other inter-module interaction issues, e.g. exception handling, are expected to arise.

Goal: Full support for the interaction of wrapped types and functions residing in different extension modules.

Improved Overloading Support

Boost.Python's support for overloaded functions and operators is based on throwing C++ exceptions when a signature fails to match the appropriate function. This has several disadvantages: firstly, on many implementations the C++ exception-handling mechanism is highly optimized for the case where no exception is thrown, and throwing an exception can pose serious performance penalties. Secondly, enough C++ implementations have bugs in their exception-handling mechanisms that it is best not to rely on exceptions for routine control flow.

Goal: Modification of the type conversion mechanism so that overloading can be implemented without the use of C++ exceptions.

C++ to Python Exception Translation

It is critical for any mature C++ software package to be able to report error conditions via arbitrary exception types. Boost.Python currently provides support for translating only a limited selection of exception types to Python.

Goal: Implementation of a feature which allows arbitrary new exception types to be registered and automatically translated.

Default Argument Support

C++ functions with default argument values can currently be exposed to Python, but the defaults are lost.

Goal: Implementation of compile-time constant default argument expressions. Potentially implementation of lambda expressions for describing default arguments.

Keyword Argument Support

Python supports the specification of particular function arguments by name, rather than by position.

Goal: Implementation of a feature which allows keyword arguments to be used from Python for wrapped C++ functions.

Generic C++ to Python Object Interface

It is often necessary for C++ functions to manipulate objects passed to them directly from Python, without converting them to some other representation. Currently Boost.Python has undocumented support for that usage when the expected Python type is known.

Goal: Addition of a C++ type which wraps any Python object and provides a similar interface to Python's, with the validity of any operation checked at runtime.

Interface for the application of standard C++ algorithms to Python objects

Goal: Implementation of interfaces for the application of C++ Standard Template Library algorithms and boost algorithms to Python objects, such as Python lists, tuples, strings and Python objects that support the buffer interface.

Python LONG support

Python provides an arbitrary-precision LONG integer type which is not currently supported by Boost.Python.

Goal: Addition of an interface to Python LONGs which allows them to be directly manipulated in C++ with a natural interface.

Improved Built-In Numeric Type Coercion

Goal: Python supplies at least 4 numeric types, any of which should be able to be passed where an argument of any C++ numeric type is expected, provided that the conversion does not lose significant information.

Python Iterator Support

Goal: Python 2.2 provides an iteration interface which should allow C++ sequences to be easily exposed to Python in a natural way.

Automatic C++ Object Initialization

While Python allows classes to be created without initialization, C++ does not. Boost.Python currently allows C++ base classes of Python extension classes to remain uninitialized. That behavior is not always appropriate.

Goal: Optional support for the automatic default construction of C++ base classes and error reporting when base classes are not initialized.

DocString Support

Modules, Types, and Functions in Python can be documented with "docstrings", which allow the automatic extraction of documentation (and even testing code) at runtime. Goal: Full support for docstrings on the elements of C++ extension modules and classes.

C++ long long support

The long long type is a popular extension to C++ which allows the representation of integer numeric values of at least 64 bits.

Goal: Automatic conversions of C++ long long values to/from Python.

Code Footprint Reduction

Currently Boost.Python is not optimized to reduce the code size of the C++ extension modules.

Goal: Reengineering of Boost.Python so that the code footprint for each extension module is as small as feasible.

Data Memory Footprint Reduction

Wrapped C++ classes that are not subclassed in Python use more dynamic allocation than necessary, increasing the overall data footprint of an application using Boost.Python extension classes.

Goal: Embedding of C++ classes directly in Python objects. This will eliminate the overhead due to dynamic allocation.