Don't upgrade pip.

.github/get-py-env.py

@@ -1,65 +0,0 @@
-#!/usr/bin/env python3
-#
-# Determine info about the Python install and write shell code to stdout, to
-# set env variables.  This will set the variables PY_LDFLAGS, PY_CFLAGS and
-# PY_INC_PATH.
-#
-# The python3-config tool is used as the source of this info. In theory we
-# could use sysconfig as well but the setup-python action from github appears
-# to patch python3-config but not patch the sysconfig info.
-#
-# Usage:
-#   eval $(python3 get-py-env.py)
-
-import os
-import re
-import subprocess
-
-
-def get_output(cmd):
-    rv = subprocess.run(
-        cmd,
-        capture_output=True,  # Capture stdout and stderr
-        text=True,  # Decode output as text (UTF-8)
-        check=True,  # Raise an error if the command fails
-    )
-    return rv.stdout
-
-
-def extract_flags(cmd, prefix):
-    flags = []
-    for part in get_output(cmd).split():
-        part = part.strip()
-        if part.startswith(prefix):
-            flags.append(part)
-    return ' '.join(flags)
-
-
-def find_python_h():
-    """Find the include path that has Python.h contained inside.
-    We could use INCLUDEPY from sysconfig but github patches
-    python3-config but not the sysconfig info (after moving the
-    install).
-    """
-    c_flags = extract_flags(['python3-config', '--cflags'], '-I')
-    for part in c_flags.split():
-        m = re.search(r'-I(\S+)', part)
-        if not m:
-            continue
-        inc_path = m.group(1)
-        if os.path.exists(os.path.join(inc_path, 'Python.h')):
-            return inc_path
-    raise SystemExit('cannot find Python.h')
-
-
-def main():
-    ld_flags = extract_flags(['python3-config', '--ldflags'], '-L')
-    c_flags = extract_flags(['python3-config', '--cflags'], '-I')
-    include_path = find_python_h()
-    print(f'PY_LDFLAGS="{ld_flags}"')
-    print(f'PY_CFLAGS="{c_flags}"')
-    print(f'PY_INC_PATH="{include_path}"')
-
-
-if __name__ == '__main__':
-    main()

.github/run-faber.sh

@@ -1,46 +0,0 @@
-#!/bin/sh
-
-set -eu
-
-echo "cxx version: $CXX $($CXX --version)"
-echo "cxx std: $CXX_STD"
-echo "python3 path: $(which python3)"
-echo "python3 version: $(python3 --version)"
-
-if ! which faber > /dev/null; then
-    echo "Installing faber..."
-    python3 -m pip install --upgrade pip
-    python3 -m pip install -U faber
-fi
-echo "faber version: $(faber -v)"
-
-# find and set PY_LDFLAGS and PY_INC_PATH
-eval $(python3 .github/get-py-env.py)
-
-echo "PY_INC_PATH=$PY_INC_PATH"
-echo "PY_LDFLAGS=$PY_LDFLAGS"
-
-case $(python3-config --abiflags) in
-    *t*)
-        # When running with free-threaded, we always want to disable the GIL
-        # even for extensions without the mod_gil_not_used() flag
-        export PYTHON_GIL=0
-        ;;
-esac
-
-# this could be set by LD_LIBRARY_PATH but faber overrides it
-prefix=$(python3-config --prefix)
-echo "${prefix}/lib" > /etc/ld.so.conf.d/boost-ci.conf && ldconfig
-
-sed -e "s/\$PYTHON/python3/g" .ci/faber > $HOME/.faber
-
-faber \
-  --with-boost-include=${BOOST_PY_DEPS} \
-  --builddir=build \
-  cxx.name="${CXX}" \
-  cxxflags="-std=${CXX_STD}" \
-  cppflags="-std=${CXX_STD}" \
-  include="${PY_INC_PATH}" \
-  ldflags="${PY_LDFLAGS}" \
-  -j`nproc` \
-  "$@"

.github/workflows/deploy-documentation.yml

@@ -17,7 +17,7 @@ jobs:
           python3-sphinx \
           xsltproc \
           docbook-xsl
-        sudo python3 -m pip install --upgrade pip
+        #sudo python3 -m pip install --upgrade pip
         sudo python3 -m pip install faber
     - name: build
       run: |

.github/workflows/test-ubuntu.yml

@@ -1,10 +1,6 @@
-# Test on Ubuntu with various compiler and language standard versions.
 name: Test Ubuntu
 
-on:
+on:  [push, pull_request]
-  push:
-  pull_request:
-  workflow_dispatch:
 
 jobs:
   build:
@@ -13,59 +9,31 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        python-version: ['3.14']
+        python: [python, python3]
         cxx: [g++, clang++]
-        std: [c++11, c++14, c++17]
+        std: [c++98, c++11, c++14, c++17]
         include:
-          - python-version: '2.7'
+          # Add the appropriate docker image for each compiler.
-            cxx: g++
+          # The images from teeks99/boost-python-test already have boost::python
-            std: c++11
+          # pre-reqs installed, see:
-          - python-version: '3.10'
+          # https://github.com/teeks99/boost-python-test-docker
-            cxx: g++
+          - cxx: clang++
-            std: c++17
+            docker-img: teeks99/boost-python-test:clang-12_1.76.0
-          - python-version: '3.11'
+          - cxx: g++
-            cxx: g++
+            docker-img: teeks99/boost-python-test:gcc-10_1.76.0
-            std: c++17
-          - python-version: '3.12'
-            cxx: g++
-            std: c++17
-          - python-version: '3.13'
-            cxx: g++
-            std: c++17
-          # Also test with free-threaded build of Python
-          - python-version: '3.14t'
-            cxx: clang++
-            std: c++17
 
     container:
-      # Add the appropriate docker image for the compiler.
+      image: ${{ matrix.docker-img }}
-      # The images from teeks99/boost-python-test already have boost::python
-      # pre-reqs installed, see:
-      # https://github.com/teeks99/boost-python-test-docker
-      image: ${{ matrix.cxx == 'g++' &&
-        'teeks99/boost-python-test:gcc-15_1.89.0' ||
-        'teeks99/boost-python-test:clang-21_1.89.0' }}
 
     steps:
     - uses: actions/checkout@v5
-    - name: setup python
+
-      if: "${{ matrix.python-version  != '2.7' }}"
+    - name: build
-      uses: actions/setup-python@v5
-      with:
-        python-version: ${{ matrix.python-version }}
-    - name: setup prerequisites
       run: |
-        # Warning: this is not necessarily the same Python version as the one configured above !
+        ${{ matrix.python }} --version
-        python3 -m pip install -U faber --break-system-packages
-        echo "CXX=${{ matrix.cxx }}" >> "$GITHUB_ENV"
-        echo "CXX_STD=${{ matrix.std }}" >> "$GITHUB_ENV"
-    - name: build-py2
-      if: "${{ matrix.python-version  == '2.7' }}"
-      run: |
-        python --version
         ${{ matrix.cxx }} --version
         faber -v
-        sed -e "s/\$PYTHON/python/g" .ci/faber > ~/.faber
+        sed -e "s/\$PYTHON/${{ matrix.python }}/g" .ci/faber > ~/.faber
         faber \
           --with-boost-include=${BOOST_PY_DEPS} \
           --builddir=build \
@@ -73,12 +41,7 @@ jobs:
           cxxflags=-std=${{ matrix.std }} \
           cppflags=-std=${{ matrix.std }} \
           -j`nproc`
-    - name: build-py3
+    - name: test
-      if: "${{ matrix.python-version  != '2.7' }}"
-      run: |
-        .github/run-faber.sh
-    - name: test-py2
-      if: "${{ matrix.python-version  == '2.7' }}"
       run: |
         faber \
           --with-boost-include=${BOOST_PY_DEPS} \
@@ -88,7 +51,3 @@ jobs:
           cppflags=-std=${{ matrix.std }} \
           -j`nproc` \
           test.report
-    - name: test-py3
-      if: "${{ matrix.python-version  != '2.7' }}"
-      run: |
-        .github/run-faber.sh test.report

doc/numpy/_templates/layout.html

@@ -90,7 +90,7 @@
       <tr>
         <td valign="top" width="300">
           <h3><a href="{{ pathto('index') }}"><img 
-          alt="C++ Boost" src="{{ pathto('_static/bpl.png', 1) }}" border="0"></a></h3>
+          alt="C++ Boost" src="{{ pathto('_static/' + logo, 1) }}" border="0"></a></h3>
         </td>
 
         <td >

doc/tutorial.qbk

@@ -117,7 +117,7 @@ platforms. The complete list of Bjam executables can be found
 [h2 Let's Jam!]
 __jam__
 
-[@../example/Jamroot Here] is our minimalist Jamroot
+[@../../../../example/tutorial/Jamroot Here] is our minimalist Jamroot
 file. Simply copy the file and tweak [^use-project boost] to where your
 boost root directory is and you're OK.
 

fabscript

@@ -16,7 +16,6 @@ from faber.config.try_run import try_run
 
 features += include('include')
 features += define('BOOST_ALL_NO_LIB')  # disable auto-linking
-features += define('BOOST_NO_AUTO_PTR')
 boost_include = options.get_with('boost-include')
 if boost_include:
     features += include(boost_include)

include/boost/python/detail/is_auto_ptr.hpp

@@ -8,8 +8,6 @@
 # ifndef BOOST_NO_AUTO_PTR
 #  include <boost/python/detail/is_xxx.hpp>
 #  include <memory>
-# else
-#  include <boost/mpl/bool.hpp>
 # endif
 
 namespace boost { namespace python { namespace detail { 

include/boost/python/detail/pymutex.hpp

@@ -1,103 +0,0 @@
-// Copyright 2025 Boost.Python Contributors
-// 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)
-
-#ifndef BOOST_PYTHON_DETAIL_PYMUTEX_HPP
-#define BOOST_PYTHON_DETAIL_PYMUTEX_HPP
-
-#include <boost/python/detail/prefix.hpp>
-#ifdef Py_GIL_DISABLED
-// needed for pymutex wrapper
-#include <atomic>
-#include <cstddef>
-#endif
-
-namespace boost { namespace python { namespace detail {
-
-#ifdef Py_GIL_DISABLED
-
-// Re-entrant wrapper around PyMutex for free-threaded Python
-// Similar to _PyRecursiveMutex or threading.RLock
-class pymutex {
-    PyMutex m_mutex;
-    std::atomic<unsigned long> m_owner;
-    std::size_t m_level;
-
-public:
-    pymutex() : m_mutex({}), m_owner(0), m_level(0) {}
-
-    // Non-copyable, non-movable
-    pymutex(const pymutex&) = delete;
-    pymutex& operator=(const pymutex&) = delete;
-
-    void lock() {
-        unsigned long thread = PyThread_get_thread_ident();
-        if (m_owner.load(std::memory_order_relaxed) == thread) {
-            m_level++;
-            return;
-        }
-        PyMutex_Lock(&m_mutex);
-        m_owner.store(thread, std::memory_order_relaxed);
-        // m_level should be 0 when we acquire the lock
-    }
-
-    void unlock() {
-        unsigned long thread = PyThread_get_thread_ident();
-        // Verify current thread owns the lock
-        if (m_owner.load(std::memory_order_relaxed) != thread) {
-            // This should never happen - programming error
-            return;
-        }
-        if (m_level > 0) {
-            m_level--;
-            return;
-        }
-        m_owner.store(0, std::memory_order_relaxed);
-        PyMutex_Unlock(&m_mutex);
-    }
-
-    bool is_locked_by_current_thread() const {
-        unsigned long thread = PyThread_get_thread_ident();
-        return m_owner.load(std::memory_order_relaxed) == thread;
-    }
-};
-
-
-// RAII lock guard for pymutex
-class pymutex_guard {
-    pymutex& m_mutex;
-
-public:
-    explicit pymutex_guard(pymutex& mutex) : m_mutex(mutex) {
-        m_mutex.lock();
-    }
-
-    ~pymutex_guard() {
-        m_mutex.unlock();
-    }
-
-    // Non-copyable, non-movable
-    pymutex_guard(const pymutex_guard&) = delete;
-    pymutex_guard& operator=(const pymutex_guard&) = delete;
-};
-
-// Global mutex for protecting all Boost.Python internal state
-// Similar to pybind11's internals.mutex
-BOOST_PYTHON_DECL pymutex& get_global_mutex();
-
-// Macro for acquiring the global lock
-// Similar to pybind11's PYBIND11_LOCK_INTERNALS
-#define BOOST_PYTHON_LOCK_STATE() \
-    ::boost::python::detail::pymutex_guard lock(::boost::python::detail::get_global_mutex())
-
-#else
-
-// No-op macro when not in free-threaded mode
-#define BOOST_PYTHON_LOCK_STATE()
-
-#endif // Py_GIL_DISABLED
-
-}}} // namespace boost::python::detail
-
-#endif // BOOST_PYTHON_DETAIL_PYMUTEX_HPP

include/boost/python/module_init.hpp

@@ -11,41 +11,11 @@
 
 # ifndef BOOST_PYTHON_MODULE_INIT
 
-namespace boost { namespace python {
+namespace boost { namespace python { namespace detail {
-
-#ifdef HAS_CXX11
-// Use to activate the Py_MOD_GIL_NOT_USED flag.
-class mod_gil_not_used {
-public:
-    explicit mod_gil_not_used(bool flag = true) : flag_(flag) {}
-    bool flag() const { return flag_; }
-
-private:
-    bool flag_;
-};
-
-namespace detail {
-
-inline bool gil_not_used_option() { return false; }
-template <typename F, typename... O>
-bool gil_not_used_option(F &&, O &&...o);
-template <typename... O>
-inline bool gil_not_used_option(mod_gil_not_used f, O &&...o) {
-    return f.flag() || gil_not_used_option(o...);
-}
-template <typename F, typename... O>
-inline bool gil_not_used_option(F &&, O &&...o) {
-    return gil_not_used_option(o...);
-}
-
-}
-#endif // HAS_CXX11
-
-namespace detail {
 
 #  if PY_VERSION_HEX >= 0x03000000
 
-BOOST_PYTHON_DECL PyObject* init_module(PyModuleDef&, void(*)(), bool gil_not_used = false);
+BOOST_PYTHON_DECL PyObject* init_module(PyModuleDef&, void(*)());
 
 #else
 
@@ -57,37 +27,7 @@ BOOST_PYTHON_DECL PyObject* init_module(char const* name, void(*)());
 
 #  if PY_VERSION_HEX >= 0x03000000
 
-#   ifdef HAS_CXX11
+#   define _BOOST_PYTHON_MODULE_INIT(name) \
-#    define _BOOST_PYTHON_MODULE_INIT(name, ...) \
-  PyObject* BOOST_PP_CAT(PyInit_, name)()  \
-  { \
-    static PyModuleDef_Base initial_m_base = { \
-        PyObject_HEAD_INIT(NULL) \
-        0, /* m_init */ \
-        0, /* m_index */ \
-        0 /* m_copy */ };  \
-    static PyMethodDef initial_methods[] = { { 0, 0, 0, 0 } }; \
- \
-    static struct PyModuleDef moduledef = { \
-        initial_m_base, \
-        BOOST_PP_STRINGIZE(name), \
-        0, /* m_doc */ \
-        -1, /* m_size */ \
-        initial_methods, \
-        0,  /* m_reload */ \
-        0, /* m_traverse */ \
-        0, /* m_clear */ \
-        0,  /* m_free */ \
-    }; \
- \
-    return boost::python::detail::init_module( \
-        moduledef, BOOST_PP_CAT(init_module_, name), \
-        boost::python::detail::gil_not_used_option(__VA_ARGS__) ); \
-  } \
-  void BOOST_PP_CAT(init_module_, name)()
-
-#   else // !HAS_CXX11
-#    define _BOOST_PYTHON_MODULE_INIT(name) \
   PyObject* BOOST_PP_CAT(PyInit_, name)()  \
   { \
     static PyModuleDef_Base initial_m_base = { \
@@ -113,7 +53,6 @@ BOOST_PYTHON_DECL PyObject* init_module(char const* name, void(*)());
         moduledef, BOOST_PP_CAT(init_module_, name) ); \
   } \
   void BOOST_PP_CAT(init_module_, name)()
-#   endif // HAS_CXX11
 
 #  else
 
@@ -127,15 +66,9 @@ BOOST_PYTHON_DECL PyObject* init_module(char const* name, void(*)());
 
 #  endif
 
-#  if defined(HAS_CXX11) && (PY_VERSION_HEX >= 0x03000000)
+#  define BOOST_PYTHON_MODULE_INIT(name)                       \
-#   define BOOST_PYTHON_MODULE_INIT(name, ...)                  \
-  void BOOST_PP_CAT(init_module_,name)();                      \
-extern "C" BOOST_SYMBOL_EXPORT _BOOST_PYTHON_MODULE_INIT(name, __VA_ARGS__)
-#  else
-#   define BOOST_PYTHON_MODULE_INIT(name)                       \
   void BOOST_PP_CAT(init_module_,name)();                      \
 extern "C" BOOST_SYMBOL_EXPORT _BOOST_PYTHON_MODULE_INIT(name)
-#  endif // HAS_CXX11 && Python 3
 
 # endif
 

include/boost/python/numpy/dtype.hpp

@@ -17,7 +17,6 @@
 #include <boost/python/numpy/numpy_object_mgr_traits.hpp>
 #include <boost/mpl/for_each.hpp>
 #include <boost/python/detail/type_traits.hpp>
-#include <boost/type_traits/is_unsigned.hpp>
 
 namespace boost { namespace python { namespace numpy {
 

include/boost/python/object_core.hpp

@@ -419,16 +419,6 @@ inline api::object_base& api::object_base::operator=(api::object_base const& rhs
 
 inline api::object_base::~object_base()
 {
-#ifdef Py_GIL_DISABLED
-    // This is a not very elegant fix for a problem that occurs with the
-    // free-threaded build of Python.  If this is called when the interpreter
-    // has already been finalized, the thread-state can be null.  Unlike the
-    // GIL-enabled build, Py_DECREF() requires a valid thread-state.  This
-    // causes a memory leak, rather than crash, which seems preferable.
-    if (PyThreadState_GetUnchecked() == NULL) {
-        return;
-    }
-#endif
     assert( Py_REFCNT(m_ptr) > 0 );
     Py_DECREF(m_ptr);
 }

src/converter/from_python.cpp

@@ -11,7 +11,6 @@
 
 #include <boost/python/handle.hpp>
 #include <boost/python/detail/raw_pyobject.hpp>
-#include <boost/python/detail/pymutex.hpp>
 #include <boost/python/cast.hpp>
 
 #include <vector>
@@ -146,8 +145,6 @@ namespace
 
   inline bool visit(rvalue_from_python_chain const* chain)
   {
-      BOOST_PYTHON_LOCK_STATE();
-
       visited_t::iterator const p = std::lower_bound(visited.begin(), visited.end(), chain);
       if (p != visited.end() && *p == chain)
           return false;
@@ -163,8 +160,6 @@ namespace
       
       ~unvisit()
       {
-          BOOST_PYTHON_LOCK_STATE();
-
           visited_t::iterator const p = std::lower_bound(visited.begin(), visited.end(), chain);
           assert(p != visited.end());
           visited.erase(p);

src/converter/registry.cpp

@@ -5,7 +5,6 @@
 #include <boost/python/converter/registry.hpp>
 #include <boost/python/converter/registrations.hpp>
 #include <boost/python/converter/builtin_converters.hpp>
-#include <boost/python/detail/pymutex.hpp>
 
 #include <set>
 #include <stdexcept>
@@ -182,8 +181,6 @@ namespace // <unnamed>
 
   entry* get(type_info type, bool is_shared_ptr = false)
   {
-      BOOST_PYTHON_LOCK_STATE();
-
 #  ifdef BOOST_PYTHON_TRACE_REGISTRY
       registry_t::iterator p = entries().find(entry(type));
       
@@ -296,8 +293,6 @@ namespace registry
 
   registration const* query(type_info type)
   {
-      BOOST_PYTHON_LOCK_STATE();
-
       registry_t::iterator p = entries().find(entry(type));
 #  ifdef BOOST_PYTHON_TRACE_REGISTRY
       std::cout << "querying " << type

src/converter/type_id.cpp

@@ -5,7 +5,6 @@
 
 #include <boost/python/type_id.hpp>
 #include <boost/python/detail/decorated_type_id.hpp>
-#include <boost/python/detail/pymutex.hpp>
 #include <utility>
 #include <vector>
 #include <algorithm>
@@ -93,7 +92,6 @@ namespace
 
 bool cxxabi_cxa_demangle_is_broken()
 {
-    BOOST_PYTHON_LOCK_STATE();
     static bool was_tested = false;
     static bool is_broken = false;
     if (!was_tested) {
@@ -111,8 +109,6 @@ namespace detail
 {
   BOOST_PYTHON_DECL char const* gcc_demangle(char const* mangled)
   {
-      BOOST_PYTHON_LOCK_STATE();
-
       typedef std::vector<
           std::pair<char const*, char const*>
       > mangling_map;

src/dict.cpp

@@ -68,16 +68,8 @@ object dict_base::get(object_cref k) const
 {
     if (check_exact(this))
     {
-#ifdef Py_GIL_DISABLED
-        PyObject* result;
-        if (PyDict_GetItemRef(this->ptr(),k.ptr(),&result) < 0) {
-            throw_error_already_set();
-        }
-        return object(detail::new_reference(result ? result : Py_None));
-#else
         PyObject* result = PyDict_GetItem(this->ptr(),k.ptr());
         return object(detail::borrowed_reference(result ? result : Py_None));
-#endif
     }
     else
     {

src/errors.cpp

@@ -10,21 +10,9 @@
 #include <boost/python/errors.hpp>
 #include <boost/cast.hpp>
 #include <boost/python/detail/exception_handler.hpp>
-#include <boost/python/detail/pymutex.hpp>
 
 namespace boost { namespace python {
 
-#ifdef Py_GIL_DISABLED
-namespace detail {
-    // Global mutex for protecting all Boost.Python internal state
-    pymutex& get_global_mutex()
-    {
-        static pymutex mutex;
-        return mutex;
-    }
-}
-#endif
-
 error_already_set::~error_already_set() {}
 
 // IMPORTANT: this function may only be called from within a catch block!
@@ -32,13 +20,8 @@ BOOST_PYTHON_DECL bool handle_exception_impl(function0<void> f)
 {
     try
     {
-        detail::exception_handler* handler_chain = nullptr;
+        if (detail::exception_handler::chain)
-        {
+            return detail::exception_handler::chain->handle(f);
-            BOOST_PYTHON_LOCK_STATE();
-            handler_chain = detail::exception_handler::chain;
-        }
-        if (handler_chain)
-            return handler_chain->handle(f);
         f();
         return false;
     }
@@ -97,7 +80,6 @@ exception_handler::exception_handler(handler_function const& impl)
     : m_impl(impl)
     , m_next(0)
 {
-    BOOST_PYTHON_LOCK_STATE();
     if (chain != 0)
         tail->m_next = this;
     else

src/module.cpp

@@ -38,17 +38,10 @@ BOOST_PYTHON_DECL void scope_setattr_doc(char const* name, object const& x, char
 
 #if PY_VERSION_HEX >= 0x03000000
 
-BOOST_PYTHON_DECL PyObject* init_module(PyModuleDef& moduledef,
+BOOST_PYTHON_DECL PyObject* init_module(PyModuleDef& moduledef, void(*init_function)())
-    void(*init_function)(), bool gil_not_used)
 {
-    PyObject *mod = PyModule_Create(&moduledef);
-#ifdef Py_GIL_DISABLED
-    if (mod != NULL && gil_not_used) {
-        PyUnstable_Module_SetGIL(mod, Py_MOD_GIL_NOT_USED);
-    }
-#endif
     return init_module_in_scope(
-        mod,
+        PyModule_Create(&moduledef),
         init_function);
 }
 

src/object/function_doc_signature.cpp

@@ -135,15 +135,7 @@ namespace boost { namespace python { namespace objects {
             str name(get_qualname(py_type));
             if ( py_type->tp_flags & Py_TPFLAGS_HEAPTYPE ) {
                 // Qualify the type name if it is defined in a different module.
-                PyObject *type_module_name;
+                PyObject *type_module_name = PyDict_GetItemString(py_type->tp_dict, "__module__");
-#if PY_VERSION_HEX >= 0x030D0000
-                if (PyDict_GetItemStringRef(py_type->tp_dict, "__module__", &type_module_name) < 0) {
-                    throw_error_already_set();
-                }
-#else
-                type_module_name = PyDict_GetItemString(py_type->tp_dict, "__module__");
-                Py_XINCREF(type_module_name);
-#endif
                 if (
                     type_module_name
                     && PyObject_RichCompareBool(
@@ -152,11 +144,8 @@ namespace boost { namespace python { namespace objects {
                         Py_NE
                     ) != 0
                 ) {
-                    str result = str("%s.%s" % make_tuple(handle<>(type_module_name), name));
+                    return str("%s.%s" % make_tuple(handle<>(borrowed(type_module_name)), name));
-                    return result;
                 }
-                // Clean up the strong reference if we didn't use it
-                Py_XDECREF(type_module_name);
             }
             return name;
         } else {

src/object/inheritance.cpp

@@ -4,7 +4,6 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 #include <boost/python/object/inheritance.hpp>
 #include <boost/python/type_id.hpp>
-#include <boost/python/detail/pymutex.hpp>
 #include <boost/graph/breadth_first_search.hpp>
 #if _MSC_FULL_VER >= 13102171 && _MSC_FULL_VER <= 13102179
 # include <boost/graph/reverse_graph.hpp>
@@ -391,8 +390,6 @@ namespace
 
   inline void* convert_type(void* const p, class_id src_t, class_id dst_t, bool polymorphic)
   {
-      BOOST_PYTHON_LOCK_STATE();
-
       // Quickly rule out unregistered types
       index_entry* src_p = seek_type(src_t);
       if (src_p == 0)
@@ -455,8 +452,6 @@ BOOST_PYTHON_DECL void* find_static_type(void* p, class_id src_t, class_id dst_t
 BOOST_PYTHON_DECL void add_cast(
     class_id src_t, class_id dst_t, cast_function cast, bool is_downcast)
 {
-    BOOST_PYTHON_LOCK_STATE();
-
     // adding an edge will invalidate any record of unreachability in
     // the cache.
     static std::size_t expected_cache_len = 0;
@@ -495,7 +490,6 @@ BOOST_PYTHON_DECL void add_cast(
 BOOST_PYTHON_DECL void register_dynamic_id_aux(
     class_id static_id, dynamic_id_function get_dynamic_id)
 {
-    BOOST_PYTHON_LOCK_STATE();
     tuples::get<kdynamic_id>(*demand_type(static_id)) = get_dynamic_id;
 }
 

src/wrapper.cpp

@@ -21,7 +21,7 @@ namespace detail
                           this->m_self, const_cast<char*>(name))))
           )
           {
-              PyObject* class_f = 0;
+              PyObject* borrowed_f = 0;
             
               if (
                   PyMethod_Check(m.get())
@@ -29,20 +29,12 @@ namespace detail
                   && class_object->tp_dict != 0
               )
               {
-#if PY_VERSION_HEX >= 0x030D0000
+                  borrowed_f = ::PyDict_GetItemString(
-                  if (::PyDict_GetItemStringRef(
-                      class_object->tp_dict, const_cast<char*>(name), &class_f) < 0) {
-                      throw_error_already_set();
-                  }
-#else
-                  class_f = ::PyDict_GetItemString(
                       class_object->tp_dict, const_cast<char*>(name));
-                  Py_XINCREF(class_f);
+
-#endif
+
               }
-              bool is_override = (class_f != PyMethod_GET_FUNCTION(m.get()));
+              if (borrowed_f != PyMethod_GET_FUNCTION(m.get()))
-              Py_XDECREF(class_f);
-              if (is_override)
                   return override(m);
           }
       }

test/back_reference.cpp

@@ -99,7 +99,7 @@ BOOST_PYTHON_MODULE(back_reference_ext)
         .def("set", &Y::set)
         ;
 
-    class_<Z,std::shared_ptr<Z> >("Z", init<int>())
+    class_<Z,std::auto_ptr<Z> >("Z", init<int>())
         .def("value", &Z::value)
         .def("set", &Z::set)
         ;

test/copy_ctor_mutates_rhs.cpp

@@ -9,13 +9,14 @@
 
 struct foo
 {
-    operator std::shared_ptr<int>&() const;
+    operator std::auto_ptr<int>&() const;
 };
 
 int main()
 {
     using namespace boost::python::detail;
     BOOST_STATIC_ASSERT(!copy_ctor_mutates_rhs<int>::value);
+    BOOST_STATIC_ASSERT(copy_ctor_mutates_rhs<std::auto_ptr<int> >::value);
     BOOST_STATIC_ASSERT(!copy_ctor_mutates_rhs<std::string>::value);
     BOOST_STATIC_ASSERT(!copy_ctor_mutates_rhs<foo>::value);
     return 0;

test/fabscript

@@ -68,7 +68,6 @@ for t in [('injected',),
           ('raw_ctor',),
           ('exception_translator',),
           ('module_init_exception',),
-          ('module_nogil',),
           ('test_enum', ['enum_ext']),
           ('test_cltree', ['cltree']),
           ('newtest', ['m1', 'm2']),
@@ -119,10 +118,10 @@ for t in [('injected',),
 
 tests.append(extension_test('shared_ptr',
                             condition=set.define.contains('HAS_CXX11')))
-#tests.append(extension_test('polymorphism2_auto_ptr',
+tests.append(extension_test('polymorphism2_auto_ptr',
-#                            condition=set.define.contains('HAS_CXX11').not_()))
+                            condition=set.define.contains('HAS_CXX11').not_()))
-#tests.append(extension_test('auto_ptr',
+tests.append(extension_test('auto_ptr',
-#                            condition=set.define.contains('HAS_CXX11')))
+                            condition=set.define.contains('HAS_CXX11')))
 
 import_ = binary('import_', ['import_.cpp', src.bpl], features=features|python_libs)
 if platform.os == 'Windows':

test/injected.cpp

@@ -17,7 +17,7 @@ typedef test_class<> X;
 
 X* empty() { return new X(1000); }
 
-std::shared_ptr<X> sum(int a, int b) { return std::shared_ptr<X>(new X(a+b)); }
+std::auto_ptr<X> sum(int a, int b) { return std::auto_ptr<X>(new X(a+b)); }
 
 boost::shared_ptr<X> product(int a, int b, int c)
 {

test/module_nogil.cpp

@@ -1,25 +0,0 @@
-// Test for BOOST_PYTHON_MODULE with optional mod_gil_not_used argument
-
-#include <boost/python/module.hpp>
-#include <boost/python/def.hpp>
-
-// Simple function to export
-int get_value() {
-    return 1234;
-}
-
-#if defined(HAS_CXX11) && (PY_VERSION_HEX >= 0x03000000)
-// C++11 build with Python 3: test with mod_gil_not_used option
-BOOST_PYTHON_MODULE(module_nogil_ext, boost::python::mod_gil_not_used())
-{
-    using namespace boost::python;
-    def("get_value", get_value);
-}
-#else
-// C++98 build or Python 2: test without optional arguments
-BOOST_PYTHON_MODULE(module_nogil_ext)
-{
-    using namespace boost::python;
-    def("get_value", get_value);
-}
-#endif

test/module_nogil.py

@@ -1,29 +0,0 @@
-"""
->>> from module_nogil_ext import *
->>> get_value()
-1234
->>> import sys, sysconfig
->>> Py_GIL_DISABLED = bool(sysconfig.get_config_var('Py_GIL_DISABLED'))
->>> if Py_GIL_DISABLED and sys._is_gil_enabled():
-...    print('GIL is enabled and should not be')
-... else:
-...    print('okay')
-okay
-"""
-
-from __future__ import print_function
-
-def run(args = None):
-    import sys
-    import doctest
-
-    if args is not None:
-        sys.argv = args
-    return doctest.testmod(sys.modules.get(__name__))
-
-if __name__ == '__main__':
-    print("running...")
-    import sys
-    status = run()[0]
-    if (status == 0): print("Done.")
-    sys.exit(status)

test/operators_wrapper.cpp

@@ -36,7 +36,7 @@ BOOST_PYTHON_MODULE( operators_wrapper_ext )
         ;
     
     scope().attr("v") = vector();
-    std::shared_ptr<vector> dp(new dvector);
+    std::auto_ptr<vector> dp(new dvector);
-    register_ptr_to_python< std::shared_ptr<vector> >();
+    register_ptr_to_python< std::auto_ptr<vector> >();
     scope().attr("d") = dp;
 }

test/select_holder.cpp

@@ -62,14 +62,14 @@ int test_main(int, char * [])
     assert_holder<Base,Derived
         ,value_holder_back_reference<Base,Derived> >();
 
-    assert_holder<Base,std::unique_ptr<Base>
+    assert_holder<Base,std::auto_ptr<Base>
-        ,pointer_holder<std::unique_ptr<Base>,Base> >();
+        ,pointer_holder<std::auto_ptr<Base>,Base> >();
     
-    assert_holder<Base,std::unique_ptr<Derived>
+    assert_holder<Base,std::auto_ptr<Derived>
-        ,pointer_holder_back_reference<std::unique_ptr<Derived>,Base> >();
+        ,pointer_holder_back_reference<std::auto_ptr<Derived>,Base> >();
 
-    assert_holder<BR,std::unique_ptr<BR>
+    assert_holder<BR,std::auto_ptr<BR>
-        ,pointer_holder_back_reference<std::unique_ptr<BR>,BR> > ();
+        ,pointer_holder_back_reference<std::auto_ptr<BR>,BR> > ();
 
     return 0;
 }

test/shared_ptr.py

@@ -38,7 +38,7 @@
 12
 >>> try: modify(p)
 ... except TypeError: pass
-... else: print('expected a TypeError')
+... else: 'print(expected a TypeError)'
 >>> look(None)
 -1
 >>> store(p)
@@ -61,7 +61,7 @@ bye
 13
 >>> try: modify(z)
 ... except TypeError: pass
-... else: print('expected a TypeError')
+... else: 'print(expected a TypeError)'
 
 >>> Z.get() # should be None
 >>> store(z)
@@ -84,7 +84,7 @@ bye
 17
 >>> try: modify(x)
 ... except TypeError: pass
-... else: print('expected a TypeError')
+... else: 'print(expected a TypeError)'
 >>> look(None)
 -1
 >>> store(x)

test/upcast.cpp

@@ -13,7 +13,7 @@ int main()
 {
     PyTypeObject o;
     Y y;
-    BOOST_TEST(boost::python::upcast<PyObject>(&o) == reinterpret_cast<PyObject*>(&o));
+    BOOST_TEST(&Py_REFCNT(boost::python::upcast<PyObject>(&o)) == &Py_REFCNT(&o));
-    BOOST_TEST(boost::python::upcast<PyObject>(&y) == &y);
+    BOOST_TEST(&Py_REFCNT(boost::python::upcast<PyObject>(&y)) == &Py_REFCNT(&y));
     return boost::report_errors();
 }

test/wrapper_held_type.cpp

@@ -20,12 +20,12 @@ struct data
     }
 };
     
-std::shared_ptr<data> create_data()
+std::auto_ptr<data> create_data()
 { 
-    return std::shared_ptr<data>( new data ); 
+    return std::auto_ptr<data>( new data ); 
 }
 
-void do_nothing( std::shared_ptr<data>& ){}
+void do_nothing( std::auto_ptr<data>& ){}
 
     
 namespace bp = boost::python;
@@ -59,7 +59,7 @@ struct data_wrapper : data, bp::wrapper< data >
 
 BOOST_PYTHON_MODULE(wrapper_held_type_ext)
 {
-    bp::class_< data_wrapper, std::shared_ptr< data > >( "data" )    
+    bp::class_< data_wrapper, std::auto_ptr< data > >( "data" )    
         .def( "id", &data::id, &::data_wrapper::default_id );
 
     bp::def( "do_nothing", &do_nothing );