Test multiple Python versions.

Py_REFCNT was stabilized in 3.9, uses this official API instead of the
`ob_refcnt` field that doesn't exist in the free-threaded build of 3.13.

.github/workflows/deploy-documentation.yml

@@ -1,6 +1,6 @@
 name: deploy documentation
 
-on: [push, pull_request]
+on: [push]
 
 jobs:
   deploy:

.github/workflows/test-osx.yml

@@ -9,14 +9,14 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: [3.6]
+        python-version: ['3.8.10', '3.12']
         cxx: [clang++]
-        std: [c++98, c++11, c++14] # TODO: c++17 is failing !
+        std: [c++11, c++14] # TODO: c++17 is failing !
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
     - name: setup python
-      uses: actions/setup-python@v2
+      uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
     - name: setup prerequisites
@@ -28,18 +28,23 @@ jobs:
       run: |
         python --version
         ${{ matrix.cxx }} --version
+        brew info boost
         faber -v
         sed -e "s/\$PYTHON/python/g" .ci/faber > ~/.faber
         faber \
+          --with-boost-include=$(brew --prefix boost)/include \
           --builddir=build \
           cxx.name=${{ matrix.cxx }} \
           cxxflags=-std=${{ matrix.std }} \
+          cppflags=-std=${{ matrix.std }} \
           -j`sysctl -n hw.ncpu`
     - name: test
       run: |
         faber \
+          --with-boost-include=$(brew --prefix boost)/include \
           --builddir=build\
           cxx.name=${{ matrix.cxx }} \
           cxxflags=-std=${{ matrix.std }} \
+          cppflags=-std=${{ matrix.std }} \
           -j`sysctl -n hw.ncpu` \
           test.report

.github/workflows/test-ubuntu.yml

@@ -26,7 +26,7 @@ jobs:
       image: ${{ matrix.docker-img }}
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
 
     - name: build
       run: |
@@ -39,6 +39,7 @@ jobs:
           --builddir=build \
           cxx.name=${{ matrix.cxx }} \
           cxxflags=-std=${{ matrix.std }} \
+          cppflags=-std=${{ matrix.std }} \
           -j`nproc`
     - name: test
       run: |
@@ -47,5 +48,6 @@ jobs:
           --builddir=build \
           cxx.name=${{ matrix.cxx }} \
           cxxflags=-std=${{ matrix.std }} \
+          cppflags=-std=${{ matrix.std }} \
           -j`nproc` \
           test.report

.github/workflows/test-windows.yml

@@ -11,20 +11,30 @@ jobs:
         python-version: [3.7]
 
     steps:
-    - uses: actions/checkout@v2
+    - uses: actions/checkout@v4
-    - uses: actions/setup-python@v2
+    - uses: actions/setup-python@v5
       with:
         python-version: ${{ matrix.python-version }}
+    - uses: microsoft/setup-msbuild@v1.1
     - name: setup boost prerequisites
       uses: lukka/run-vcpkg@v6
       with:
-        vcpkgGitCommitId: '8a9a97315aefb3f8bc5d81bf66ca0025938b9c91'
+        vcpkgGitCommitId: '88b1071e39f13b632644d9d953738d345a4ac055'
         vcpkgDirectory: '${{ runner.workspace }}/vcpkg'
         vcpkgTriplet: x64-windows
-        vcpkgArguments: boost-config boost-core boost-function boost-graph boost-iterator boost-lexical-cast boost-mpl boost-preprocessor boost-smart-ptr boost-static-assert boost-align
+        vcpkgArguments: >
-
+          boost-config
+          boost-core
+          boost-function
+          boost-graph
+          boost-iterator
+          boost-lexical-cast
+          boost-mpl
+          boost-preprocessor
+          boost-smart-ptr
+          boost-static-assert
+          boost-align
     - name: setup faber
-      #shell: 'bash'
       run: |
         python -m pip install --upgrade pip
         python -m pip install setuptools faber numpy

build.jam

@@ -0,0 +1,41 @@
+# Copyright René Ferdinand Rivera Morell 2024
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+require-b2 5.2 ;
+
+constant boost_dependencies :
+    /boost/align//boost_align
+    /boost/bind//boost_bind
+    /boost/config//boost_config
+    /boost/conversion//boost_conversion
+    /boost/core//boost_core
+    /boost/detail//boost_detail
+    /boost/foreach//boost_foreach
+    /boost/function//boost_function
+    /boost/iterator//boost_iterator
+    /boost/lexical_cast//boost_lexical_cast
+    /boost/mpl//boost_mpl
+    /boost/numeric_conversion//boost_numeric_conversion
+    /boost/preprocessor//boost_preprocessor
+    /boost/static_assert//boost_static_assert
+    /boost/tuple//boost_tuple
+    /boost/type_traits//boost_type_traits
+    /boost/utility//boost_utility ;
+
+project /boost/python
+    : common-requirements
+        <include>include
+    ;
+
+explicit
+    [ alias boost_python : build//boost_python ]
+    [ alias boost_numpy : build//boost_numpy ]
+    [ alias all : boost_python boost_numpy test ]
+    ;
+
+call-if : boost-library python
+    : install boost_python boost_numpy
+    ;
+

build/Jamfile

@@ -30,14 +30,34 @@ else
         ;
 }
 
-project boost/python
+constant boost_dependencies_private :
+    /boost/graph//boost_graph
+    /boost/integer//boost_integer
+    /boost/property_map//boost_property_map
+    /boost/smart_ptr//boost_smart_ptr
+    ;
+
+project
   : source-location ../src
+  : common-requirements <library>$(boost_dependencies)
+  : requirements <library>$(boost_dependencies_private)
   ;
 
 rule cond ( test ? : yes * : no * ) { if $(test) { return $(yes) ; } else { return $(no) ; } }
 rule unless ( test ? : yes * : no * ) { if ! $(test) { return $(yes) ; } else { return $(no) ; } }
 local rule eq ( a : b ) { if $(a) = $(b) { return 1 ; } }
 
+rule tag ( name : type ? : property-set )
+{
+    if python-tag in [ RULENAMES $(__name__) ]
+    {
+        return [  $(__name__).python-tag $(name) : $(type) : $(property-set) ] ;
+    }
+}
+
+if [ python.configured ]
+{
+
 lib boost_python
     : # sources
     list.cpp
@@ -92,8 +112,9 @@ lib boost_python
         [ unless [ python.configured ] : <build>no ]
         <dependency>config-warning
         <python-debugging>on:<define>BOOST_DEBUG_PYTHON
+        -<tag>@%boostcpp.tag
         -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
-        <tag>@python-tag
+        <tag>@tag
         <conditional>@python.require-py
 
     :   # default build
@@ -101,8 +122,20 @@ lib boost_python
     :   # usage requirements
         <link>static:<define>BOOST_PYTHON_STATIC_LIB
         <python-debugging>on:<define>BOOST_DEBUG_PYTHON
+        <define>BOOST_PYTHON_NO_LIB
     ;
 
+}
+else
+{
+
+alias boost_python : config-warning ;
+
+}
+
+if [ python.configured ] && [ python.numpy ]
+{
+
 numpy-include = [ python.numpy-include ] ;
 lib boost_numpy
     : # sources
@@ -120,8 +153,9 @@ lib boost_numpy
         <library>/python//numpy
         <library>boost_python
         <python-debugging>on:<define>BOOST_DEBUG_PYTHON
+        -<tag>@%boostcpp.tag
         -<tag>@$(BOOST_JAMROOT_MODULE)%$(BOOST_JAMROOT_MODULE).tag
-        <tag>@python-tag
+        <tag>@tag
         <conditional>@python.require-py
 
     :   # default build
@@ -129,39 +163,13 @@ lib boost_numpy
     :   # usage requirements
         <link>static:<define>BOOST_NUMPY_STATIC_LIB
         <python-debugging>on:<define>BOOST_DEBUG_PYTHON
+        <define>BOOST_NUMPY_NO_LIB
     ;
 
-# boost-install creates `stage` and `install` targets
-#
-# `stage` stages (builds and copies into `stage/lib`) the given libraries
-#   `boost_python` and `boost_numpy` and their dependencies and is similar
-#   to issuing `b2 --with-python stage` from top level
-#
-# `install` installs the two libraries and their dependencies and is similar
-#   to issuing `b2 --with-python install` from top level
-
-if [ python.configured ]
-{
-    if [ python.numpy ]
-    {
-        boost-install boost_python boost_numpy ;
-    }
-    else
-    {
-        boost-install boost_python ;
-    }
 }
 else
 {
 
-# When Python isn't configured, the above `boost-install` is not executed,
+alias boost_numpy : config-warning ;
-# so we create empty `stage` and `install` targets that do nothing but issue
-# a warning message unless `--without-python` is given
-
-alias stage : config-warning ;
-explicit stage ;
-
-alias install : config-warning ;
-explicit install ;
 
 }

doc/numpy/_static/boost.css

@@ -714,3 +714,23 @@ span.purple { color: purple; }
 span.gold { color: gold; }
 span.silver { color: silver; } /* lighter gray */
 span.gray { color: #808080; } /* light gray */
+
+/* 2022 fix */
+
+ol.simple ol p,
+ol.simple ul p,
+ul.simple ol p,
+ul.simple ul p {
+    margin-top: 0;
+}
+
+ol.simple > li:not(:first-child) > p,
+ul.simple > li:not(:first-child) > p {
+    margin-top: 0;
+}
+
+ol.simple p,
+ul.simple p {
+    margin-bottom: 0;
+}
+

doc/numpy/_templates/layout.html

@@ -49,6 +49,9 @@
     {%- for scriptfile in script_files %}
     <script type="text/javascript" src="{{ pathto(scriptfile, 1) }}"></script>
     {%- endfor %}
+    <script data-url_root="{{ pathto('', 1) }}" id="documentation_options" src="{{ pathto('', 1) }}_static/documentation_options.js"></script>
+    <script src="{{ pathto('', 1) }}_static/searchtools.js"></script>
+    <script src="{{ pathto('', 1) }}_static/language_data.js"></script>
     {%- if use_opensearch %}
     <link rel="search" type="application/opensearchdescription+xml"
           title="{% trans docstitle=docstitle|e %}Search within {{ docstitle }}{% endtrans %}"

doc/numpy/tutorial/dtype.rst

@@ -48,7 +48,7 @@ Next, create a list, and add this tuple to the list. Then use the list to create
     list_for_dtype.append(for_custom_dtype) ;
     np::dtype custom_dtype = np::dtype(list_for_dtype) ;
 
-We are now ready to create an ndarray with dimensions specified by \*shape\* and of custom dtpye ::
+We are now ready to create an ndarray with dimensions specified by \*shape\* and of custom dtype ::
 
     np::ndarray new_array = np::zeros(shape,custom_dtype);
   }

example/README.md

@@ -3,7 +3,7 @@
 # Examples
 
 This directory contains various examples using Boost.Python.
-You may compile these using the `bjam` command either in this directory
+You may compile these using the `b2` command either in this directory
 or in any of the subdirectories.
 You may need to adjust the paths in the Jamroot file if Boost.Python
 is not installed in a default location.

include/boost/python/call_method.hpp

@@ -59,7 +59,7 @@ call_method(PyObject* self, char const* name
     )
 {
     PyObject* const result = 
-        PyEval_CallMethod(
+        PyObject_CallMethod(
             self
             , const_cast<char*>(name)
             , const_cast<char*>("(" BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_FIXED, "O") ")")

include/boost/python/class.hpp

@@ -372,10 +372,11 @@ class class_ : public objects::class_base
     {
         typedef typename api::is_object_operators<F>::type is_obj_or_proxy;
         
-        return this->make_fn_impl(
+        return objects::add_doc(
+            this->make_fn_impl(
             detail::unwrap_wrapper((W*)0)
           , f, is_obj_or_proxy(), (char*)0, detail::is_data_member_pointer<F>()
-        );
+        ), NULL);
     }
     
     template <class F>
@@ -383,10 +384,11 @@ class class_ : public objects::class_base
     {
         typedef typename api::is_object_operators<F>::type is_obj_or_proxy;
         
-        return this->make_fn_impl(
+        return objects::add_doc(
+            this->make_fn_impl(
             detail::unwrap_wrapper((W*)0)
           , f, is_obj_or_proxy(), (int*)0, detail::is_data_member_pointer<F>()
-        );
+        ), NULL);
     }
     
     template <class T, class F>

include/boost/python/converter/pytype_function.hpp

@@ -9,7 +9,7 @@
 # include <boost/python/converter/registered.hpp>
 #  include <boost/python/detail/unwind_type.hpp>
 #  include <boost/python/detail/type_traits.hpp>
-
+# include <boost/python/back_reference.hpp>
 
 namespace boost { namespace python {
 
@@ -46,6 +46,12 @@ inline python::type_info unwind_type_id_(boost::type<T>* = 0, mpl::false_ * =0)
     return boost::python::detail::unwind_type<unwind_type_id_helper, T> ();
 }
 
+template <class T>
+inline python::type_info unwind_type_id_(boost::type<back_reference<T> >* = 0, mpl::false_ * =0)
+{
+    return boost::python::detail::unwind_type<unwind_type_id_helper, T> ();
+}
+
 inline python::type_info unwind_type_id_(boost::type<void>* = 0, mpl::true_* =0)
 {
     return type_id<void>();

include/boost/python/detail/config.hpp

@@ -57,9 +57,15 @@
  ****************************************************************************/
 
 // backwards compatibility:
-#ifdef BOOST_PYTHON_STATIC_LIB
+#if defined(BOOST_PYTHON_STATIC_LINK) && !defined(BOOST_PYTHON_STATIC_LIB)
-#  define BOOST_PYTHON_STATIC_LINK
+#  define BOOST_PYTHON_STATIC_LIB
-# elif !defined(BOOST_PYTHON_DYNAMIC_LIB)
+#endif
+
+#if defined(BOOST_PYTHON_DYNAMIC_LINK) && !defined(BOOST_PYTHON_DYNAMIC_LIB)
+#  define BOOST_PYTHON_DYNAMIC_LIB
+#endif
+
+#if !defined(BOOST_PYTHON_STATIC_LIB) && !defined(BOOST_PYTHON_DYNAMIC_LIB)
 #  define BOOST_PYTHON_DYNAMIC_LIB
 #endif
 

include/boost/python/make_constructor.hpp

@@ -61,7 +61,8 @@ namespace detail
           typedef objects::pointer_holder<Ptr,value_type> holder;
           typedef objects::instance<holder> instance_t;
 
-          void* memory = holder::allocate(this->m_self, offsetof(instance_t, storage), sizeof(holder));
+          void* memory = holder::allocate(this->m_self, offsetof(instance_t, storage), sizeof(holder),
+                                          boost::python::detail::alignment_of<holder>::value);
           try {
 #if defined(BOOST_NO_CXX11_SMART_PTR)
               (new (memory) holder(x))->install(this->m_self);

include/boost/python/object/add_to_namespace.hpp

@@ -18,6 +18,8 @@ BOOST_PYTHON_DECL void add_to_namespace(
 BOOST_PYTHON_DECL void add_to_namespace(
     object const& name_space, char const* name, object const& attribute, char const* doc);
 
+BOOST_PYTHON_DECL object const& add_doc(object const& attribute, char const* doc);
+
 }}} // namespace boost::python::objects
 
 #endif // ADD_TO_NAMESPACE_DWA200286_HPP

include/boost/python/object/function.hpp

@@ -35,6 +35,8 @@ struct BOOST_PYTHON_DECL function : PyObject
     static void add_to_namespace(
         object const& name_space, char const* name, object const& attribute, char const* doc);
 
+    static object const& add_doc(object const& attribute, char const* doc);
+
     object const& doc() const;
     void doc(object const& x);
     
@@ -42,6 +44,8 @@ struct BOOST_PYTHON_DECL function : PyObject
 
     object const& get_namespace() const { return m_namespace; }
     
+    object const& get_module() const { return m_module; }
+
  private: // helper functions
     object signature(bool show_return_type=false) const;
     object signatures(bool show_return_type=false) const;
@@ -53,6 +57,7 @@ struct BOOST_PYTHON_DECL function : PyObject
     handle<function> m_overloads;
     object m_name;
     object m_namespace;
+    object m_module;
     object m_doc;
     object m_arg_names;
     unsigned m_nkeyword_values;

include/boost/python/object/function_doc_signature.hpp

@@ -18,13 +18,13 @@
 namespace boost { namespace python { namespace objects {
 
 class function_doc_signature_generator{
-    static const  char * py_type_str(const python::detail::signature_element &s);
+    static str py_type_str(const python::detail::signature_element &s, const object& current_module_name);
     static bool arity_cmp( function const *f1, function const *f2 );
     static bool are_seq_overloads( function const *f1, function const *f2 , bool check_docs);
     static std::vector<function const*> flatten(function const *f);
     static std::vector<function const*> split_seq_overloads( const std::vector<function const *> &funcs, bool split_on_doc_change);
     static str raw_function_pretty_signature(function const *f, size_t n_overloads,  bool cpp_types = false);
-    static str parameter_string(py_function const &f, size_t n, object arg_names, bool cpp_types);
+    static str parameter_string(py_function const &f, size_t n, object arg_names, const object& module_name, bool cpp_types);
     static str pretty_signature(function const *f, size_t n_overloads,  bool cpp_types = false);
 
 public:

include/boost/python/object_operators.hpp

@@ -9,7 +9,7 @@
 
 # include <boost/python/object_core.hpp>
 # include <boost/python/call.hpp>
-# include <boost/iterator/detail/enable_if.hpp>
+# include <boost/type_traits/enable_if.hpp>
 # include <boost/mpl/bool.hpp>
 
 # include <boost/iterator/detail/config_def.hpp>
@@ -40,7 +40,7 @@ struct is_object_operators
 # if !defined(BOOST_NO_SFINAE) && !defined(BOOST_NO_IS_CONVERTIBLE)
 template <class L, class R, class T>
 struct enable_binary
-  : boost::iterators::enable_if<is_object_operators<L,R>, T>
+  : boost::enable_if_<is_object_operators<L,R>::value, T>
 {};
 #  define BOOST_PYTHON_BINARY_RETURN(T) typename enable_binary<L,R,T>::type
 # else

include/boost/python/pure_virtual.hpp

@@ -96,6 +96,7 @@ namespace detail
             , make_function(
                   detail::nullary_function_adaptor<void(*)()>(pure_virtual_called)
                 , default_call_policies()
+                , options.keywords()
                 , detail::error_signature<held_type>(detail::get_signature(m_pmf))
               )
           );

src/converter/from_python.cpp

@@ -222,7 +222,13 @@ namespace
       , char const* ref_type)
   {
       handle<> holder(source);
-      if (source->ob_refcnt <= 1)
+      if (
+#if PY_VERSION_HEX < 0x03090000
+                source->ob_refcnt
+#else
+                Py_REFCNT(source)
+#endif
+                <= 1)
       {
           handle<> msg(
 #if PY_VERSION_HEX >= 0x3000000

src/exec.cpp

@@ -109,8 +109,8 @@ object BOOST_PYTHON_DECL exec_file(char const *filename, object global, object l
   PyObject *fo = Py_BuildValue("s", f);
   PyObject *fb = Py_None;
   PyUnicode_FSConverter(fo, &fb);
-  f = PyBytes_AsString(fb);
+  char *f_as_uft = PyBytes_AsString(fb);
-  FILE *fs = fopen(f, "r");
+  FILE *fs = fopen(f_as_uft, "r");
   Py_DECREF(fo);
   Py_DECREF(fb);
 #elif PY_VERSION_HEX >= 0x03000000
@@ -129,6 +129,7 @@ object BOOST_PYTHON_DECL exec_file(char const *filename, object global, object l
                 f,
                 Py_file_input,
 		global.ptr(), local.ptr());
+  fclose(fs);
   if (!result) throw_error_already_set();
   return object(detail::new_reference(result));
 }

src/numpy/dtype.cpp

@@ -98,35 +98,16 @@ python::detail::new_reference dtype::convert(object const & arg, bool align)
   return python::detail::new_reference(reinterpret_cast<PyObject*>(obj));
 }
 
-int dtype::get_itemsize() const { return reinterpret_cast<PyArray_Descr*>(ptr())->elsize;}
+int dtype::get_itemsize() const {
+#if NPY_ABI_VERSION < 0x02000000
+  return reinterpret_cast<PyArray_Descr*>(ptr())->elsize;
+#else
+  return PyDataType_ELSIZE(reinterpret_cast<PyArray_Descr*>(ptr()));
+#endif
+}
 
 bool equivalent(dtype const & a, dtype const & b) {
-    // On Windows x64, the behaviour described on 
+  return a == b;
-    // http://docs.scipy.org/doc/numpy/reference/c-api.array.html for
-    // PyArray_EquivTypes unfortunately does not extend as expected:
-    // "For example, on 32-bit platforms, NPY_LONG and NPY_INT are equivalent".
-    // This should also hold for 64-bit platforms (and does on Linux), but not
-    // on Windows. Implement an alternative:
-#ifdef _MSC_VER
-    if (sizeof(long) == sizeof(int) &&
-        // Manually take care of the type equivalence.
-        ((a == dtype::get_builtin<long>() || a == dtype::get_builtin<int>()) &&
-         (b == dtype::get_builtin<long>() || b == dtype::get_builtin<int>()) ||
-         (a == dtype::get_builtin<unsigned int>() || a == dtype::get_builtin<unsigned long>()) &&
-         (b == dtype::get_builtin<unsigned int>() || b == dtype::get_builtin<unsigned long>()))) {
-        return true;
-    } else {
-        return PyArray_EquivTypes(
-            reinterpret_cast<PyArray_Descr*>(a.ptr()),
-            reinterpret_cast<PyArray_Descr*>(b.ptr())
-        );
-    }
-#else
-    return PyArray_EquivTypes(
-        reinterpret_cast<PyArray_Descr*>(a.ptr()),
-        reinterpret_cast<PyArray_Descr*>(b.ptr())
-    );
-#endif
 }
 
 namespace

src/object/class.cpp

@@ -333,8 +333,9 @@ namespace objects
           for (instance_holder* p = kill_me->objects, *next; p != 0; p = next)
           {
               next = p->next();
+              void* q = dynamic_cast<void*>(p);
               p->~instance_holder();
-              instance_holder::deallocate(inst, dynamic_cast<void*>(p));
+              instance_holder::deallocate(inst, q);
           }
         
           // Python 2.2.1 won't add weak references automatically when
@@ -502,6 +503,16 @@ namespace objects
           );
   }
 
+  object qualname(const char *name)
+  {
+#if PY_VERSION_HEX >= 0x03030000
+      if (PyObject_HasAttrString(scope().ptr(), "__qualname__")) {
+          return str("%s.%s" % make_tuple(scope().attr("__qualname__"), name));
+      }
+#endif
+      return str(name);
+  }
+
   namespace
   {
     // Find a registered class object corresponding to id. Return a
@@ -564,6 +575,9 @@ namespace objects
    
       object m = module_prefix();
       if (m) d["__module__"] = m;
+#if PY_VERSION_HEX >= 0x03030000
+      d["__qualname__"] = qualname(name);
+#endif
 
       if (doc != 0)
           d["__doc__"] = doc;
@@ -753,10 +767,9 @@ void* instance_holder::allocate(PyObject* self_, std::size_t holder_offset, std:
             throw std::bad_alloc();
 
         const uintptr_t x = reinterpret_cast<uintptr_t>(base_storage) + sizeof(alignment_marker_t);
-        //this has problems for x -> max(void *)
+        // Padding required to align the start of a data structure is: (alignment - (x % alignment)) % alignment
-        //const size_t padding = alignment - ((x + sizeof(alignment_marker_t)) % alignment);
+        // Since the alignment is a power of two, the formula can be simplified with bitwise AND operator as follow:
-        //only works for alignments with alignments of powers of 2, but no edge conditions
+        const uintptr_t padding = (alignment - (x & (alignment - 1))) & (alignment - 1);
-        const uintptr_t padding = alignment == 1 ? 0 : ( alignment - (x & (alignment - 1)) );
         const size_t aligned_offset = sizeof(alignment_marker_t) + padding;
         void* const aligned_storage = (char *)base_storage + aligned_offset;
         BOOST_ASSERT((char *) aligned_storage + holder_size <= (char *)base_storage + base_allocation);

src/object/enum.cpp

@@ -49,7 +49,9 @@ extern "C"
         if (!self->name)
         {
             return
-#if PY_VERSION_HEX >= 0x03000000
+#if PY_VERSION_HEX >= 0x03030000
+                PyUnicode_FromFormat("%S.%S(%ld)", mod, ((PyHeapTypeObject*)(self_->ob_type))->ht_qualname, PyLong_AsLong(self_));
+#elif PY_VERSION_HEX >= 0x03000000
                 PyUnicode_FromFormat("%S.%s(%ld)", mod, self_->ob_type->tp_name, PyLong_AsLong(self_));
 #else
                 PyString_FromFormat("%s.%s(%ld)", PyString_AsString(mod), self_->ob_type->tp_name, PyInt_AS_LONG(self_));
@@ -62,7 +64,9 @@ extern "C"
                 return 0;
 
             return
-#if PY_VERSION_HEX >= 0x03000000
+#if PY_VERSION_HEX >= 0x03030000
+                PyUnicode_FromFormat("%S.%S.%S", mod, ((PyHeapTypeObject*)(self_->ob_type))->ht_qualname, name);
+#elif PY_VERSION_HEX >= 0x03000000
                 PyUnicode_FromFormat("%S.%s.%S", mod, self_->ob_type->tp_name, name);
 #else
                 PyString_FromFormat("%s.%s.%s", 
@@ -113,7 +117,6 @@ static PyTypeObject enum_type_object = {
 #if PY_VERSION_HEX < 0x03000000
     | Py_TPFLAGS_CHECKTYPES
 #endif
-    | Py_TPFLAGS_HAVE_GC
     | Py_TPFLAGS_BASETYPE,                  /* tp_flags */
     0,                                      /* tp_doc */
     0,                                      /* tp_traverse */
@@ -146,6 +149,7 @@ static PyTypeObject enum_type_object = {
 };
 
 object module_prefix();
+object qualname(const char *name);
 
 namespace
 {
@@ -176,6 +180,11 @@ namespace
       object module_name = module_prefix();
       if (module_name)
          d["__module__"] = module_name;
+#if PY_VERSION_HEX >= 0x03030000
+      object q = qualname(name);
+      if (q)
+         d["__qualname__"] = q;
+#endif
       if (doc)
          d["__doc__"] = doc;
 

src/object/function.cpp

@@ -419,6 +419,30 @@ namespace detail
     extern char cpp_signature_tag[];
 }
 
+object const& function::add_doc(object const& attribute, char const* doc)
+{
+    str _doc;
+
+    if (docstring_options::show_py_signatures_)
+    {
+        _doc += str(const_cast<const char*>(detail::py_signature_tag));
+    }
+    if (doc != 0 && docstring_options::show_user_defined_)
+        _doc += doc;
+
+    if (docstring_options::show_cpp_signatures_)
+    {
+        _doc += str(const_cast<const char*>(detail::cpp_signature_tag));
+    }
+    if(_doc)
+    {    
+        object mutable_attribute(attribute);
+        mutable_attribute.attr("__doc__")= _doc;
+    }
+
+    return attribute;
+}
+
 void function::add_to_namespace(
     object const& name_space, char const* name_, object const& attribute, char const* doc)
 {
@@ -489,11 +513,24 @@ void function::add_to_namespace(
 
         assert(!PyErr_Occurred());
         handle<> name_space_name(
-            allow_null(::PyObject_GetAttrString(name_space.ptr(), const_cast<char*>("__name__"))));
+            allow_null(::PyObject_GetAttrString(name_space.ptr(), const_cast<char*>(
+#if PY_VERSION_HEX < 0x03030000
+                "__name__"
+#else
+                "__qualname__"
+#endif
+            ))));
         PyErr_Clear();
         
         if (name_space_name)
             new_func->m_namespace = object(name_space_name);
+
+        object module_name(
+          PyObject_IsInstance(name_space.ptr(), upcast<PyObject>(&PyModule_Type))
+          ? object(name_space.attr("__name__"))
+          : api::getattr(name_space, "__module__", str())
+        );
+        new_func->m_module = module_name;
     }
 
     if (PyObject_SetAttr(ns, name.ptr(), attribute.ptr()) < 0)
@@ -532,24 +569,7 @@ void function::add_to_namespace(
           "C++ signature:", f->signature(true)));
     }
     */
-    str _doc;
+    add_doc(attribute, doc);
-
-    if (docstring_options::show_py_signatures_)
-    {
-        _doc += str(const_cast<const char*>(detail::py_signature_tag));
-    }
-    if (doc != 0 && docstring_options::show_user_defined_)
-        _doc += doc;
-
-    if (docstring_options::show_cpp_signatures_)
-    {
-        _doc += str(const_cast<const char*>(detail::cpp_signature_tag));
-    }
-    if(_doc)
-    {    
-        object mutable_attribute(attribute);
-        mutable_attribute.attr("__doc__")= _doc;
-    }
 }
 
 BOOST_PYTHON_DECL void add_to_namespace(
@@ -564,6 +584,18 @@ BOOST_PYTHON_DECL void add_to_namespace(
     function::add_to_namespace(name_space, name, attribute, doc);
 }
 
+BOOST_PYTHON_DECL object const& add_doc(object const& attribute, char const* doc)
+{
+#if PY_VERSION_HEX >= 0x03000000
+    if (PyInstanceMethod_Check(attribute.ptr())) {
+#else
+    if (PyMethod_Check(attribute.ptr())) {
+#endif
+        return attribute;
+    }
+    return function::add_doc(attribute, doc);
+}
+
 
 namespace
 {
@@ -670,7 +702,7 @@ extern "C"
     static PyObject* function_get_module(PyObject* op, void*)
     {
         function* f = downcast<function>(op);
-        object const& ns = f->get_namespace();
+        object const& ns = f->get_module();
         if (!ns.is_none()) {
             return python::incref(ns.ptr());
         }

src/object/function_doc_signature.cpp

@@ -114,23 +114,47 @@ namespace boost { namespace python { namespace objects {
         return res;
     }
 
-    const  char * function_doc_signature_generator::py_type_str(const python::detail::signature_element &s)
+    static str get_qualname(const PyTypeObject *py_type)
+    {
+# if PY_VERSION_HEX >= 0x03030000
+        if ( py_type->tp_flags & Py_TPFLAGS_HEAPTYPE )
+            return str(handle<>(borrowed(((PyHeapTypeObject*)(py_type))->ht_qualname)));
+# endif
+        return str(py_type->tp_name);
+    }
+
+    str function_doc_signature_generator::py_type_str(const python::detail::signature_element &s, const object &current_module_name)
     {
         if (s.basename==std::string("void")){
             static const char * none = "None";
-            return none;
+            return str(none);
         }
 
         PyTypeObject const * py_type = s.pytype_f?s.pytype_f():0;
-        if ( py_type )
+        if ( py_type ) {
-            return  py_type->tp_name;
+            str name(get_qualname(py_type));
-        else{
+            if ( py_type->tp_flags & Py_TPFLAGS_HEAPTYPE ) {
+                // Qualify the type name if it is defined in a different module.
+                PyObject *type_module_name = PyDict_GetItemString(py_type->tp_dict, "__module__");
+                if (
+                    type_module_name
+                    && PyObject_RichCompareBool(
+                        type_module_name,
+                        current_module_name.ptr(),
+                        Py_NE
+                    ) != 0
+                ) {
+                    return str("%s.%s" % make_tuple(handle<>(borrowed(type_module_name)), name));
+                }
+            }
+            return name;
+        } else {
             static const char * object = "object";
-            return object;
+            return str(object);
         }
     }
 
-    str function_doc_signature_generator::parameter_string(py_function const &f, size_t n, object arg_names, bool cpp_types)
+    str function_doc_signature_generator::parameter_string(py_function const &f, size_t n, object arg_names, const object& current_module_name, bool cpp_types)
     {
         str param;
 
@@ -156,12 +180,12 @@ namespace boost { namespace python { namespace objects {
             {
                 object kv;
                 if ( arg_names && (kv = arg_names[n-1]) )
-                    param = str( " (%s)%s" % make_tuple(py_type_str(s[n]),kv[0]) );
+                    param = str( " (%s)%s" % make_tuple(py_type_str(s[n], current_module_name),kv[0]) );
                 else
-                    param = str(" (%s)%s%d" % make_tuple(py_type_str(s[n]),"arg", n) );
+                    param = str(" (%s)%s%d" % make_tuple(py_type_str(s[n], current_module_name),"arg", n) );
             }
             else //we are processing the return type
-                param = py_type_str(f.get_return_type());
+                param = py_type_str(f.get_return_type(), current_module_name);
         }
 
         //an argument - check for default value and append it
@@ -199,7 +223,7 @@ namespace boost { namespace python { namespace objects {
             str param;
 
             formal_params.append(
-                parameter_string(impl, n, f->m_arg_names, cpp_types)
+                parameter_string(impl, n, f->m_arg_names, f->get_module(), cpp_types)
                 );
 
             // find all the arguments with default values preceeding the arity-n_overloads

src/slice.cpp

@@ -34,4 +34,14 @@ slice_base::step() const
         ((PySliceObject*)this->ptr())->step));
 }
 
+static struct register_slice_pytype_ptr
+{
+    register_slice_pytype_ptr()
+    {
+        const_cast<converter::registration &>(
+            converter::registry::lookup(boost::python::type_id<boost::python::slice>())
+            ).m_class_object = &PySlice_Type;
+    }
+}register_slice_pytype_ptr_;
+
 } } } // !namespace boost::python::detail

test/Jamfile

@@ -2,14 +2,16 @@
 # Software License, Version 1.0. (See accompanying
 # file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 
+require-b2 5.0.1 ;
+import-search /boost/config/checks ;
+
 import python ;
 import os ;
-import ../../config/checks/config : requires ;
+import config : requires ;
 
 lib socket ;
 
-use-project /boost/python : ../build ;
+project
-project /boost/python/test 
   : requirements
     <toolset>gcc:<cxxflags>-Wextra
     <target-os>qnxnto:<library>socket
@@ -28,7 +30,7 @@ rule py-run ( sources * : input-file ? )
       : $(input-file)
       : #requirements
         <define>BOOST_PYTHON_SUPPRESS_REGISTRY_INITIALIZATION
- 
+
     ] ;
 }
 
@@ -52,6 +54,18 @@ rule require-windows ( properties * )
 
 if [ python.configured ]
 {
+alias base_deps : usage-requirements
+    <library>/boost/align//boost_align
+    <library>/boost/assert//boost_assert
+    <library>/boost/config//boost_config
+    <library>/boost/core//boost_core
+    <library>/boost/detail//boost_detail
+    <library>/boost/function//boost_function
+    <library>/boost/mpl//boost_mpl
+    <library>/boost/preprocessor//boost_preprocessor
+    <library>/boost/static_assert//boost_static_assert
+    <library>/boost/type_traits//boost_type_traits
+    ;
 test-suite python
   :
 
@@ -97,8 +111,8 @@ bpl-test crossmod_exception
 [ bpl-test andreas_beyer ]
 [ bpl-test wrapper_held_type ]
 
-[ bpl-test polymorphism2_auto_ptr 
+[ bpl-test polymorphism2_auto_ptr
-  : polymorphism2_auto_ptr.py polymorphism2.py polymorphism2_auto_ptr.cpp 
+  : polymorphism2_auto_ptr.py polymorphism2.py polymorphism2_auto_ptr.cpp
   : [ requires auto_ptr ]
 ]
 
@@ -119,7 +133,7 @@ bpl-test crossmod_exception
 [ bpl-test try : newtest.py m1.cpp m2.cpp ]
 [ bpl-test const_argument ]
 [ bpl-test keywords : keywords.cpp keywords_test.py ]
-   
+
 
 [ python-extension builtin_converters_ext : builtin_converters.cpp /boost/python//boost_python ]
 [ bpl-test builtin_converters : test_builtin_converters.py builtin_converters_ext ]
@@ -192,13 +206,13 @@ bpl-test crossmod_opaque
     # Whenever the cause for the failure of the polymorphism test is found
     # and fixed, this should be retested.
     <toolset>hp_cxx:<build>no ]
-      
+
 [ python-extension map_indexing_suite_ext
     : map_indexing_suite.cpp int_map_indexing_suite.cpp a_map_indexing_suite.cpp
     /boost/python//boost_python ]
-[ bpl-test  
+[ bpl-test
     map_indexing_suite : map_indexing_suite.py map_indexing_suite_ext ]
-      
+
 [ run import_.cpp /boost/python//boost_python $(PY) : : import_.py ]
 
 # if $(TEST_BIENSTMAN_NON_BUGS)
@@ -212,28 +226,29 @@ bpl-test crossmod_opaque
 
 # --- unit tests of library components ---
 
-[ compile indirect_traits_test.cpp ]
+[ compile indirect_traits_test.cpp : <use>base_deps ]
-[ run destroy_test.cpp ]
+[ run destroy_test.cpp : : : <use>base_deps ]
 [ py-run pointer_type_id_test.cpp ]
 [ py-run bases.cpp ]
-[ run if_else.cpp ]
+[ run if_else.cpp : : : <use>base_deps ]
 [ py-run pointee.cpp ]
-[ run result.cpp ]
+[ run result.cpp : : : <use>base_deps ]
 
-[ compile string_literal.cpp ]
+[ compile string_literal.cpp : <use>base_deps ]
 [ py-compile borrowed.cpp ]
 [ py-compile object_manager.cpp ]
 [ py-compile copy_ctor_mutates_rhs.cpp ]
 
 [ py-run upcast.cpp ]
-  
+
 [ py-compile select_holder.cpp ]
-  
+
-[ run select_from_python_test.cpp ../src/converter/type_id.cpp 
+[ run select_from_python_test.cpp ../src/converter/type_id.cpp
-  :   
+  :
   :
   : <define>BOOST_PYTHON_STATIC_LIB
     <use>$(PY)
+    <use>base_deps
 
 ]
 

test/map_indexing_suite.py

@@ -214,6 +214,13 @@ joel kimpo
 ...     i.data()
 4
 
+#####################################################################
+# Test signature...
+#####################################################################
+
+>>> AMap.__iter__.__doc__.strip().split("\\n")[0]
+'__iter__( (AMap)arg1) -> __main__.iterator :'
+
 #####################################################################
 # END....
 #####################################################################

test/nested.cpp

@@ -4,6 +4,8 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/python/module.hpp>
 #include <boost/python/class.hpp>
+#include <boost/python/def.hpp>
+#include <boost/python/enum.hpp>
 #include <boost/python/operators.hpp>
 #include <boost/python/scope.hpp>
 #include "test_class.hpp"
@@ -16,6 +18,8 @@
 typedef test_class<> X;
 typedef test_class<1> Y;
 
+enum color { red = 0, blue = 1, green = 2 };
+
 std::ostream& operator<<(std::ostream& s, X const& x)
 {
     return s << x.value();
@@ -26,11 +30,13 @@ std::ostream& operator<<(std::ostream& s, Y const& x)
     return s << x.value();
 }
 
+void test_function(const X& x, const Y& y) {}
 
 BOOST_PYTHON_MODULE(nested_ext)
 {
     using namespace boost::python;
 
+    {
     // Establish X as the current scope.
     scope x_class
         = class_<X>("X", init<int>())
@@ -42,6 +48,17 @@ BOOST_PYTHON_MODULE(nested_ext)
     class_<Y>("Y", init<int>())
         .def(str(self))
         ;
+
+    // so will the enum `color`
+    enum_<color>("color")
+        .value("red", red)
+        .value("green", green)
+        .value("blue", blue)
+        ;
+    }
+
+    // The generated docstring will use the fully-qualified name of Y
+    def("test_function", &test_function);
 }
 
 

test/nested.py

@@ -13,14 +13,35 @@
     >>> X.__name__
     'X'
     
-    >>> X.Y
+    >>> X.Y # doctest: +py2
     <class 'nested_ext.Y'>
+
+    >>> X.Y # doctest: +py3
+    <class 'nested_ext.X.Y'>
     
     >>> X.Y.__module__
     'nested_ext'
     
     >>> X.Y.__name__
     'Y'
+
+    >>> getattr(X.color, "__qualname__", None) # doctest: +py3
+    'X.color'
+
+    >>> repr(X.color.red) # doctest: +py2
+    'nested_ext.color.red'
+
+    >>> repr(X.color.red) # doctest: +py3
+    'nested_ext.X.color.red'
+
+    >>> repr(X.color(1)) # doctest: +py2
+    'nested_ext.color(1)'
+
+    >>> repr(X.color(1)) # doctest: +py3
+    'nested_ext.X.color(1)'
+
+    >>> test_function.__doc__.strip().split('\\n')[0] # doctest: +py3
+    'test_function( (X)arg1, (X.Y)arg2) -> None :'
     
 '''
 
@@ -30,7 +51,23 @@ def run(args = None):
 
     if args is not None:
         sys.argv = args
-    return doctest.testmod(sys.modules.get(__name__))
+
+    py2 = doctest.register_optionflag("py2")
+    py3 = doctest.register_optionflag("py3")
+
+    class ConditionalChecker(doctest.OutputChecker):
+        def check_output(self, want, got, optionflags):
+            if (optionflags & py3) and (sys.version_info[0] < 3):
+                return True
+            if (optionflags & py2) and (sys.version_info[0] >= 3):
+                return True
+            return doctest.OutputChecker.check_output(self, want, got, optionflags)
+
+    runner = doctest.DocTestRunner(ConditionalChecker())
+    for test in doctest.DocTestFinder().find(sys.modules.get(__name__)):
+        runner.run(test)
+
+    return doctest.TestResults(runner.failures, runner.tries)
     
 if __name__ == '__main__':
     print("running...")

test/properties.cpp

@@ -64,6 +64,7 @@ BOOST_PYTHON_MODULE(properties_ext)
     class_<X>("X", init<int>() )
         //defining read only property
         .add_property( "value_r", &X::get_value )
+        .add_property( "value_r_f", make_function(&X::get_value) )
         .add_property( "value_r_ds", &X::get_value, "value_r_ds is read-only")
         //defining read \ write property 
         .add_property( "value_rw", &X::get_value, &X::set_value )

test/properties.py

@@ -20,6 +20,9 @@ value read only
 >>> x1.value_r
 1
 
+>>> x1.value_r_f
+1
+
 value read - write
 >>> x1.value_rw
 1
@@ -84,8 +87,27 @@ after creating second intstance of X instances count is 2
 
 >>> assert properties.X.value_rw_ds.__doc__ == "value_rw_ds is read-write"
 
+>>> properties.X.value_r_f.fget.__doc__.strip().split("\\n")[0]
+'None( (properties_ext.X)arg1) -> int :'
+
+>>> properties.X.value_rw_ds.fget.__doc__.strip().split("\\n")[0]
+'None( (properties_ext.X)arg1) -> int :'
+
+>>> properties.X.value_rw_ds.fset.__doc__.strip().split("\\n")[0]
+'None( (properties_ext.X)arg1, (int)arg2) -> None :'
+
+>>> properties.X.value_rw_ds.fget.__doc__.strip().split("\\n")[0]
+'None( (properties_ext.X)arg1) -> int :'
+
+>>> properties.X.value_direct.fset.__doc__.strip().split("\\n")[0]
+'None( (properties_ext.X)arg1, (int)arg2) -> None :'
+
+>>> properties.X.value_direct.fget.__doc__.strip().split("\\n")[0]
+'None( (properties_ext.X)arg1) -> int :'
 """
 
+# FIXME: cases to cover: pointer-to-member, preconstructed function
+
 #import sys; sys.path.append(r'P:\Actimize4.0\smart_const\py_smart_const___Win32_Debug')
 import properties_ext as properties
 

test/slice.py

@@ -33,6 +33,8 @@ test passed
 0
 >>> check_slice_get_indices( slice( -2, -5, -2))
 6
+>>> check_slice_get_indices.__doc__.strip().split('\\n')[0]
+'check_slice_get_indices( (slice)arg1) -> int :'
 """
 
 # Performs an affirmative and negative argument resolution check.