Changelogs » Pyplusplus

PyUp Safety actively tracks 267,404 Python packages for vulnerabilities and notifies you when to upgrade.



  1. Update due to changes in pygccxml 1.8.0.
  2. Performance improvements.
  3. Small documentation fixes.


  1. Reorganize documentation, switch to readthedocs theme.
  2. Misc. small fixes.


  1. Added support for Python 3.
  2. Added support for pygccxml 1.7 and castxml.
  3. Switched to setuptools instead of distutils.


  1. The bug related to exposing free operators was fixed. Many thanks to Andrei Vermel.
  2. Few bugs were fixed for 64Bit platform. Many thanks to Carsten.
  3. :mod:`ctypes` backend was introduced - :doc:`Py++ <index>` is able to
  generate Python code, which uses :mod:`ctypes` package to call functions in
  DLLs or shared libraries.
  Massive refactoring, which preserve backward compatibility to previous releases,
  was done.
  4. From now on, :doc:`Py++ <index>` will use `Sphinx <>`_
  for all documentation.
  5. :doc:`Indexing Suite V2 <indexing_suite_v2.html>` introduces
  few backward compatibility changes. The indexing suite became "headers only"
  library and doesn't requier Boost.Python library patching.
  See ":doc:`containers`" document for more information.
  6. Support for `std::hash_map<...>` and `std::hash_set<...>` containers was added.
  7. The bug related to transformed virtual function was fixed. Many thanks to Pertti Kellomäki.
  8. Thanks to Benoît Leveau, the "Function Transformation" documentation
  is much better now.
  9. The following transformers were added:
  * ``inout_static_array``
  * ``input_static_matrix``
  * ``output_static_matrix``
  * ``inout_static_matrix``
  Many thanks to Benoît Leveau.
  10. Numerous bugs in "ctypes code generator" were fixed. Many thanks to Nikolaus Rath.
  11. Thanks to Alan Birtles, for fixing a small issue on cygwin.
  12. Thanks to Minh-Tri Pham, for reporting bug and providing patch for
  "from_address" transformer, on 64 bit platforms.
  13. Thanks to Aron Xu, for pointing out that it is better to use "",
  instead of "sys.platform" for platform specific logic
  14. Thanks to Scott Sturdivant, for reporting the bug, related to bit fields code generation.
  The bug was fixed.


  1. The algorithm, which calculates what member functions should be redefined in
  derived class wrappers, was improved. Many thanks to Julian Scheid for the bug
  The change explanation.
  .. code-block:: c++
  struct A{
  virtual void foo() {}
  class B: public A{
  Previous version of :doc:`Py++ <index>` didn't generate wrapper for class ``B``, even
  though ``B`` inherits ``A``'s virtual function. Now if you have the following
  Python code:
  .. code-block:: python
  class C(B):
  def __init__( self ):
  def foo(self):
  print ""
  then when ``foo`` is invoked on this instance on the C++ side of things, the
  Python code won't be executed as the wrapper was missing.
  **Warning!** **There is a possibility that your generated code will not work!**
  **Keep reading.**
  If you use "function transformation" functionality, than it is possible the
  generated code will **NOT** work. Consider the following example:
  .. code-block:: c++
  struct A{
  virtual void foo(int& i) {/*do smth*/}
  class B: public A{
  virtual void foo(int& i) {/*do smth else*/}
  The :doc:`Py++ <index>` code:
  .. code-block:: python
  from pyplusplus import module_builder
  from pyplusplus import function_transformers as FT
  mb = module_builder_t( ... )
  foo = mb.member_functions( 'foo' )
  foo.add_transformation( FT.output(0) )
  The generated code, for class ``B``, is:
  .. code-block:: c++
  namespace bp = boost::python;
  struct B_wrapper : B, bp::wrapper< B > {
  virtual void foo( int & i ) const  { ... }
  static boost::python::tuple default_foo( ::B const & inst )
  { ... }
  virtual void foo( int & i ) const
  { ... }
  static boost::python::object default_foo( ::A const & inst )
  { ... }
  bp::class_< B_wrapper, bp::bases< A > >( "B" )
  .def( "foo", (boost::python::tuple (*)( ::B const & ))( &B_wrapper::default_foo ) )
  .def( "foo", (boost::python::object (*)( ::A const & ))( &B_wrapper::default_foo ) );
  As you can see, after applying the transformation both functions have same
  signature. Do you know what function will be called in some situation? I do -
  the wrong one :-(.
  Unfortunately, there is no easy work around or some trick that you can use,
  which will not break the existing code. I see few solutions to the problem:
  * change the alias of the functions
  .. code-block:: python
  from pyplusplus import module_builder
  from pyplusplus import function_transformers as FT
  mb = module_builder_t( ... )
  foo = mb.member_functions( '::A::foo' ).add_transformation( FT.output(0), alias="foo_a" )
  foo = mb.member_functions( '::B::foo' ).add_transformation( FT.output(0), alias="foo_b" )
  * use ``inout`` transformation - it preserves a function signature
  * :doc:`Py++ <index>` can introduce a configuration, that will preserve the previous behaviour.
  I think this is a wrong way to go and doing the API changes is the 'right'
  longer term solution.
  If you **absolutely need** to preserve API backward compatible, contact me
  and I will introduce such configuration option.
  Sorry for inconvenience.
  2. Few bugs, related to Indexing Suite 2, were fixed. Many thanks to Oliver Schweitzer
  for reporting them.
  3. New and highly experimental feature was introduced -
  :doc:`Boost.Python and ctypes integration <ctypes/ctypes_integration>`.
  4. Support for :doc:`boost::python::make_constructor <functions/make_constructor>` functionality was added.
  5. Support for unions and unnamed classes was added.
  6. Doxygen documentation extractor was improved. Many thanks to Hernán Ordiales.
  7. Py++ documentation was improved. Many thanks to Bernd Fritzke.


  1. Bug fixes:
  * Py++ will not expose free operators, if at least one of the classes, it works
  on, is not exposed.
  Many thanks to Meghana Haridev for reporting the bug.
  2. Added ability to completely disable warnings reporting.
  3. All logging is now done to ``stderr`` instead of ``stdout``.
  4. Generated code improvements:
  * ``default_call_policies`` is not generated
  * ``return_internal_reference`` call policies - default arguments are not
  * STD containers are generated without default arguments. For example instead
  of ``std::vector< int, std::allocator< int > >``, in many cases :doc:`Py++ <index>` will
  generate ``std::vector< int >``.
  5. :doc:`create_with_signature <functions/overloading>` algorithm was improved.
  :doc:`Py++ <index>` will generate correct code in one more use case.
  6. Added ability to exclude declarations from being exposed, if they will cause
  compilation to fail.
  7. Starting from this version, :doc:`Py++ <index>` provides a complete solution for
  :doc:`multi-module development <multi_module_development>`.
  8. Classes, which expose C arrays will be registered only once.
  9. Starting from this version, :doc:`Py++ <index>` supports a code generation with different
  10. There is a new strategy to split code into files. It is IDE friendly. Be sure
  to read :doc:`the updated documentation <split_module>`.


  1. Bug fixes:
  * Declaration of virtual functions that have an exception specification with
  an empty throw was fixed. Now the exception specification is generated properly.
  Many thanks to Martin Preisler for reporting the bug.
  2. Added exposing of copy constructor, ``operator=`` and ``operator<<``.
  * ``operator=`` is exposed under "assign" name
  * ``operator<<`` is exposed under "__str__" name
  3. Added new call policies:
  * :doc:`as_tuple <functions/call_policies/as_tuple>`
  * :doc:`custom_call_policies <functions/call_policies/return_range>`
  * :doc:`return_range <functions/call_policies/return_range>`
  4. Added an initial support for multi-module development. Now you can mark your
  declarations as ``already_exposed`` and :doc:`Py++ <index>` will do the rest. For more
  information read :doc:`multi-module development guide <multi_module_development>`.
  .. line-separator
  5. :doc:`input_c_buffer <functions/transformation/input_c_buffer>` - new functions
  transformation, which allows one to pass a Python sequence to function, instead of pair of arguments: pointer to buffer and size.
  6. Added ability to control generated "include" directives. Now you can ask :doc:`Py++ <index>`
  to include a header file, when it generates code for some declaration. For more
  information refers to `inserting code guide`_.
  .. _`inserting code guide` : inserting_code.htmlheader-files
  7. Code generation improvements: system header files ( Boost.Python or Py++ defined )
  will be included from the generated files only in case the generated code
  depends on them.
  8. Performance improvements: Py++ runs 1.5 - 2 times faster, than the previous one.
  9. Added ability to add code before overridden and default function calls.
  For more information refer to `member function API documentation`_.
  .. _`member function API documentation` : apidocs/pyplusplus.decl_wrappers.calldef_wrapper.member_function_t-class.html
  10. :doc:`Py++ <index>` will generate documentation for automatically constructed properties.
  For more information refer to :doc:`properties guide <properties>`.
  11. Added iteration functionality to Boost.Python Indexing Suite V2 ``std::map``
  and ``std::multimap`` containers.


  1. Added :doc:`Function Transformation <functions/transformation/transformation>` feature.
  2. "Py++" introduces new functionality, which allows you to control messages and
  warnings: :doc:`how to disable warnings? <warnings>`.
  3. Added new algorithm, which controls the registration order of the functions.
  See :doc:`registration order document <functions/registration_order>`
  4. New "Py++" defined :doc:`return_pointee_value <functions/call_policies/return_pointee_value>`
  call policy was introduced.
  5. Support for opaque types was added. Read more about this feature `here`__.
  .. __ : functions/call_policies/call_policies.htmlspecial-case
  6. It is possible to configure "Py++" to generate faster ( compilation time )
  code for indexing suite version 2. See API documentation.
  7. The algorithm, which finds all class properties was improved. It provides
  user with a better way to control properties creation. A property that would
  hide another exposed declaration will not be registered\\created.
  8. Work around for "custom smart pointer as member variable" Boost.Python bug
  was introduced.
  9. Bugs fixes and documentation improvement.


  1. Interface changes:
  * ``module_builder.module_builder_t.build_code_creator`` method:
  argument ``create_casting_constructor`` was removed and deprecation warning
  was introduced.
  2. Performance improvements. In some cases you can get x10 performance boost.
  Many thanks to Allen Bierbaum! Saving and reusing results of different
  `pygccxml <>`_ algorithms and type traits functions achieved this.
  3. Convenience API for registering exception translator was introduced.
  4. :doc:`Py++ <index>` can generate code that uses ``BOOST_PYTHON_FUNCTION_OVERLOADS`` and
  5. Treatment to previously generated and no more in-use files was added. By
  default :doc:`Py++ <index>` will delete these files, but of course you can redefine this
  6. Generated code changes:
  * ``default_call_policies`` should not be generated any more.
  * For functions that have ``return_value_policy< return_opaque_pointer >``
  call policy, :doc:`Py++ <index>` will automatically generate ``BOOST_PYTHON_OPAQUE_SPECIALIZED_TYPE_ID``
  macro. Thank you very much for Gottfried Ganssauge for this idea.
  7. Support for Boost.Python properties was introduced. :doc:`Py++ <index>` implements small
  algorithm, that will automatically discover properties, base on naming conventions.
  8. ``decl_wrappers.class_t`` has new function: ``is_wrapper_needed``. This
  function explains why :doc:`Py++ <index>` creates class wrapper for exposed class.
  9. Python type traits module was introduce. Today it contains only single function:
  * ``is_immutable`` - returns ``True`` if exposed type is Python immutable type


  1. Georgiy Dernovoy contributed a patch, which allows :doc:`Py++ <index>` GUI to
  save\\load last used header file.
  2. :doc:`Py++ <index>` improved a lot functionality related to providing feedback to user:
  * every package has its own logger
  * only important user messages are written to ``stdout``
  * user messages are clear
  3. Support for Boost.Python indexing suite version 2 was implemented.
  4. Every code creator class took ``parent`` argument in ``__init__`` method.
  This argument was removed. ``adopt_creator`` and ``remove_creator`` will
  set\unset reference to parent.
  5. Generated code for member and free functions was changed. This changed was
  introduced to fix compilation errors on msvc 7.1 compiler.
  6. :doc:`Py++ <index>` generates "stable" code. If header files were not changed,
  :doc:`Py++ <index>` will not change any file.
  7. Support for huge classes was added. :doc:`Py++ <index>` is able to split registration
  code for the class to multiple cpp files.
  8. User code could be added almost anywhere, without use of low level API.
  9. Generated source files include only header files you passes as an argument
  to module builder.
  10. Bug fixes.
  11. Documentation was improved.
  Project name changed
  In this version the project has been renamed from "pyplusplus" to "Py++".
  There were few reasons to this:
  1. I like "Py++" more then "pyplusplus".
  2. "Py++" was the original name of the project:
  3. Users always changed the name of the projects. I saw at least 6 different names.


  1. :doc:`Py++ <index>` "user guide" functionality has been improved. Now :doc:`Py++ <index>`
  can answer few questions:
  * why this declaration could not be exported
  * why this function could not be overridden from Python
  2. :doc:`Py++ <index>` can suggest an alias for exported classes.
  3. Small redesign has been done - now it is much easier to understand and
  maintain code creators, which creates code for C++ functions.
  4. Exception specification is taken into account, when :doc:`Py++ <index>` exports
  member functions.
  5. Member variables, that are pointers exported correctly.
  6. Added experimental support for ``vector_indexing_suite``.
  7. Bug fixes.


  Many thanks to *Matthias Baas* and *Allen Bierbaum*! They contributed so much to
  Py++, especially Matthias:
  * New high-level API: :doc:`Py++ <index>` has simple and powerful API
  * Documentation: Matthias and Allen added a lot of documentation strings
  * Bug fixes and performance improvements
  1. New GUI features:
  * It is possible now to see XML generated by GCC-XML.
  * It is possible to use GUI as wizard. It will help you to start  with
  :doc:`Py++ <index>`, by generating :doc:`Py++ <index>` code.
  2. **Attention - non backward compatible change**.
  ``module_creator.creator_t.__init__`` method has been changed. ``decls``
  argument could be interpreted as
  * list of all declaration to be exported
  * list of top-level declarations. ``creator_t`` should export all
  declarations recursively.
  In order to clarify the use of ``decls`` argument new argument ``recursive``
  has been added. By default new value of ``recursive`` is ``False``.
  Guide for users/upgraders: if use are exporting all declaration without
  filtering, you should set ``recursive`` argument to ``True``. If you use
  ``pygccxml.declarations.filtering.*`` functions, you have nothing to do.
  Sorry for the inconvenience :-(.
  3. Better split of extension module to files. From now the following declarations will
  have dedicated file:
  * named enumerations, defined within namespace
  * unnamed enumerations and global variables
  * free functions
  This functionality will keep the number of instantiated templates within
  one file, ``main.cpp``, to be very low. Also it is possible to implement
  solution, where ``main.cpp`` file does not contain templates instantiations
  at all.
  4. Only constant casting operators could be used with ``implicitly_convertible``.
  This bug has been fixed.
  5. Bug exporting non copyable class has been fixed.
  6. Small bug fix - from now file with identical content will not be overwritten.
  7. Boost.Python ``optional`` is now supported and used when a constructor has a
  a default argument.
  8. :doc:`Py++ <index>` now generates correct code for hierarchy of abstract classes:
  .. code-block:: c++
  struct abstract1{
  virtual void do_smth() = 0;
  struct abstract2 : public abstract1{
  virtual void do_smth_else() = 0;
  struct concrete : public abstract2{
  virtual void do_smth(){};
  virtual void do_smth_else(){};
  9. Logging functionality has been added
  10. New packages ``module_builder``, ``decl_wrappers`` and ``_logging_`` has
  been added.
  11. ...


  1. Code repository has been introduced. This repository contains classes
  and functions that will help users to export different C++ classes and
  declarations. Right now this repository contains two classes:
  * *array_1_t*
  * *const_array_1_t*
  Those classes helps to export static, single dimension arrays.
  2. Code generation has been improved.
  3. Code generation speed has been improved.
  4. If you have Niall Douglas *void\** patch, then you can enjoy from
  automatically set call policies.
  5. Bit fields can be accessed from Python
  6. Creating custom code creator example has been added.
  7. Comparison to Pyste has been wrote.
  8. Using this version it is possible to export most of TnFOX Python bindings.


  1. operator() is now supported.
  2. Special casting operators are renamed( *__int__*, *__str__*, ... ).
  3. Few bug fixes
  .. _`SourceForge`: