Improve test coverage.

Update scripts to use actions/setup-python to install different Python
versions.  Add run-faber.sh and get-py-env.py scripts.  Add
test-ubuntu-py-ver.yml CI script to test with different Python versions.

.appveyor.yml

@@ -1,111 +0,0 @@
-environment:
-  global:
-    # SDK v7.0 MSVC Express 2008's SetEnv.cmd script will fail if the
-    # /E:ON and /V:ON options are not enabled in the batch script intepreter
-    # See: http://stackoverflow.com/a/13751649/163740
-    CMD_IN_ENV: "cmd /E:ON /V:ON /C .\\ci\\run_with_env.cmd"
-
-  matrix:
-
-    # Pre-installed Python versions, which Appveyor may upgrade to
-    # a later point release.
-    # See: http://www.appveyor.com/docs/installed-software#python
-
-    - PYTHON: C:\\Python36-x64
-      PYTHON_VERSION: 3.6.x
-      PYTHON_ARCH: 64
-      MSVC: 12.0
-      ARCH: x86_64
-      BOOST_PREFIX: C:\Libraries\boost_1_66_0
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      PYTHON: C:\\Python36-x64
-      PYTHON_VERSION: 3.6.x
-      PYTHON_ARCH: 64
-      MSVC: 15.9.19
-      ARCH: x86_64
-      BOOST_PREFIX: C:\Libraries\boost_1_69_0
-
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-      PYTHON: C:\\Python36-x64
-      PYTHON_VERSION: 3.6.x
-      PYTHON_ARCH: 64
-      MSVC: 16.7.4
-      ARCH: x86_64
-      BOOST_PREFIX: C:\Libraries\boost_1_73_0
-
-install:
-  # If there is a newer build queued for the same PR, cancel this one.
-  # The AppVeyor 'rollout builds' option is supposed to serve the same
-  # purpose but it is problematic because it tends to cancel builds pushed
-  # directly to master instead of just PR builds (or the converse).
-  # credits: JuliaLang developers.
-  - ps: if ($env:APPVEYOR_PULL_REQUEST_NUMBER -and $env:APPVEYOR_BUILD_NUMBER -ne ((Invoke-RestMethod `
-        https://ci.appveyor.com/api/projects/$env:APPVEYOR_ACCOUNT_NAME/$env:APPVEYOR_PROJECT_SLUG/history?recordsNumber=50).builds | `
-        Where-Object pullRequestId -eq $env:APPVEYOR_PULL_REQUEST_NUMBER)[0].buildNumber) { `
-          throw "There are newer queued builds for this pull request, failing early." }
-  - ECHO "Filesystem root:"
-  - ps: "ls \"C:/\""
-  - ECHO "Installed libraries:"
-  - ps: "ls \"C:/Libraries/\""
-  ## This path doesn't exist with the VS 2017 worker images
-  #- ECHO "Installed SDKs:"
-  #- ps: "ls \"C:/Program Files/Microsoft SDKs/Windows\""
-
-  # Install Python (from the official .msi of http://python.org) and pip when
-  # not already installed.
-  - ps: if (-not(Test-Path($env:PYTHON))) { & .ci\install.ps1 }
-
-  # Prepend newly installed Python to the PATH of this build (this cannot be
-  # done from inside the powershell script as it would require to restart
-  # the parent CMD process).
-  - "SET PATH=%PYTHON%;%PYTHON%\\Scripts;%PATH%"
-
-  # Check that we have the expected version and architecture for Python
-  - "python --version"
-  - "python -c \"import struct; print(struct.calcsize('P') * 8)\""
-
-  # Upgrade to the latest version of pip to avoid it displaying warnings
-  # about it being out of date.
-  - "python -m pip install --disable-pip-version-check --user --upgrade pip"
-
-  # Install the build dependencies of the project. If some dependencies contain
-  # compiled extensions and are not provided as pre-built wheel packages,
-  # pip will build them from source using the MSVC compiler matching the
-  # target Python version and architecture
-
-  - curl -LfsS -o vswhere.exe https://github.com/Microsoft/vswhere/releases/download/2.8.4/vswhere.exe
-  #- |
-  #   curl -LfsS -o faber.tar.gz https://github.com/stefanseefeld/faber/archive/snapshot/2020-08-01.tar.gz
-  #   tar xf faber.tar.gz
-  #   CD faber-snapshot-2020-08-01
-  #   python setup.py install
-  #   CD ..
-  - python -m pip install faber
-  # report the available MSVC compilers
-  - faber --log=tools --info=tools cxx
-  - easy_install sphinx
-  - python -m pip install numpy
-  - set FARGS=--log=summary --log=output --log=actions --log=commands --with-boost-include=%BOOST_PREFIX% target.arch=%ARCH% cxx.name=msvc cxx.version=%MSVC%
-
-build_script:
-  - faber %FARGS% config || type config.log
-  - faber %FARGS% -j8
-
-test_script:
-  - faber %FARGS% -j8 test.report
-
-after_test:
-  # If tests are successful, create binary packages for the project.
-  #- "%CMD_IN_ENV% python setup.py bdist_wheel"
-  #- "%CMD_IN_ENV% python setup.py bdist_wininst"
-  #- "%CMD_IN_ENV% python setup.py bdist_msi"
-  #- ps: "ls dist"
-
-#artifacts:
-  # Archive the generated packages in the ci.appveyor.com build report.
-  #- path: dist\*
-
-#on_success:
-#  - TODO: upload the content of dist/*.whl to a public wheelhouse
-#

.ci/faber

@@ -1,3 +1,7 @@
+# -*- python -*-
+
+from faber.tools.boost import boostbook
 from faber.tools.python import python
 
+bb = boostbook(prefix='/usr/share/boostbook')
 p = python(command='$PYTHON')

.ci/install.ps1

@@ -1,229 +0,0 @@
-# Sample script to install Python and pip under Windows
-# Authors: Olivier Grisel, Jonathan Helmus, Kyle Kastner, and Alex Willmer
-# License: CC0 1.0 Universal: http://creativecommons.org/publicdomain/zero/1.0/
-
-$MINICONDA_URL = "http://repo.continuum.io/miniconda/"
-$BASE_URL = "https://www.python.org/ftp/python/"
-$GET_PIP_URL = "https://bootstrap.pypa.io/get-pip.py"
-$GET_PIP_PATH = "C:\get-pip.py"
-
-$PYTHON_PRERELEASE_REGEX = @"
-(?x)
-(?<major>\d+)
-\.
-(?<minor>\d+)
-\.
-(?<micro>\d+)
-(?<prerelease>[a-z]{1,2}\d+)
-"@
-
-
-function Download ($filename, $url) {
-    $webclient = New-Object System.Net.WebClient
-
-    $basedir = $pwd.Path + "\"
-    $filepath = $basedir + $filename
-    if (Test-Path $filename) {
-        Write-Host "Reusing" $filepath
-        return $filepath
-    }
-
-    # Download and retry up to 3 times in case of network transient errors.
-    Write-Host "Downloading" $filename "from" $url
-    $retry_attempts = 2
-    for ($i = 0; $i -lt $retry_attempts; $i++) {
-        try {
-            $webclient.DownloadFile($url, $filepath)
-            break
-        }
-        Catch [Exception]{
-            Start-Sleep 1
-        }
-    }
-    if (Test-Path $filepath) {
-        Write-Host "File saved at" $filepath
-    } else {
-        # Retry once to get the error message if any at the last try
-        $webclient.DownloadFile($url, $filepath)
-    }
-    return $filepath
-}
-
-
-function ParsePythonVersion ($python_version) {
-    if ($python_version -match $PYTHON_PRERELEASE_REGEX) {
-        return ([int]$matches.major, [int]$matches.minor, [int]$matches.micro,
-                $matches.prerelease)
-    }
-    $version_obj = [version]$python_version
-    return ($version_obj.major, $version_obj.minor, $version_obj.build, "")
-}
-
-
-function DownloadPython ($python_version, $platform_suffix) {
-    $major, $minor, $micro, $prerelease = ParsePythonVersion $python_version
-
-    if (($major -le 2 -and $micro -eq 0) `
-        -or ($major -eq 3 -and $minor -le 2 -and $micro -eq 0) `
-        ) {
-        $dir = "$major.$minor"
-        $python_version = "$major.$minor$prerelease"
-    } else {
-        $dir = "$major.$minor.$micro"
-    }
-
-    if ($prerelease) {
-        if (($major -le 2) `
-            -or ($major -eq 3 -and $minor -eq 1) `
-            -or ($major -eq 3 -and $minor -eq 2) `
-            -or ($major -eq 3 -and $minor -eq 3) `
-            ) {
-            $dir = "$dir/prev"
-        }
-    }
-
-    if (($major -le 2) -or ($major -le 3 -and $minor -le 4)) {
-        $ext = "msi"
-        if ($platform_suffix) {
-            $platform_suffix = ".$platform_suffix"
-        }
-    } else {
-        $ext = "exe"
-        if ($platform_suffix) {
-            $platform_suffix = "-$platform_suffix"
-        }
-    }
-
-    $filename = "python-$python_version$platform_suffix.$ext"
-    $url = "$BASE_URL$dir/$filename"
-    $filepath = Download $filename $url
-    return $filepath
-}
-
-
-function InstallPython ($python_version, $architecture, $python_home) {
-    Write-Host "Installing Python" $python_version "for" $architecture "bit architecture to" $python_home
-    if (Test-Path $python_home) {
-        Write-Host $python_home "already exists, skipping."
-        return $false
-    }
-    if ($architecture -eq "32") {
-        $platform_suffix = ""
-    } else {
-        $platform_suffix = "amd64"
-    }
-    $installer_path = DownloadPython $python_version $platform_suffix
-    $installer_ext = [System.IO.Path]::GetExtension($installer_path)
-    Write-Host "Installing $installer_path to $python_home"
-    $install_log = $python_home + ".log"
-    if ($installer_ext -eq '.msi') {
-        InstallPythonMSI $installer_path $python_home $install_log
-    } else {
-        InstallPythonEXE $installer_path $python_home $install_log
-    }
-    if (Test-Path $python_home) {
-        Write-Host "Python $python_version ($architecture) installation complete"
-    } else {
-        Write-Host "Failed to install Python in $python_home"
-        Get-Content -Path $install_log
-        Exit 1
-    }
-}
-
-
-function InstallPythonEXE ($exepath, $python_home, $install_log) {
-    $install_args = "/quiet InstallAllUsers=1 TargetDir=$python_home"
-    RunCommand $exepath $install_args
-}
-
-
-function InstallPythonMSI ($msipath, $python_home, $install_log) {
-    $install_args = "/qn /log $install_log /i $msipath TARGETDIR=$python_home"
-    $uninstall_args = "/qn /x $msipath"
-    RunCommand "msiexec.exe" $install_args
-    if (-not(Test-Path $python_home)) {
-        Write-Host "Python seems to be installed else-where, reinstalling."
-        RunCommand "msiexec.exe" $uninstall_args
-        RunCommand "msiexec.exe" $install_args
-    }
-}
-
-function RunCommand ($command, $command_args) {
-    Write-Host $command $command_args
-    Start-Process -FilePath $command -ArgumentList $command_args -Wait -Passthru
-}
-
-
-function InstallPip ($python_home) {
-    $pip_path = $python_home + "\Scripts\pip.exe"
-    $python_path = $python_home + "\python.exe"
-    if (-not(Test-Path $pip_path)) {
-        Write-Host "Installing pip..."
-        $webclient = New-Object System.Net.WebClient
-        $webclient.DownloadFile($GET_PIP_URL, $GET_PIP_PATH)
-        Write-Host "Executing:" $python_path $GET_PIP_PATH
-        & $python_path $GET_PIP_PATH
-    } else {
-        Write-Host "pip already installed."
-    }
-}
-
-
-function DownloadMiniconda ($python_version, $platform_suffix) {
-    if ($python_version -eq "3.4") {
-        $filename = "Miniconda3-3.5.5-Windows-" + $platform_suffix + ".exe"
-    } else {
-        $filename = "Miniconda-3.5.5-Windows-" + $platform_suffix + ".exe"
-    }
-    $url = $MINICONDA_URL + $filename
-    $filepath = Download $filename $url
-    return $filepath
-}
-
-
-function InstallMiniconda ($python_version, $architecture, $python_home) {
-    Write-Host "Installing Python" $python_version "for" $architecture "bit architecture to" $python_home
-    if (Test-Path $python_home) {
-        Write-Host $python_home "already exists, skipping."
-        return $false
-    }
-    if ($architecture -eq "32") {
-        $platform_suffix = "x86"
-    } else {
-        $platform_suffix = "x86_64"
-    }
-    $filepath = DownloadMiniconda $python_version $platform_suffix
-    Write-Host "Installing" $filepath "to" $python_home
-    $install_log = $python_home + ".log"
-    $args = "/S /D=$python_home"
-    Write-Host $filepath $args
-    Start-Process -FilePath $filepath -ArgumentList $args -Wait -Passthru
-    if (Test-Path $python_home) {
-        Write-Host "Python $python_version ($architecture) installation complete"
-    } else {
-        Write-Host "Failed to install Python in $python_home"
-        Get-Content -Path $install_log
-        Exit 1
-    }
-}
-
-
-function InstallMinicondaPip ($python_home) {
-    $pip_path = $python_home + "\Scripts\pip.exe"
-    $conda_path = $python_home + "\Scripts\conda.exe"
-    if (-not(Test-Path $pip_path)) {
-        Write-Host "Installing pip..."
-        $args = "install --yes pip"
-        Write-Host $conda_path $args
-        Start-Process -FilePath "$conda_path" -ArgumentList $args -Wait -Passthru
-    } else {
-        Write-Host "pip already installed."
-    }
-}
-
-function main () {
-    InstallPython $env:PYTHON_VERSION $env:PYTHON_ARCH $env:PYTHON
-    InstallPip $env:PYTHON
-}
-
-main

.ci/run_with_env.cmd

@@ -1,88 +0,0 @@
-:: To build extensions for 64 bit Python 3, we need to configure environment
-:: variables to use the MSVC 2010 C++ compilers from GRMSDKX_EN_DVD.iso of:
-:: MS Windows SDK for Windows 7 and .NET Framework 4 (SDK v7.1)
-::
-:: To build extensions for 64 bit Python 2, we need to configure environment
-:: variables to use the MSVC 2008 C++ compilers from GRMSDKX_EN_DVD.iso of:
-:: MS Windows SDK for Windows 7 and .NET Framework 3.5 (SDK v7.0)
-::
-:: 32 bit builds, and 64-bit builds for 3.5 and beyond, do not require specific
-:: environment configurations.
-::
-:: Note: this script needs to be run with the /E:ON and /V:ON flags for the
-:: cmd interpreter, at least for (SDK v7.0)
-::
-:: More details at:
-:: https://github.com/cython/cython/wiki/64BitCythonExtensionsOnWindows
-:: http://stackoverflow.com/a/13751649/163740
-::
-:: Author: Olivier Grisel
-:: License: CC0 1.0 Universal: http://creativecommons.org/publicdomain/zero/1.0/
-::
-:: Notes about batch files for Python people:
-::
-:: Quotes in values are literally part of the values:
-::      SET FOO="bar"
-:: FOO is now five characters long: " b a r "
-:: If you don't want quotes, don't include them on the right-hand side.
-::
-:: The CALL lines at the end of this file look redundant, but if you move them
-:: outside of the IF clauses, they do not run properly in the SET_SDK_64==Y
-:: case, I don't know why.
-@ECHO OFF
-
-SET COMMAND_TO_RUN=%*
-SET WIN_SDK_ROOT=C:\Program Files\Microsoft SDKs\Windows
-SET WIN_WDK=c:\Program Files (x86)\Windows Kits\10\Include\wdf
-
-:: Extract the major and minor versions, and allow for the minor version to be
-:: more than 9.  This requires the version number to have two dots in it.
-SET MAJOR_PYTHON_VERSION=%PYTHON_VERSION:~0,1%
-IF "%PYTHON_VERSION:~3,1%" == "." (
-    SET MINOR_PYTHON_VERSION=%PYTHON_VERSION:~2,1%
-) ELSE (
-    SET MINOR_PYTHON_VERSION=%PYTHON_VERSION:~2,2%
-)
-
-:: Based on the Python version, determine what SDK version to use, and whether
-:: to set the SDK for 64-bit.
-IF %MAJOR_PYTHON_VERSION% == 2 (
-    SET WINDOWS_SDK_VERSION="v7.0"
-    SET SET_SDK_64=Y
-) ELSE (
-    IF %MAJOR_PYTHON_VERSION% == 3 (
-        SET WINDOWS_SDK_VERSION="v7.1"
-        IF %MINOR_PYTHON_VERSION% LEQ 4 (
-            SET SET_SDK_64=Y
-        ) ELSE (
-            SET SET_SDK_64=N
-            IF EXIST "%WIN_WDK%" (
-                :: See: https://connect.microsoft.com/VisualStudio/feedback/details/1610302/
-                REN "%WIN_WDK%" 0wdf
-            )
-        )
-    ) ELSE (
-        ECHO Unsupported Python version: "%MAJOR_PYTHON_VERSION%"
-        EXIT 1
-    )
-)
-
-IF %PYTHON_ARCH% == 64 (
-    IF %SET_SDK_64% == Y (
-        ECHO Configuring Windows SDK %WINDOWS_SDK_VERSION% for Python %MAJOR_PYTHON_VERSION% on a 64 bit architecture
-        SET DISTUTILS_USE_SDK=1
-        SET MSSdk=1
-        "%WIN_SDK_ROOT%\%WINDOWS_SDK_VERSION%\Setup\WindowsSdkVer.exe" -q -version:%WINDOWS_SDK_VERSION%
-        "%WIN_SDK_ROOT%\%WINDOWS_SDK_VERSION%\Bin\SetEnv.cmd" /x64 /release
-        ECHO Executing: %COMMAND_TO_RUN%
-        call %COMMAND_TO_RUN% || EXIT 1
-    ) ELSE (
-        ECHO Using default MSVC build environment for 64 bit architecture
-        ECHO Executing: %COMMAND_TO_RUN%
-        call %COMMAND_TO_RUN% || EXIT 1
-    )
-) ELSE (
-    ECHO Using default MSVC build environment for 32 bit architecture
-    ECHO Executing: %COMMAND_TO_RUN%
-    call %COMMAND_TO_RUN% || EXIT 1
-)

.ci/upload_docs.sh

@@ -1,58 +0,0 @@
-#!/bin/bash
-set -e # Exit with nonzero exit code if anything fails
-
-SOURCE_BRANCH="master"
-TARGET_BRANCH="gh-pages"
-
-# Pull requests and commits to other branches shouldn't try to deploy, just build to verify
-if [ "$TRAVIS_PULL_REQUEST" != "false" ] || \
-   [ "$TRAVIS_BRANCH" != master -a \
-     "$TRAVIS_BRANCH" != develop  -a \
-     "$TRAVIS_BRANCH" != travis ]; then
-    echo "No docs to upload."
-    exit 0
-fi
-
-if [ -z "$GH_TOKEN" ]; then
-    echo "Error: GH_TOKEN is undefined"
-    exit 1
-fi
-
-# Save some useful information
-REPO=`git config remote.origin.url`
-SHA=`git rev-parse --verify HEAD`
-
-# build happens to contain the "doc/html" tree that we want to push
-# into the gh-pages branch. So we step into that directory, create a new repo,
-# set the remote appropriately, then commit and push.
-cd build
-git init
-git config user.name "Travis CI"
-git config user.email "travis-ci"
-
-# Make sure 'GH_TOKEN' is set (as 'secure' variable) in .travis.yml
-git remote add upstream "https://$GH_TOKEN@github.com/boostorg/python.git"
-git fetch upstream
-git reset upstream/gh-pages
-
-# Prepare version.
-if [ "$TRAVIS_BRANCH" = develop -o "$TRAVIS_BRANCH" = travis ]; then
-    mkdir -p develop/doc/
-    cp ../index.html develop/
-    cp ../doc/index.html develop/doc/
-    cp -a doc/html develop/doc/
-    git add develop/index.html
-    git add develop/doc/index.html
-    git add -A develop/doc/html
-else
-    cp ../index.html .
-    cp ../doc/index.html doc/
-    git add index.html
-    git add doc/index.html
-    git add -A doc/html
-fi
-# Commit the new version.
-git commit -m "Deploy to GitHub Pages: ${SHA}"
-
-# Now that we're all set up, we can push.
-git push -q upstream HEAD:gh-pages

.github/get-py-env.py

@@ -0,0 +1,65 @@
+#!/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

@@ -0,0 +1,46 @@
+#!/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

@@ -0,0 +1,37 @@
+name: deploy documentation
+
+on: [push]
+
+jobs:
+  deploy:
+    runs-on: ubuntu-24.04
+    steps:
+    - uses: actions/checkout@v5
+    - name: setup
+      run: |
+        sudo apt-get update
+        sudo apt-get install \
+          libboost-tools-dev \
+          python3 \
+          python3-numpy \
+          python3-sphinx \
+          xsltproc \
+          docbook-xsl
+        sudo python3 -m pip install --upgrade pip
+        sudo python3 -m pip install faber
+    - name: build
+      run: |
+        sed -e "s/\$PYTHON/python3/g" .ci/faber > ~/.faber
+        faber --builddir=build doc.html
+        if [ "${GITHUB_REF##*/}" == master ]; then
+          echo "destination_dir=doc/html" >> $GITHUB_ENV
+        else
+          echo "destination_dir=doc/develop/html" >> $GITHUB_ENV
+        fi
+    - name: deploy
+      uses: peaceiris/actions-gh-pages@v4
+      with:
+        github_token: ${{ secrets.GITHUB_TOKEN }}
+        publish_dir: build/doc/html
+        destination_dir: ${{ env.destination_dir }}
+        keep_files: true

.github/workflows/test-osx.yml

@@ -0,0 +1,50 @@
+name: Test OSX
+
+on:  [push, pull_request]
+
+jobs:
+  build:
+    runs-on: macOS-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: [3.8.10]
+        cxx: [clang++]
+        std: [c++11, c++14] # TODO: c++17 is failing !
+
+    steps:
+    - uses: actions/checkout@v5
+    - name: setup python
+      uses: actions/setup-python@v6
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: setup prerequisites
+      run: |
+        brew install boost
+        python -m pip install --upgrade pip
+        python -m pip install setuptools faber
+    - name: build
+      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

@@ -0,0 +1,94 @@
+# Test on Ubuntu with various compiler and language standard versions.
+name: Test Ubuntu
+
+on:
+  push:
+  pull_request:
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.14']
+        cxx: [g++, clang++]
+        std: [c++11, c++14, c++17]
+        include:
+          - python-version: '2.7'
+            cxx: g++
+            std: c++11
+          - python-version: '3.10'
+            cxx: g++
+            std: c++17
+          - python-version: '3.11'
+            cxx: g++
+            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.
+      # 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' }}"
+      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 !
+        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
+        faber \
+          --with-boost-include=${BOOST_PY_DEPS} \
+          --builddir=build \
+          cxx.name=${{ matrix.cxx }} \
+          cxxflags=-std=${{ matrix.std }} \
+          cppflags=-std=${{ matrix.std }} \
+          -j`nproc`
+    - name: build-py3
+      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} \
+          --builddir=build \
+          cxx.name=${{ matrix.cxx }} \
+          cxxflags=-std=${{ matrix.std }} \
+          cppflags=-std=${{ matrix.std }} \
+          -j`nproc` \
+          test.report
+    - name: test-py3
+      if: "${{ matrix.python-version  != '2.7' }}"
+      run: |
+        .github/run-faber.sh test.report

.github/workflows/test-windows.yml

@@ -0,0 +1,49 @@
+name: Test Windows
+
+on:  [push, pull_request]
+
+jobs:
+  build:
+    runs-on: windows-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: [3.7]
+
+    steps:
+    - uses: actions/checkout@v5
+    - uses: actions/setup-python@v6
+      with:
+        python-version: ${{ matrix.python-version }}
+    - uses: microsoft/setup-msbuild@v2
+    - name: setup boost prerequisites
+      uses: lukka/run-vcpkg@v6
+      with:
+        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
+    - name: setup faber
+      run: |
+        python -m pip install --upgrade pip
+        python -m pip install setuptools faber numpy
+        faber --info=tools cxx
+    - name: build
+      shell: cmd
+      run: |
+        faber --builddir=build cxx.name=msvc --log=commands --log=output --with-boost-include=${{ runner.workspace }}\vcpkg\installed\x64-windows\include -j4
+    - name: test
+      shell: cmd
+      run: |
+        faber --builddir=build cxx.name=msvc --with-boost-include=${{ runner.workspace }}\vcpkg\installed\x64-windows\include -j4 test.report

.travis.yml

@@ -1,117 +0,0 @@
-#
-# Copyright (c) 2016 Stefan Seefeld
-# All rights reserved.
-#
-# 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)
-
-dist: bionic
-
-language: cpp
-
-env:
-  global:
-    - secure: BRNUkxN3p8f+uYKWC3Hr0VPqZA0PxbWr1DJlcI4hbiZtzKhMCWjDmd9UW9CzzexqeOxpd+9s0G87qvOur+wMSVxugDxtTesZrh1czXHeSVxgQrYD783XJtQJ9aYypbChkiboRD6Xpmbq7itwMuHBJMFtCuDxMynpU1jWwkyTf2Y=
-
-jobs:
-  include:
-    - os: linux
-      env: CXX=g++ PYTHON=python CXXFLAGS=-std=c++98
-    - os: linux
-      env: CXX=g++ PYTHON=python CXXFLAGS=-std=c++11
-    - os: linux
-      env: CXX=g++ PYTHON=python3 CXXFLAGS=-std=c++98
-    - os: linux
-      env: CXX=g++ PYTHON=python3 CXXFLAGS=-std=c++11
-    - os: linux
-      env: CXX=clang++ PYTHON=python3 CXXFLAGS=-std=c++98
-    - os: linux
-      env: CXX=clang++ PYTHON=python3 CXXFLAGS=-std=c++11
-    - os: linux
-      env: CXX=g++ PYTHON=pypy3 CXXFLAGS=-std=c++11
-    - os: osx
-      env: CXX=clang++ PYTHON=python CXXFLAGS=-std=c++11
-    - env: PYTHON=python DOC=1
-  allow_failures:
-    - os: linux
-      env: CXX=g++ PYTHON=pypy3 CXXFLAGS=-std=c++11
-    - os: osx
-
-addons:
-  apt:
-    sources:
-    - ubuntu-toolchain-r-test
-    - pypy
-    packages:
-    - gcc
-    - g++
-    - clang
-    - pypy3-dev
-    - python3-pip
-    - python-numpy
-    - python-sphinx
-    - python3-dev
-    - python3-numpy
-    - libboost-all-dev
-    - xsltproc
-    - docbook-xsl
-    - python-docutils
-
-
-cache:
-  directories:
-  - $HOME/Boost
-
-install:
-  # Install our own version of Boost (the subset we need) as the system version is
-  # too old (for C++11 support).
-  - |
-     if [ ! -d $HOME/Boost/tools/boostbook ]; then
-       echo "rebuilding Boost prerequisites."
-       wget https://sourceforge.net/projects/boost/files/boost/1.66.0/boost_1_66_0.tar.gz/download
-       tar xf download
-       pushd boost_1_66_0
-       ./bootstrap.sh
-       ./b2 tools/bcp
-       mkdir -p $HOME/Boost
-       # Install Boost.Python prerequisites, but not Boost.Python itself.
-       dist/bin/bcp python tools/boostbook tools/quickbook $HOME/Boost &> /dev/null
-       rm -rf $HOME/Boost/boost/python*
-       popd
-     else
-       echo "using cached Boost prerequisites."
-     fi
-     # Install Faber, the build tool.
-     python3 -m pip install setuptools
-     python3 -m pip install faber
-     #date=2020-08-01
-     #wget https://github.com/stefanseefeld/faber/archive/snapshot/$date.tar.gz
-     #tar xf $date.tar.gz
-     #pushd faber-snapshot-$date
-     #sudo python3 setup.py install
-     #popd
-
-before_script:
-- sed -e "s/\$PYTHON/$PYTHON/g" .ci/faber > ~/.faber
-- $PYTHON --version
-- faber -h
-- ls -l $HOME/Boost
-
-script:
-- |
-   if [ "$DOC" ]; then
-     BOOST_ROOT=$HOME/Boost faber --builddir=build doc.html
-   else
-     faber --with-boost-include=$HOME/Boost --builddir=build test.report cxx.name=$CXX cxxflags=$CXXFLAGS -j8
-   fi
-
-after_success:
-# Upload docs only when building upstream.
-- |
-   if [ "$DOC" -a \
-        "$TRAVIS_REPO_SLUG" = "boostorg/python" -a \
-        "$TRAVIS_PULL_REQUEST" = "false" ]; then
-     export GH_TOKEN
-     .ci/upload_docs.sh
-   fi

CMakeLists.txt

@@ -0,0 +1,176 @@
+# Copyright 2020, 2021 Peter Dimov
+# Distributed under the Boost Software License, Version 1.0.
+# https://www.boost.org/LICENSE_1_0.txt
+
+cmake_minimum_required(VERSION 3.14...3.20)
+
+project(boost_python VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+
+find_package(Python REQUIRED COMPONENTS Development OPTIONAL_COMPONENTS NumPy)
+
+if(Python_NumPy_FOUND)
+  message(STATUS "Boost.Python: using Python ${Python_VERSION} with NumPy at ${Python_NumPy_INCLUDE_DIRS}")
+else()
+  message(STATUS "Boost.Python: using Python ${Python_VERSION} without NumPy")
+endif()
+
+# boost_pythonXY
+
+set(_pyver ${Python_VERSION_MAJOR}${Python_VERSION_MINOR})
+set(_boost_python boost_python${_pyver})
+
+add_library(${_boost_python}
+  src/dict.cpp
+  src/errors.cpp
+  src/exec.cpp
+  src/import.cpp
+  src/list.cpp
+  src/long.cpp
+  src/module.cpp
+  src/object_operators.cpp
+  src/object_protocol.cpp
+  src/slice.cpp
+  src/str.cpp
+  src/tuple.cpp
+  src/wrapper.cpp
+  src/converter/from_python.cpp
+  src/converter/registry.cpp
+  src/converter/type_id.cpp
+  src/converter/builtin_converters.cpp
+  src/converter/arg_to_python_base.cpp
+  src/object/enum.cpp
+  src/object/class.cpp
+  src/object/function.cpp
+  src/object/inheritance.cpp
+  src/object/life_support.cpp
+  src/object/pickle_support.cpp
+  src/object/iterator.cpp
+  src/object/stl_iterator.cpp
+  src/object_protocol.cpp
+  src/object_operators.cpp
+  src/object/function_doc_signature.cpp
+)
+
+add_library(Boost::python${_pyver} ALIAS ${_boost_python})
+
+target_include_directories(${_boost_python} PUBLIC include)
+
+target_link_libraries(${_boost_python}
+  PUBLIC
+    Boost::align
+    Boost::bind
+    Boost::config
+    Boost::conversion
+    Boost::core
+    Boost::detail
+    Boost::foreach
+    Boost::function
+    Boost::iterator
+    Boost::lexical_cast
+    Boost::mpl
+    Boost::numeric_conversion
+    Boost::preprocessor
+    Boost::smart_ptr
+    Boost::static_assert
+    Boost::tuple
+    Boost::type_traits
+    Boost::utility
+
+    Python::Module
+
+  PRIVATE
+    Boost::graph
+    Boost::integer
+    Boost::property_map
+)
+
+target_compile_definitions(${_boost_python}
+  PUBLIC BOOST_PYTHON_NO_LIB
+  PRIVATE BOOST_PYTHON_SOURCE
+)
+
+if(BUILD_SHARED_LIBS)
+  target_compile_definitions(${_boost_python} PUBLIC BOOST_PYTHON_DYN_LINK)
+else()
+  target_compile_definitions(${_boost_python} PUBLIC BOOST_PYTHON_STATIC_LINK BOOST_PYTHON_STATIC_LIB)
+endif()
+
+# Boost::python alias
+
+add_library(boost_python INTERFACE)
+add_library(Boost::python ALIAS boost_python)
+target_link_libraries(boost_python INTERFACE Boost::python${_pyver})
+
+# Installation
+
+if(BOOST_SUPERPROJECT_VERSION AND NOT CMAKE_VERSION VERSION_LESS 3.13)
+  boost_install(TARGETS ${_boost_python} boost_python VERSION ${BOOST_SUPERPROJECT_VERSION} HEADER_DIRECTORY include)
+endif()
+
+if(Python_NumPy_FOUND)
+
+# boost_numpyXY
+
+set(_boost_numpy boost_numpy${_pyver})
+
+add_library(${_boost_numpy}
+  src/numpy/dtype.cpp
+  src/numpy/matrix.cpp
+  src/numpy/ndarray.cpp
+  src/numpy/numpy.cpp
+  src/numpy/scalars.cpp
+  src/numpy/ufunc.cpp
+)
+
+add_library(Boost::numpy${_pyver} ALIAS ${_boost_numpy})
+
+target_include_directories(${_boost_numpy} PUBLIC include)
+
+target_link_libraries(${_boost_numpy}
+  PUBLIC
+    Boost::config
+    Boost::core
+    Boost::detail
+    Boost::mpl
+    Boost::python
+    Boost::smart_ptr
+
+    Python::NumPy
+)
+
+target_compile_definitions(${_boost_numpy}
+  PUBLIC BOOST_NUMPY_NO_LIB
+  PRIVATE BOOST_NUMPY_SOURCE
+)
+
+if(BUILD_SHARED_LIBS)
+  target_compile_definitions(${_boost_numpy} PUBLIC BOOST_NUMPY_DYN_LINK)
+else()
+  target_compile_definitions(${_boost_numpy} PUBLIC BOOST_NUMPY_STATIC_LINK BOOST_NUMPY_STATIC_LIB)
+endif()
+
+# Boost::numpy alias
+
+add_library(boost_numpy INTERFACE)
+add_library(Boost::numpy ALIAS boost_numpy)
+target_link_libraries(boost_numpy INTERFACE Boost::numpy${_pyver})
+
+# Installation
+
+if(BOOST_SUPERPROJECT_VERSION AND NOT CMAKE_VERSION VERSION_LESS 3.13)
+  boost_install(TARGETS ${_boost_numpy} boost_numpy VERSION ${BOOST_SUPERPROJECT_VERSION})
+endif()
+
+endif()
+
+unset(_pyver)
+unset(_boost_python)
+unset(_boost_numpy)
+
+# Testing
+
+if(BUILD_TESTING AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/test/CMakeLists.txt")
+
+  add_subdirectory(test)
+
+endif()

README.md

@@ -21,8 +21,7 @@ See the [Boost.Python](http://boostorg.github.io/python) documentation for detai
 
 **Hint :** Check out the [development version](http://boostorg.github.io/python/develop) of the documentation to see work in progress.
 
-# Building [![Build Status](https://travis-ci.org/boostorg/python.svg?branch=develop)](https://travis-ci.org/boostorg/python) [![Build status](https://ci.appveyor.com/api/projects/status/cgx9xma6v3gjav92/branch/develop?svg=true)](https://ci.appveyor.com/project/stefanseefeld/python/branch/develop)
+# Building ![Test Ubuntu](https://github.com/boostorg/python/workflows/Test%20Ubuntu/badge.svg) ![Test OSX](https://github.com/boostorg/python/workflows/Test%20OSX/badge.svg) ![Test Windows](https://github.com/boostorg/python/workflows/Test%20Windows/badge.svg)
-
 
 While Boost.Python is part of the Boost C++ Libraries super-project, and thus can be compiled as part of Boost, it can also be compiled and installed stand-alone, i.e. against a pre-installed Boost package.
 

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
@@ -117,11 +150,12 @@ lib boost_numpy
         <define>BOOST_NUMPY_SOURCE
         [ cond [ python.numpy ] : <library>/python//python_for_extensions ]
         [ unless [ python.numpy ] : <build>no ]
-        <include>$(numpy-include)
+        <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 %}"
@@ -87,7 +90,7 @@
       <tr>
         <td valign="top" width="300">
           <h3><a href="{{ pathto('index') }}"><img 
-          alt="C++ Boost" src="{{ pathto('_static/' + logo, 1) }}" border="0"></a></h3>
+          alt="C++ Boost" src="{{ pathto('_static/bpl.png', 1) }}" border="0"></a></h3>
         </td>
 
         <td >

doc/numpy/conf.py

@@ -40,8 +40,8 @@ source_suffix = '.rst'
 master_doc = 'index'
 
 # General information about the project.
-project = u'Boost.Python NumPy extension'
+project = 'Boost.Python NumPy extension'
-copyright = u'2011, Stefan Seefeld'
+copyright = '2011, Stefan Seefeld'
 
 # The version info for the project you're documenting, acts as replacement for
 # |version| and |release|, also used in various other places throughout the
@@ -181,8 +181,8 @@ html_add_permalinks = False
 # Grouping the document tree into LaTeX files. List of tuples
 # (source start file, target name, title, author, documentclass [howto/manual]).
 latex_documents = [
-  ('index', 'BoostPythonNumPy.tex', u'Boost.Python NumPy Documentation',
+  ('index', 'BoostPythonNumPy.tex', 'Boost.Python NumPy Documentation',
-   u'Stefan Seefeld', 'manual'),
+   'Stefan Seefeld', 'manual'),
 ]
 
 # The name of an image file (relative to this directory) to place at the top of
@@ -214,6 +214,6 @@ latex_documents = [
 # One entry per manual page. List of tuples
 # (source start file, name, description, authors, manual section).
 man_pages = [
-    ('index', 'boostnumpy', u'Boost.Python NumPy Documentation',
+    ('index', 'boostnumpy', 'Boost.Python NumPy Documentation',
-     [u'Stefan Seefeld'], 1)
+     ['Stefan Seefeld'], 1)
 ]

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);
   }

doc/reference/call_method.qbk

@@ -20,6 +20,8 @@ C++ Module Definition
 ``
 #include <boost/python/module.hpp>
 #include <boost/python/class.hpp>
+#include <boost/python/call_method.hpp>
+#include <boost/python/def.hpp>
 #include <boost/utility.hpp>
 #include <cstring>
 
@@ -28,7 +30,7 @@ class Base
 {
  public:
    virtual char const* class_name() const { return "Base"; }
-   virtual ~Base();
+   virtual ~Base() {};
 };
 
 bool is_base(Base* b)
@@ -56,7 +58,7 @@ BOOST_PYTHON_MODULE(my_module)
 {
     def("is_base", is_base);
 
-    class_<Base,Base_callback, noncopyable>("Base")
+    class_<Base,Base_callback, boost::noncopyable>("Base")
         .def("class_name", &Base_callback::Base_name)
         ;
 

doc/tutorial.qbk

@@ -117,7 +117,7 @@ platforms. The complete list of Bjam executables can be found
 [h2 Let's Jam!]
 __jam__
 
-[@../../../../example/tutorial/Jamroot Here] is our minimalist Jamroot
+[@../example/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.
 

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.

example/numpy/demo_gaussian.py

@@ -3,6 +3,7 @@
 #    (See accompanying file LICENSE_1_0.txt or copy at
 #          http://www.boost.org/LICENSE_1_0.txt)
 
+from __future__ import print_function
 import numpy
 import gaussian
 
@@ -19,19 +20,19 @@ x, y = numpy.meshgrid(r, r)
 z = g(x, y)
 
 s = z.sum() * (r[1] - r[0])**2
-print "sum (should be ~ 1):", s
+print("sum (should be ~ 1):", s)
 
 xc = (z * x).sum() / z.sum()
-print "x centroid (should be ~ %f): %f" % (mu[0], xc)
+print("x centroid (should be ~ %f): %f" % (mu[0], xc))
 
 yc = (z * y).sum() / z.sum()
-print "y centroid (should be ~ %f): %f" % (mu[1], yc)
+print("y centroid (should be ~ %f): %f" % (mu[1], yc))
 
 xx = (z * (x - xc)**2).sum() / z.sum()
-print "xx moment (should be ~ %f): %f" % (sigma[0,0], xx)
+print("xx moment (should be ~ %f): %f" % (sigma[0,0], xx))
 
 yy = (z * (y - yc)**2).sum() / z.sum()
-print "yy moment (should be ~ %f): %f" % (sigma[1,1], yy)
+print("yy moment (should be ~ %f): %f" % (sigma[1,1], yy))
 
 xy = 0.5 * (z * (x - xc) * (y - yc)).sum() / z.sum()
-print "xy moment (should be ~ %f): %f" % (sigma[0,1], xy)
+print("xy moment (should be ~ %f): %f" % (sigma[0,1], xy))

example/quickstart/script.py

@@ -1,4 +1,4 @@
-#! /usr/bin/env python
+#!/usr/bin/env python3
 # Copyright Stefan Seefeld 2006. 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)

example/quickstart/test_extending.py

@@ -1,4 +1,4 @@
-#! /usr/bin/env python
+#!/usr/bin/env python3
 # Copyright Ralf W. Grosse-Kunstleve 2006. 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)

example/tutorial/hello.py

@@ -1,4 +1,4 @@
-#! /usr/bin/env python
+#!/usr/bin/env python3
 #  Copyright Joel de Guzman 2002-2007. 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)

fabscript

@@ -16,6 +16,7 @@ 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/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/obj_mgr_arg_from_python.hpp

@@ -81,9 +81,9 @@ inline object_manager_ref_arg_from_python<Ref>::object_manager_ref_arg_from_pyth
 # if defined(__EDG_VERSION__) && __EDG_VERSION__ <= 243
     // needed for warning suppression
     python::detail::borrowed_reference x_ = python::detail::borrowed_reference(x);
-    python::detail::construct_referent<Ref>(&m_result.bytes, x_);
+    python::detail::construct_referent<Ref>(m_result.bytes, x_);
 # else 
-    python::detail::construct_referent<Ref>(&m_result.bytes, (python::detail::borrowed_reference)x);
+    python::detail::construct_referent<Ref>(m_result.bytes, (python::detail::borrowed_reference)x);
 # endif 
 }
 

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/converter/rvalue_from_python_data.hpp

@@ -9,6 +9,7 @@
 # include <boost/python/detail/referent_storage.hpp>
 # include <boost/python/detail/destroy.hpp>
 # include <boost/python/detail/type_traits.hpp>
+# include <boost/align/align.hpp>
 # include <boost/static_assert.hpp>
 # include <cstddef>
 
@@ -132,7 +133,13 @@ template <class T>
 inline rvalue_from_python_data<T>::~rvalue_from_python_data()
 {
     if (this->stage1.convertible == this->storage.bytes)
-        python::detail::destroy_referent<ref_type>(this->storage.bytes);
+    {
+        size_t allocated = sizeof(this->storage);
+        void *ptr = this->storage.bytes;
+        void *aligned_storage =
+            ::boost::alignment::align(boost::python::detail::alignment_of<T>::value, 0, ptr, allocated);
+        python::detail::destroy_referent<ref_type>(aligned_storage);
+    }
 }
 
 }}} // namespace boost::python::converter

include/boost/python/converter/shared_ptr_from_python.hpp

@@ -49,13 +49,17 @@ struct shared_ptr_from_python
       new (storage) SP<T>();
     else
     {
-      SP<void> hold_convertible_ref_count(
+      void *const storage = ((converter::rvalue_from_python_storage<SP<T> >*)data)->storage.bytes;
-	 (void*)0, shared_ptr_deleter(handle<>(borrowed(source))) );
+      // Deal with the "None" case.
-      // use aliasing constructor
+      if (data->convertible == source)
-      new (storage) SP<T>(hold_convertible_ref_count,
+        new (storage) SP<T>();
-			  static_cast<T*>(data->convertible));
+      else
+      {
+        SP<void> hold_convertible_ref_count((void*)0, shared_ptr_deleter(handle<>(borrowed(source))) );
+        // use aliasing constructor
+        new (storage) SP<T>(hold_convertible_ref_count, static_cast<T*>(data->convertible));
+      }
     }
-
     data->convertible = storage;
   }
 };

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/detail/is_auto_ptr.hpp

@@ -8,6 +8,8 @@
 # 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

@@ -0,0 +1,103 @@
+// 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/detail/referent_storage.hpp

@@ -5,39 +5,21 @@
 #ifndef REFERENT_STORAGE_DWA200278_HPP
 # define REFERENT_STORAGE_DWA200278_HPP
 # include <boost/mpl/if.hpp>
+# include <boost/type_traits/aligned_storage.hpp>
 # include <cstddef>
 
 namespace boost { namespace python { namespace detail {
 
-struct alignment_dummy;
+template <std::size_t size, std::size_t alignment = std::size_t(-1)>
-typedef void (*function_ptr)();
+struct aligned_storage
-typedef int (alignment_dummy::*member_ptr);
-typedef int (alignment_dummy::*member_function_ptr)();
-
-# define BOOST_PYTHON_ALIGNER(T, n)                     \
-        typename mpl::if_c<                             \
-           sizeof(T) <= size, T, char>::type t##n
-
-// Storage for size bytes, aligned to all fundamental types no larger than size
-template <std::size_t size>
-union aligned_storage
 {
-    BOOST_PYTHON_ALIGNER(char, 0);
+  union type
-    BOOST_PYTHON_ALIGNER(short, 1);
+  {
-    BOOST_PYTHON_ALIGNER(int, 2);
+    typename ::boost::aligned_storage<size, alignment>::type data;
-    BOOST_PYTHON_ALIGNER(long, 3);
-    BOOST_PYTHON_ALIGNER(float, 4);
-    BOOST_PYTHON_ALIGNER(double, 5);
-    BOOST_PYTHON_ALIGNER(long double, 6);
-    BOOST_PYTHON_ALIGNER(void*, 7);
-    BOOST_PYTHON_ALIGNER(function_ptr, 8);
-    BOOST_PYTHON_ALIGNER(member_ptr, 9);
-    BOOST_PYTHON_ALIGNER(member_function_ptr, 10);
     char bytes[size];
+  };
 };
-
+      
-# undef BOOST_PYTHON_ALIGNER
-
   // Compute the size of T's referent. We wouldn't need this at all,
   // but sizeof() is broken in CodeWarriors <= 8.0
   template <class T> struct referent_size;
@@ -50,15 +32,12 @@ union aligned_storage
           std::size_t, value = sizeof(T));
   };
 
-
 // A metafunction returning a POD type which can store U, where T ==
 // U&. If T is not a reference type, returns a POD which can store T.
 template <class T>
 struct referent_storage
 {
-    typedef aligned_storage<
+    typedef typename aligned_storage<referent_size<T>::value, alignment_of<T>::value>::type type;
-        ::boost::python::detail::referent_size<T>::value
-    > type;
 };
 
 }}} // namespace boost::python::detail

include/boost/python/detail/wrap_python.hpp

@@ -227,7 +227,11 @@ typedef int pid_t;
 
 # define PyVarObject_HEAD_INIT(type, size) \
         PyObject_HEAD_INIT(type) size,
+#endif
 
+#if PY_VERSION_HEX < 0x030900A4
+#  define Py_SET_TYPE(obj, type) ((Py_TYPE(obj) = (type)), (void)0)
+#  define Py_SET_SIZE(obj, size) ((Py_SIZE(obj) = (size)), (void)0)
 #endif
 
 

include/boost/python/exception_translator.hpp

@@ -7,7 +7,7 @@
 
 # include <boost/python/detail/prefix.hpp>
 
-# include <boost/bind.hpp>
+# include <boost/bind/bind.hpp>
 # include <boost/bind/placeholders.hpp>
 # include <boost/type.hpp>
 # include <boost/python/detail/translate_exception.hpp>
@@ -18,6 +18,7 @@ namespace boost { namespace python {
 template <class ExceptionType, class Translate>
 void register_exception_translator(Translate translate, boost::type<ExceptionType>* = 0)
 {
+    using namespace boost::placeholders;
     detail::register_exception_handler(
         boost::bind<bool>(detail::translate_exception<ExceptionType,Translate>(), _1, _2, translate)
         );

include/boost/python/instance_holder.hpp

@@ -38,7 +38,7 @@ struct BOOST_PYTHON_DECL instance_holder : private noncopyable
     // Allocate storage for an object of the given size at the given
     // offset in the Python instance<> object if bytes are available
     // there. Otherwise allocate size bytes of heap memory.
-    static void* allocate(PyObject*, std::size_t offset, std::size_t size);
+    static void* allocate(PyObject*, std::size_t offset, std::size_t size, std::size_t alignment = 1);
 
     // Deallocate storage from the heap if it was not carved out of
     // the given Python object by allocate(), above.

include/boost/python/iterator.hpp

@@ -22,7 +22,7 @@ works correctly. */
 #  pragma warning(disable: 4180)
 # endif
 
-# include <boost/bind.hpp>
+# include <boost/bind/bind.hpp>
 # include <boost/bind/protect.hpp>
 
 namespace boost { namespace python { 
@@ -40,6 +40,7 @@ namespace detail
     , Target&(*)()
   )
   {
+      using namespace boost::placeholders;
       return objects::make_iterator_function<Target>(
           boost::protect(boost::bind(get_start, _1))
         , boost::protect(boost::bind(get_finish, _1))

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/module_init.hpp

@@ -11,11 +11,41 @@
 
 # ifndef BOOST_PYTHON_MODULE_INIT
 
-namespace boost { namespace python { namespace detail {
+namespace boost { namespace python {
+
+#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(*)());
+BOOST_PYTHON_DECL PyObject* init_module(PyModuleDef&, void(*)(), bool gil_not_used = false);
 
 #else
 
@@ -27,7 +57,37 @@ BOOST_PYTHON_DECL PyObject* init_module(char const* name, void(*)());
 
 #  if PY_VERSION_HEX >= 0x03000000
 
-#   define _BOOST_PYTHON_MODULE_INIT(name) \
+#   ifdef HAS_CXX11
+#    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 = { \
@@ -53,6 +113,7 @@ 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
 
@@ -66,9 +127,15 @@ BOOST_PYTHON_DECL PyObject* init_module(char const* name, void(*)());
 
 #  endif
 
-#  define BOOST_PYTHON_MODULE_INIT(name)                       \
+#  if defined(HAS_CXX11) && (PY_VERSION_HEX >= 0x03000000)
+#   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,6 +17,7 @@
 #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/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/instance.hpp

@@ -6,7 +6,7 @@
 # define INSTANCE_DWA200295_HPP
 
 # include <boost/python/detail/prefix.hpp>
-
+# include <boost/python/detail/type_traits.hpp>
 # include <cstddef>
 
 namespace boost { namespace python
@@ -28,7 +28,7 @@ struct instance
     typedef typename boost::python::detail::type_with_alignment<
         boost::python::detail::alignment_of<Data>::value
     >::type align_t;
-          
+
     union
     {
         align_t align;
@@ -41,9 +41,10 @@ struct additional_instance_size
 {
     typedef instance<Data> instance_data;
     typedef instance<char> instance_char;
-    BOOST_STATIC_CONSTANT(
+    BOOST_STATIC_CONSTANT(std::size_t,
-        std::size_t, value = sizeof(instance_data)
+                          value = sizeof(instance_data) -
-                           - BOOST_PYTHON_OFFSETOF(instance_char,storage));
+                             BOOST_PYTHON_OFFSETOF(instance_char,storage) +
+                             boost::python::detail::alignment_of<Data>::value);
 };
 
 }}} // namespace boost::python::object

include/boost/python/object/make_holder.hpp

@@ -89,8 +89,9 @@ struct make_holder<N>
             BOOST_PP_ENUM_TRAILING_BINARY_PARAMS_Z(1, N, t, a))
         {
             typedef instance<Holder> instance_t;
-            
+
-            void* memory = Holder::allocate(p, offsetof(instance_t, storage), sizeof(Holder));
+            void* memory = Holder::allocate(p, offsetof(instance_t, storage), sizeof(Holder),
+                                            boost::python::detail::alignment_of<Holder>::value);
             try {
                 (new (memory) Holder(
                     p BOOST_PP_REPEAT_1ST(N, BOOST_PYTHON_DO_FORWARD_ARG, nil)))->install(p);

include/boost/python/object/make_instance.hpp

@@ -43,11 +43,14 @@ struct make_instance_impl
             
             // construct the new C++ object and install the pointer
             // in the Python object.
-            Derived::construct(&instance->storage, (PyObject*)instance, x)->install(raw_result);
+            Holder *holder =Derived::construct(instance->storage.bytes, (PyObject*)instance, x);
+            holder->install(raw_result);
               
             // Note the position of the internally-stored Holder,
             // for the sake of destruction
-            Py_SIZE(instance) = offsetof(instance_t, storage);
+            const size_t offset = reinterpret_cast<size_t>(holder) -
+              reinterpret_cast<size_t>(instance->storage.bytes) + offsetof(instance_t, storage);
+            Py_SET_SIZE(instance, offset);
 
             // Release ownership of the python object
             protect.cancel();
@@ -69,7 +72,10 @@ struct make_instance
     
     static inline Holder* construct(void* storage, PyObject* instance, reference_wrapper<T const> x)
     {
-        return new (storage) Holder(instance, x);
+        size_t allocated = objects::additional_instance_size<Holder>::value;
+        void* aligned_storage = ::boost::alignment::align(boost::python::detail::alignment_of<Holder>::value,
+                                                          sizeof(Holder), storage, allocated);
+        return new (aligned_storage) Holder(instance, x);
     }
 };
   

include/boost/python/object_core.hpp

@@ -419,6 +419,16 @@ 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);
 }

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))
               )
           );

include/boost/python/suite/indexing/detail/indexing_suite_detail.hpp

@@ -216,7 +216,13 @@ namespace boost { namespace python { namespace detail {
         {
             for (const_iterator i = proxies.begin(); i != proxies.end(); ++i)
             {
-                if ((*i)->ob_refcnt <= 0)
+                if (
+#if PY_VERSION_HEX < 0x03090000
+                (*i)->ob_refcnt
+#else
+                Py_REFCNT(*i)
+#endif
+                <= 0)
                 {
                     PyErr_SetString(PyExc_RuntimeError, 
                         "Invariant: Proxy vector in an inconsistent state");

meta/libraries.json

@@ -10,5 +10,6 @@
     ],
     "maintainers": [
 	"Stefan Seefeld <stefan -at- seefeld.name>"
-    ]
+    ],
+    "cxxstd": "03"
 }

src/converter/from_python.cpp

@@ -11,6 +11,7 @@
 
 #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>
@@ -145,6 +146,8 @@ 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;
@@ -157,9 +160,11 @@ namespace
   {
       unvisit(rvalue_from_python_chain const* chain)
           : chain(chain) {}
-      
+
       ~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);
@@ -222,7 +227,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/converter/registry.cpp

@@ -5,6 +5,7 @@
 #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>
@@ -112,9 +113,9 @@ registration::~registration()
 namespace // <unnamed>
 {
   typedef registration entry;
-  
+
   typedef std::set<entry> registry_t;
-  
+
 #ifndef BOOST_PYTHON_CONVERTER_REGISTRY_APPLE_MACH_WORKAROUND
   registry_t& entries()
   {
@@ -181,6 +182,8 @@ 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));
       
@@ -293,6 +296,8 @@ 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,6 +5,7 @@
 
 #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>
@@ -81,7 +82,7 @@ namespace
   {
       free_mem(char*p)
           : p(p) {}
-    
+
       ~free_mem()
       {
           std::free(p);
@@ -92,6 +93,7 @@ namespace
 
 bool cxxabi_cxa_demangle_is_broken()
 {
+    BOOST_PYTHON_LOCK_STATE();
     static bool was_tested = false;
     static bool is_broken = false;
     if (!was_tested) {
@@ -109,6 +111,8 @@ 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,8 +68,16 @@ 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,9 +10,21 @@
 #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!
@@ -20,8 +32,13 @@ BOOST_PYTHON_DECL bool handle_exception_impl(function0<void> f)
 {
     try
     {
-        if (detail::exception_handler::chain)
+        detail::exception_handler* handler_chain = nullptr;
-            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;
     }
@@ -80,6 +97,7 @@ 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/exec.cpp

@@ -109,14 +109,14 @@ 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
   // Let python open the file to avoid potential binary incompatibilities.
   PyObject *fo = Py_BuildValue("s", f);
-  FILE *fs = _Py_fopen(fo, "r"); // Private CPython API
+  FILE *fs = fopen(fo, "r");
   Py_DECREF(fo);
 #else
   // Let python open the file to avoid potential binary incompatibilities.
@@ -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/module.cpp

@@ -21,7 +21,7 @@ namespace
             object m_obj(((borrowed_reference_t*)m));
             scope current_module(m_obj);
 
-            handle_exception(init_function);
+            if (handle_exception(init_function)) return NULL;
         }
 
         return m;
@@ -38,10 +38,17 @@ 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, void(*init_function)())
+BOOST_PYTHON_DECL PyObject* init_module(PyModuleDef& moduledef,
+    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(
-        PyModule_Create(&moduledef),
+        mod,
         init_function);
 }
 

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

@@ -5,6 +5,7 @@
 
 #include <boost/python/detail/prefix.hpp>
 #include <boost/mpl/lambda.hpp> // #including this first is an intel6 workaround
+#include <boost/cstdint.hpp>
 
 #include <boost/python/object/class.hpp>
 #include <boost/python/object/instance.hpp>
@@ -208,7 +209,7 @@ namespace objects
   {
       if (static_data_object.tp_dict == 0)
       {
-          Py_TYPE(&static_data_object) = &PyType_Type;
+          Py_SET_TYPE(&static_data_object, &PyType_Type);
           static_data_object.tp_base = &PyProperty_Type;
           if (PyType_Ready(&static_data_object))
               return 0;
@@ -316,7 +317,7 @@ namespace objects
   {
       if (class_metatype_object.tp_dict == 0)
       {
-          Py_TYPE(&class_metatype_object) = &PyType_Type;
+          Py_SET_TYPE(&class_metatype_object, &PyType_Type);
           class_metatype_object.tp_base = &PyType_Type;
           if (PyType_Ready(&class_metatype_object))
               return type_handle();
@@ -332,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
@@ -374,12 +376,7 @@ namespace objects
               // like, so we'll store the total size of the object
               // there. A negative number indicates that the extra
               // instance memory is not yet allocated to any holders.
-#if PY_VERSION_HEX >= 0x02060000
+              Py_SET_SIZE(result,-static_cast<int>(offsetof(instance<>,storage) + instance_size));
-              Py_SIZE(result) =
-#else
-              result->ob_size =
-#endif
-                  -(static_cast<int>(offsetof(instance<>,storage) + instance_size));
           }
           return (PyObject*)result;
       }
@@ -470,7 +467,7 @@ namespace objects
   {
       if (class_type_object.tp_dict == 0)
       {
-          Py_TYPE(&class_type_object) = incref(class_metatype().get());
+          Py_SET_TYPE(&class_type_object, incref(class_metatype().get()));
           class_type_object.tp_base = &PyBaseObject_Type;
           if (PyType_Ready(&class_type_object))
               return type_handle();
@@ -506,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
@@ -568,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;
@@ -726,28 +736,46 @@ namespace objects
 } // namespace objects
 
 
-void* instance_holder::allocate(PyObject* self_, std::size_t holder_offset, std::size_t holder_size)
+typedef unsigned int alignment_marker_t;
+
+void* instance_holder::allocate(PyObject* self_, std::size_t holder_offset, std::size_t holder_size, std::size_t alignment)
 {
     assert(PyType_IsSubtype(Py_TYPE(Py_TYPE(self_)), &class_metatype_object));
     objects::instance<>* self = (objects::instance<>*)self_;
     
-    int total_size_needed = holder_offset + holder_size;
+    int total_size_needed = holder_offset + holder_size + alignment - 1;
     
     if (-Py_SIZE(self) >= total_size_needed)
     {
         // holder_offset should at least point into the variable-sized part
         assert(holder_offset >= offsetof(objects::instance<>,storage));
 
+        size_t allocated = holder_size + alignment;
+        void* storage = (char*)self + holder_offset;
+        void* aligned_storage = ::boost::alignment::align(alignment, holder_size, storage, allocated);
+
         // Record the fact that the storage is occupied, noting where it starts
-        Py_SIZE(self) = holder_offset;
+        const size_t offset = reinterpret_cast<uintptr_t>(aligned_storage) - reinterpret_cast<uintptr_t>(storage) + holder_offset;
-        return (char*)self + holder_offset;
+        Py_SET_SIZE(self, offset);
+        return (char*)self + offset;
     }
     else
     {
-        void* const result = PyMem_Malloc(holder_size);
+        const size_t base_allocation = sizeof(alignment_marker_t) + holder_size + alignment - 1;
-        if (result == 0)
+        void* const base_storage = PyMem_Malloc(base_allocation);
+        if (base_storage == 0)
             throw std::bad_alloc();
-        return result;
+
+        const uintptr_t x = reinterpret_cast<uintptr_t>(base_storage) + sizeof(alignment_marker_t);
+        // Padding required to align the start of a data structure is: (alignment - (x % alignment)) % alignment
+        // Since the alignment is a power of two, the formula can be simplified with bitwise AND operator as follow:
+        const uintptr_t padding = (alignment - (x & (alignment - 1))) & (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);
+        alignment_marker_t* const marker_storage = reinterpret_cast<alignment_marker_t *>((char *)aligned_storage - sizeof(alignment_marker_t));
+        *marker_storage = static_cast<alignment_marker_t>(padding);
+        return aligned_storage;
     }
 }
 
@@ -757,7 +785,9 @@ void instance_holder::deallocate(PyObject* self_, void* storage) throw()
     objects::instance<>* self = (objects::instance<>*)self_;
     if (storage != (char*)self + Py_SIZE(self))
     {
-        PyMem_Free(storage);
+        alignment_marker_t* marker_storage = reinterpret_cast<alignment_marker_t *>((char *)storage - sizeof(alignment_marker_t));
+        void *malloced_storage = (char *) storage - sizeof(alignment_marker_t) - (*marker_storage);
+        PyMem_Free(malloced_storage);
     }
 }
 

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
 {
@@ -153,7 +157,7 @@ namespace
   {
       if (enum_type_object.tp_dict == 0)
       {
-          Py_TYPE(&enum_type_object) = incref(&PyType_Type);
+          Py_SET_TYPE(&enum_type_object, incref(&PyType_Type));
 #if PY_VERSION_HEX >= 0x03000000
           enum_type_object.tp_base = &PyLong_Type;
 #else
@@ -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

@@ -21,7 +21,7 @@
 #include <boost/python/detail/none.hpp>
 #include <boost/mpl/vector/vector10.hpp>
 
-#include <boost/bind.hpp>
+#include <boost/bind/bind.hpp>
 
 #include <algorithm>
 #include <cstring>
@@ -107,7 +107,7 @@ function::function(
     PyObject* p = this;
     if (Py_TYPE(&function_type) == 0)
     {
-        Py_TYPE(&function_type) = &PyType_Type;
+        Py_SET_TYPE(&function_type, &PyType_Type);
         ::PyType_Ready(&function_type);
     }
     
@@ -161,7 +161,6 @@ PyObject* function::call(PyObject* args, PyObject* keywords) const
                     else
                     {
                         // build a new arg tuple, will adjust its size later
-                        assert(max_arity <= static_cast<std::size_t>(ssize_t_max));
                         inner_args = handle<>(
                             PyTuple_New(static_cast<ssize_t>(max_arity)));
 
@@ -419,6 +418,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 +512,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 +568,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 +583,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 +701,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,58 @@ 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;
+#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(
+                        type_module_name,
+                        current_module_name.ptr(),
+                        Py_NE
+                    ) != 0
+                ) {
+                    str result = str("%s.%s" % make_tuple(handle<>(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 {
             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 +191,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 +234,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/object/inheritance.cpp

@@ -4,6 +4,7 @@
 // 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>
@@ -11,7 +12,7 @@
 #include <boost/graph/adjacency_list.hpp>
 #include <boost/graph/reverse_graph.hpp>
 #include <boost/property_map/property_map.hpp>
-#include <boost/bind.hpp>
+#include <boost/bind/bind.hpp>
 #include <boost/integer_traits.hpp>
 #include <boost/tuple/tuple.hpp>
 #include <boost/tuple/tuple_comparison.hpp>
@@ -184,6 +185,7 @@ namespace
   // map a type to a position in the index
   inline type_index_t::iterator type_position(class_id type)
   {
+      using namespace boost::placeholders;
       typedef index_entry entry;
       
       return std::lower_bound(
@@ -389,6 +391,8 @@ 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)
@@ -451,6 +455,8 @@ 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;
@@ -489,6 +495,7 @@ 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/object/iterator.cpp

@@ -5,7 +5,7 @@
 
 #include <boost/python/object/iterator_core.hpp>
 #include <boost/python/object/function_object.hpp>
-#include <boost/bind.hpp>
+#include <boost/bind/bind.hpp>
 #include <boost/mpl/vector/vector10.hpp>
 
 namespace boost { namespace python { namespace objects { 

src/object/life_support.cpp

@@ -93,7 +93,7 @@ PyObject* make_nurse_and_patient(PyObject* nurse, PyObject* patient)
     
     if (Py_TYPE(&life_support_type) == 0)
     {
-        Py_TYPE(&life_support_type) = &PyType_Type;
+        Py_SET_TYPE(&life_support_type, &PyType_Type);
         PyType_Ready(&life_support_type);
     }
     

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

src/wrapper.cpp

@@ -21,20 +21,28 @@ namespace detail
                           this->m_self, const_cast<char*>(name))))
           )
           {
-              PyObject* borrowed_f = 0;
+              PyObject* class_f = 0;
-            
+
               if (
                   PyMethod_Check(m.get())
                   && PyMethod_GET_SELF(m.get()) == this->m_self
                   && class_object->tp_dict != 0
               )
               {
-                  borrowed_f = ::PyDict_GetItemString(
+#if PY_VERSION_HEX >= 0x030D0000
+                  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
               }
-              if (borrowed_f != PyMethod_GET_FUNCTION(m.get()))
+              bool is_override = (class_f != PyMethod_GET_FUNCTION(m.get()));
+              Py_XDECREF(class_f);
+              if (is_override)
                   return override(m);
           }
       }

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 ]
@@ -132,6 +146,7 @@ bpl-test crossmod_exception
 
 [ bpl-test object ]
 [ bpl-test class ]
+[ bpl-test aligned_class ]
 [ bpl-test list ]
 [ bpl-test long ]
 [ bpl-test dict ]
@@ -191,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)
@@ -211,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/aligned_class.cpp

@@ -0,0 +1,33 @@
+// 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)
+#include <boost/python/module.hpp>
+#include <boost/python/def.hpp>
+#include <boost/python/object.hpp>
+#include <boost/python/class.hpp>
+#include <boost/assert.hpp>
+#include <boost/cstdint.hpp>
+
+using namespace boost::python;
+
+struct BOOST_ALIGNMENT(32) X
+{
+    int x;
+    BOOST_ALIGNMENT(32) float f;
+    X(int n, float _f) : x(n), f(_f)
+    {
+        BOOST_ASSERT((reinterpret_cast<uintptr_t>(&f) % 32) == 0);
+    }
+};
+
+int x_function(X& x) { return x.x;}
+float f_function(X& x) { return x.f;}
+
+BOOST_PYTHON_MODULE(aligned_class_ext)
+{
+    class_<X>("X", init<int, float>());
+    def("x_function", x_function);
+    def("f_function", f_function);
+}
+
+#include "module_tail.cpp"

test/aligned_class.py

@@ -0,0 +1,44 @@
+# 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)
+'''
+>>> from aligned_class_ext import *
+
+Ensure sanity:
+
+    >>> x = X(42, 16)
+    >>> x_function(x)
+    42
+    >>> f_function(x)
+    16.0
+
+Demonstrate extraction in the presence of metaclass changes:
+
+    >>> class MetaX(X.__class__):
+    ...     def __new__(cls, *args):
+    ...         return super(MetaX, cls).__new__(cls, *args)
+    >>> class XPlusMetatype(X):
+    ...     __metaclass__ = MetaX
+    >>> x = XPlusMetatype(42, 16)
+    >>> x_function(x)
+    42
+    >>> f_function(x)
+    16.0
+
+
+'''
+
+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/back_reference.cpp

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

test/copy_ctor_mutates_rhs.cpp

@@ -9,14 +9,13 @@
 
 struct foo
 {
-    operator std::auto_ptr<int>&() const;
+    operator std::shared_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

@@ -67,6 +67,8 @@ for t in [('injected',),
           ('args',),
           ('raw_ctor',),
           ('exception_translator',),
+          ('module_init_exception',),
+          ('module_nogil',),
           ('test_enum', ['enum_ext']),
           ('test_cltree', ['cltree']),
           ('newtest', ['m1', 'm2']),
@@ -78,6 +80,8 @@ for t in [('injected',),
           ('callbacks',),
           ('defaults',),
           ('object',),
+          ('class',),
+          ('aligned_class',),
           ('list',),
           ('long',),
           ('dict',),
@@ -115,10 +119,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/import_.cpp

@@ -6,7 +6,7 @@
 #include <boost/python.hpp>
 
 #include <boost/detail/lightweight_test.hpp>
-#include <boost/bind.hpp>
+#include <boost/bind/bind.hpp>
 #include <iostream>
 #include <sstream>
 

test/injected.cpp

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

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/module_init_exception.cpp

@@ -0,0 +1,14 @@
+// Copyright (C) 2003 Rational Discovery LLC
+// 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)
+
+#include <boost/python/module.hpp>
+#include <stdexcept>
+
+using namespace boost::python;
+
+BOOST_PYTHON_MODULE(module_init_exception_ext)
+{
+    throw std::runtime_error("Module init failed");
+}

test/module_init_exception.py

@@ -0,0 +1,12 @@
+# Copyright (C) 2003 Rational Discovery LLC.  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)
+
+print("running...")
+
+try:
+    import module_init_exception_ext
+except RuntimeError as e:
+    print(e)
+
+print("Done.")

test/module_nogil.cpp

@@ -0,0 +1,25 @@
+// 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

@@ -0,0 +1,29 @@
+"""
+>>> 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/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/numpy/dtype.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright Jim Bosch & Ankit Daftery 2010-2012.
 # Distributed under the Boost Software License, Version 1.0.
@@ -15,7 +15,7 @@ if (sys.version_info.major >= 3):
 class DtypeTestCase(unittest.TestCase):
     
     def assertEquivalent(self, a, b):
-        return self.assert_(dtype_ext.equivalent(a, b), "%r is not equivalent to %r")
+        return self.assertTrue(dtype_ext.equivalent(a, b), "%r is not equivalent to %r")
 
     def testIntegers(self):
         for bits in (8, 16, 32, 64):

test/numpy/indexing.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright Jim Bosch & Ankit Daftery 2010-2012.
 # Distributed under the Boost Software License, Version 1.0.

test/numpy/ndarray.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright Jim Bosch & Ankit Daftery 2010-2012.
 # Distributed under the Boost Software License, Version 1.0.
@@ -19,7 +19,7 @@ class TestNdarray(unittest.TestCase):
                 a1 = ndarray_ext.zeros(shape,dt)
                 a2 = v.reshape(a1.shape)
                 self.assertEqual(shape,a1.shape)
-                self.assert_((a1 == a2).all())
+                self.assertTrue((a1 == a2).all())
 
     def testNdzeros_matrix(self):    
         for dtp in (numpy.int16, numpy.int32, numpy.float32, numpy.complex128):
@@ -28,7 +28,7 @@ class TestNdarray(unittest.TestCase):
             a1 = ndarray_ext.zeros_matrix(shape, dt)
             a2 = numpy.matrix(numpy.zeros(shape, dtype=dtp))
             self.assertEqual(shape,a1.shape)
-            self.assert_((a1 == a2).all())
+            self.assertTrue((a1 == a2).all())
             self.assertEqual(type(a1), type(a2))
 
     def testNdarray(self):    
@@ -38,8 +38,8 @@ class TestNdarray(unittest.TestCase):
             dt = numpy.dtype(dtp)
             a1 = ndarray_ext.array(a)
             a2 = ndarray_ext.array(a,dt)
-            self.assert_((a1 == v).all())
+            self.assertTrue((a1 == v).all())
-            self.assert_((a2 == v).all())
+            self.assertTrue((a2 == v).all())
             for shape in ((60,),(6,10),(4,3,5),(2,2,3,5)):
                 a1 = a1.reshape(shape)
                 self.assertEqual(shape,a1.shape)

test/numpy/shapes.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright Jim Bosch & Ankit Daftery 2010-2012.
 # Distributed under the Boost Software License, Version 1.0.

test/numpy/templates.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright Jim Bosch & Ankit Daftery 2010-2012.
 # Distributed under the Boost Software License, Version 1.0.
@@ -18,7 +18,7 @@ class TestTemplates(unittest.TestCase):
                 a1 = numpy.zeros(shape, dtype=dtype)
                 a2 = v.reshape(a1.shape)
                 templates_ext.fill(a1)
-                self.assert_((a1 == a2).all())
+                self.assertTrue((a1 == a2).all())
         a1 = numpy.zeros((12,), dtype=numpy.float64)
         self.assertRaises(TypeError, templates_ext.fill, a1)
         a1 = numpy.zeros((12,2,3), dtype=numpy.float32)

test/numpy/ufunc.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Copyright Jim Bosch & Ankit Daftery 2010-2012.
 # Distributed under the Boost Software License, Version 1.0.
@@ -8,7 +8,10 @@
 import ufunc_ext
 import unittest
 import numpy
-from numpy.testing.utils import assert_array_almost_equal
+try:
+    from numpy.testing import assert_array_almost_equal
+except ImportError:
+    from numpy.testing.utils import assert_array_almost_equal
 
 class TestUnary(unittest.TestCase):
 
@@ -24,7 +27,7 @@ class TestUnary(unittest.TestCase):
         assert_array_almost_equal(b, a*2.0) 
         c = numpy.zeros(5, dtype=float)
         d = f(a,output=c)
-        self.assert_(c is d)
+        self.assertTrue((c == d).all())
         assert_array_almost_equal(d, a*2.0) 
 
     def testList(self):
@@ -47,7 +50,7 @@ class TestBinary(unittest.TestCase):
         assert_array_almost_equal(f(a,b), (a*2+b*3)) 
         c = numpy.zeros(5, dtype=float)
         d = f(a,b,output=c)
-        self.assert_(c is d)
+        self.assertTrue((c == d).all())
         assert_array_almost_equal(d, a*2 + b*3) 
         assert_array_almost_equal(f(a, 2.0), a*2 + 6.0) 
         assert_array_almost_equal(f(1.0, b), 2.0 + b*3) 

test/operators_wrapper.cpp

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

test/pickle1.py

@@ -9,8 +9,10 @@ r'''>>> import pickle1_ext
     1
     >>> pickle1_ext.world.__name__
     'world'
-    >>> pickle1_ext.world('Hello').__reduce__()
+    >>> pickle1_ext.world('Hello').__reduce__()  # doctest: +PY310
     (<class 'pickle1_ext.world'>, ('Hello',))
+    >>> pickle1_ext.world('Hello').__reduce__()  # doctest: +PY311
+    (<class 'pickle1_ext.world'>, ('Hello',), None)
     >>> wd = pickle1_ext.world('California')
     >>> pstr = pickle.dumps(wd)
     >>> wl = pickle.loads(pstr)
@@ -31,7 +33,27 @@ def run(args = None):
 
     if args is not None:
         sys.argv = args
-    return doctest.testmod(sys.modules.get(__name__))
+
+    # > https://docs.python.org/3.11/library/pickle.html#object.__reduce__
+    # object.__reduce__() returns
+    # - python 3.10 or prior: a 2-element tuple
+    # - python 3.11 or later: a 3-element tuple (object's state added)
+    PY310 = doctest.register_optionflag("PY310")
+    PY311 = doctest.register_optionflag("PY311")
+
+    class ConditionalChecker(doctest.OutputChecker):
+        def check_output(self, want, got, optionflags):
+            if (optionflags & PY311) and (sys.version_info[:2] < (3, 11)):
+                return True
+            if (optionflags & PY310) and (sys.version_info[:2] >= (3, 11)):
+                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/pickle4.py

@@ -12,8 +12,10 @@ r'''>>> import pickle4_ext
     1
     >>> pickle4_ext.world.__name__
     'world'
-    >>> pickle4_ext.world('Hello').__reduce__()
+    >>> pickle4_ext.world('Hello').__reduce__()  # doctest: +PY310
     (<class 'pickle4_ext.world'>, ('Hello',))
+    >>> pickle4_ext.world('Hello').__reduce__()  # doctest: +PY311
+    (<class 'pickle4_ext.world'>, ('Hello',), None)
     >>> wd = pickle4_ext.world('California')
     >>> pstr = pickle.dumps(wd)
     >>> wl = pickle.loads(pstr)
@@ -29,7 +31,27 @@ def run(args = None):
 
     if args is not None:
         sys.argv = args
-    return doctest.testmod(sys.modules.get(__name__))
+
+    # > https://docs.python.org/3.11/library/pickle.html#object.__reduce__
+    # object.__reduce__() returns
+    # - python 3.10 or prior: a 2-element tuple
+    # - python 3.11 or later: a 3-element tuple (object's state added)
+    PY310 = doctest.register_optionflag("PY310")
+    PY311 = doctest.register_optionflag("PY311")
+
+    class ConditionalChecker(doctest.OutputChecker):
+        def check_output(self, want, got, optionflags):
+            if (optionflags & PY311) and (sys.version_info[:2] < (3, 11)):
+                return True
+            if (optionflags & PY310) and (sys.version_info[:2] >= (3, 11)):
+                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
@@ -53,11 +56,10 @@ class instance count from object:
 1
 
 as expected you can't assign new value to read only property
->>> x1.value_r = 2
+>>> x1.value_r = 2  # doctest: +ELLIPSIS
 Traceback (most recent call last):
-  File "properties.py", line 49, in ?
+    ...
-    x1.value_r = 2
+AttributeError: ...
-AttributeError: can't set attribute
 
 setting value_rw to 2. value_direct: 
 >>> x1.value_rw = 2
@@ -84,8 +86,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/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::auto_ptr<Base>
+    assert_holder<Base,std::unique_ptr<Base>
-        ,pointer_holder<std::auto_ptr<Base>,Base> >();
+        ,pointer_holder<std::unique_ptr<Base>,Base> >();
     
-    assert_holder<Base,std::auto_ptr<Derived>
+    assert_holder<Base,std::unique_ptr<Derived>
-        ,pointer_holder_back_reference<std::auto_ptr<Derived>,Base> >();
+        ,pointer_holder_back_reference<std::unique_ptr<Derived>,Base> >();
 
-    assert_holder<BR,std::auto_ptr<BR>
+    assert_holder<BR,std::unique_ptr<BR>
-        ,pointer_holder_back_reference<std::auto_ptr<BR>,BR> > ();
+        ,pointer_holder_back_reference<std::unique_ptr<BR>,BR> > ();
 
     return 0;
 }