diff --git a/thirdparty/pybind11/pybind11/.appveyor.yml b/thirdparty/pybind11/pybind11/.appveyor.yml
deleted file mode 100644
index b908d076318662a1d2cd20fe2ce0e02910e0ec6d..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/.appveyor.yml
+++ /dev/null
@@ -1,40 +0,0 @@
-version: 1.0.{build}
-image:
-- Visual Studio 2017
-- Visual Studio 2015
-test: off
-platform:
-- x64
-- x86
-environment:
- matrix:
- - CONDA: 36
- - CONDA: 27
-matrix:
- fast_finish: true # Stop remaining jobs after a job failure
-install:
-- ps: |
- if ($env:PLATFORM -eq "x64") { $env:CMAKE_ARCH = "x64" }
- if ($env:APPVEYOR_JOB_NAME -like "*Visual Studio 2017*") { $env:CMAKE_GENERATOR = "Visual Studio 15 2017" }
- else { $env:CMAKE_GENERATOR = "Visual Studio 14 2015" }
- if ($env:PYTHON) {
- if ($env:PLATFORM -eq "x64") { $env:PYTHON = "$env:PYTHON-x64" }
- $env:PATH = "C:\Python$env:PYTHON\;C:\Python$env:PYTHON\Scripts\;$env:PATH"
- pip install --disable-pip-version-check --user --upgrade pip wheel
- pip install pytest numpy scipy
- } elseif ($env:CONDA) {
- if ($env:CONDA -eq "27") { $env:CONDA = "" }
- if ($env:PLATFORM -eq "x64") { $env:CONDA = "$env:CONDA-x64" }
- $env:PATH = "C:\Miniconda$env:CONDA\;C:\Miniconda$env:CONDA\Scripts\;$env:PATH"
- conda install -y -q pytest numpy scipy
- }
-- ps: |
- Start-FileDownload 'http://bitbucket.org/eigen/eigen/get/3.3.0.zip'
- 7z x 3.3.0.zip -y > $null
- $env:CMAKE_INCLUDE_PATH = "eigen-eigen-26667be4f70b"
-build_script:
-- cmake -G "%CMAKE_GENERATOR%" -A "%CMAKE_ARCH%" -DPYBIND11_WERROR=ON
-- set MSBuildLogger="C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll"
-- cmake --build . --config Release --target pytest -- /v:m /logger:%MSBuildLogger%
-- cmake --build . --config Release --target test_cmake_build -- /v:m /logger:%MSBuildLogger%
-on_failure: if exist "tests\test_cmake_build" type tests\test_cmake_build\*.log
diff --git a/thirdparty/pybind11/pybind11/.gitignore b/thirdparty/pybind11/pybind11/.gitignore
deleted file mode 100644
index c444c17ed19c129208ad7126240f1118d8474b3d..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/.gitignore
+++ /dev/null
@@ -1,37 +0,0 @@
-CMakeCache.txt
-CMakeFiles
-Makefile
-cmake_install.cmake
-.DS_Store
-*.so
-*.pyd
-*.dll
-*.sln
-*.sdf
-*.opensdf
-*.vcxproj
-*.filters
-example.dir
-Win32
-x64
-Release
-Debug
-.vs
-CTestTestfile.cmake
-Testing
-autogen
-MANIFEST
-/.ninja_*
-/*.ninja
-/docs/.build
-*.py[co]
-*.egg-info
-*~
-.DS_Store
-/dist
-/build
-/cmake/
-.cache/
-sosize-*.txt
-pybind11Config*.cmake
-pybind11Targets.cmake
diff --git a/thirdparty/pybind11/pybind11/.gitmodules b/thirdparty/pybind11/pybind11/.gitmodules
deleted file mode 100644
index 5191885e77990ce627140937477f08643dc9499e..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/.gitmodules
+++ /dev/null
@@ -1,3 +0,0 @@
-[submodule "tools/clang"]
- path = tools/clang
- url = https://github.com/wjakob/clang-cindex-python3
diff --git a/thirdparty/pybind11/pybind11/.readthedocs.yml b/thirdparty/pybind11/pybind11/.readthedocs.yml
deleted file mode 100644
index c9c61617ca9b13a3e31d33226c52ba9529872a0d..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/.readthedocs.yml
+++ /dev/null
@@ -1,3 +0,0 @@
-python:
- version: 3
-requirements_file: docs/requirements.txt
diff --git a/thirdparty/pybind11/pybind11/.travis.yml b/thirdparty/pybind11/pybind11/.travis.yml
deleted file mode 100644
index a3e99a003d14d3b372488f0de36ce90dd619952a..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/.travis.yml
+++ /dev/null
@@ -1,194 +0,0 @@
-language: cpp
-sudo: false
-matrix:
- include:
- - os: linux
- env: PYTHON=2.7 CPP=11 GCC=4.8
- addons:
- apt:
- sources: [ubuntu-toolchain-r-test, kubuntu-backports]
- packages: [g++-4.8, cmake]
- - os: linux
- env: PYTHON=3.5 CPP=11 GCC=4.8
- addons:
- apt:
- sources: [ubuntu-toolchain-r-test, kubuntu-backports, deadsnakes]
- packages: [g++-4.8, cmake, python3.5-dev]
- - sudo: true
- services: docker
- env: PYTHON=2.7 CPP=14 GCC=6
- - sudo: true
- services: docker
- env: PYTHON=3.5 CPP=14 GCC=6 DEBUG=1
- - sudo: true
- services: docker
- env: PYTHON=3.5 CPP=17 GCC=7
- - sudo: true
- services: docker
- env: PYTHON=3.5 CPP=17 CLANG=4.0
- - os: osx
- osx_image: xcode7.3
- env: PYTHON=2.7 CPP=14 CLANG
- - os: osx
- osx_image: xcode7.3
- env: PYTHON=3.6 CPP=14 CLANG
- # Test a PyPy 2.7 build
- - os: linux
- dist: trusty
- env: PYPY=5.7 PYTHON=2.7 CPP=11 GCC=4.8
- addons:
- apt:
- packages: [g++-4.8, cmake]
- - sudo: true
- services: docker
- env: ARCH=i386 PYTHON=3.5 CPP=14 GCC=6
- # This next one does a make install *before* testing, then builds the tests against the installed version:
- - sudo: true
- services: docker
- env: PYTHON=3.5 CPP=14 CLANG=3.9 INSTALL=1
- script:
- - |
- $SCRIPT_RUN_PREFIX sh -c "set -e
- cmake ${CMAKE_EXTRA_ARGS} -DPYBIND11_INSTALL=1 -DPYBIND11_TEST=0
- make install
- cp -a tests /pybind11-tests
- mkdir /build-tests && cd /build-tests
- cmake ../pybind11-tests ${CMAKE_EXTRA_ARGS} -DPYBIND11_WERROR=ON
- make pytest -j 2"
- # A barebones build makes sure everything still works without optional deps (numpy/scipy/eigen)
- # and also tests the automatic discovery functions in CMake (Python version, C++ standard).
- - os: linux
- env: BAREBONES
- addons:
- apt:
- sources: [ubuntu-toolchain-r-test, kubuntu-backports]
- packages: [g++-4.8, cmake]
- install: pip install pytest
- # Documentation build:
- - os: linux
- language: docs
- env: DOCS STYLE LINT
- install:
- - pip install --upgrade sphinx sphinx_rtd_theme flake8 pep8-naming
- - |
- curl -fsSL ftp://ftp.stack.nl/pub/users/dimitri/doxygen-1.8.12.linux.bin.tar.gz | tar xz
- export PATH="$PWD/doxygen-1.8.12/bin:$PATH"
- pip install https://github.com/michaeljones/breathe/archive/master.zip
- script:
- - make -C docs html SPHINX_OPTIONS=-W
- - tools/check-style.sh
- - flake8
- allow_failures:
- - env: PYTHON=3.5 CPP=17 GCC=7
- - env: PYTHON=3.5 CPP=17 CLANG=4.0
-cache:
- directories:
- - $HOME/.cache/pip
- - $HOME/Library/Caches/pip
-before_install:
-- |
- # Configure build variables
- if [ "$TRAVIS_OS_NAME" = "linux" ]; then
- if [ -n "$CLANG" ]; then
- export CXX=clang++-$CLANG CC=clang-$CLANG COMPILER_PACKAGES="clang-$CLANG llvm-$CLANG-dev"
- if [ "$CLANG" = "4.0" ]; then export CXXFLAGS="-stdlib=libc++"; fi
- else
- if [ -z "$GCC" ]; then export GCC=4.8
- else export COMPILER_PACKAGES=g++-$GCC
- fi
- export CXX=g++-$GCC CC=gcc-$GCC
- fi
- if [ "$CLANG" = "4.0" ]; then export DOCKER=debian:sid
- elif [ "$GCC" = "6" ] || [ -n "$CLANG" ]; then export DOCKER=${ARCH:+$ARCH/}debian:testing
- elif [ "$GCC" = "7" ]; then export DOCKER=debian:experimental APT_GET_EXTRA="-t experimental"
- fi
- elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
- export CXX=clang++ CC=clang;
- fi
- if [ -n "$CPP" ]; then export CPP=-std=c++$CPP; fi
- if [ "${PYTHON:0:1}" = "3" ]; then export PY=3; fi
- if [ "$PYPY" = "5.7" ]; then
- curl -fSL https://bitbucket.org/pypy/pypy/downloads/pypy2-v5.7.0-linux64.tar.bz2 | tar -xj
- export PYPY_BINARY=$(echo `pwd`/pypy2-v5.7.0-linux64/bin/pypy)
- export CMAKE_EXTRA_ARGS="-DPYTHON_EXECUTABLE:FILEPATH=$PYPY_BINARY"
- fi
- if [ -n "$DEBUG" ]; then export CMAKE_EXTRA_ARGS="-DCMAKE_BUILD_TYPE=Debug"; fi
-- |
- # Initialize environment
- if [ -n "$PYPY" ]; then
- $PYPY_BINARY -m ensurepip
- $PYPY_BINARY -m pip install pytest
- elif [ -n "$DOCKER" ]; then
- docker pull $DOCKER
- # Disable LTO with gcc until gcc 79296 is fixed:
- if [ -n "$GCC" ]; then export CMAKE_EXTRA_ARGS="${CMAKE_EXTRA_ARGS} -DPYBIND11_LTO_CXX_FLAGS="; fi
-
- export containerid=$(docker run --detach --tty \
- --volume="$PWD":/pybind11 --workdir=/pybind11 \
- --env="CXXFLAGS=$CXXFLAGS" \
- --env="CC=$CC" --env="CXX=$CXX" --env="DEBIAN_FRONTEND=$DEBIAN_FRONTEND" \
- --env=GCC_COLORS=\ \
- $DOCKER)
- export SCRIPT_RUN_PREFIX="docker exec --tty $containerid"
- $SCRIPT_RUN_PREFIX sh -c 'for s in 0 15; do sleep $s; apt-get update && apt-get -qy dist-upgrade && break; done'
- # gcc-7 currently generates warnings; some are upstream bugs, so just turn off -Werror for now
- if [ "$GCC" = "7" ]; then WERROR=off; fi
- else
- if [ "$TRAVIS_OS_NAME" = "linux" ]; then
- pip install --user --upgrade pip virtualenv
- virtualenv -p python$PYTHON venv
- elif [ "$TRAVIS_OS_NAME" = "osx" ]; then
- if [ "$PY" = "3" ]; then
- brew update; brew install python$PY;
- else
- curl -fsSL -O https://bootstrap.pypa.io/get-pip.py
- sudo -H python get-pip.py
- fi
- pip$PY install --user --upgrade pip virtualenv
- python$PY -m virtualenv venv
- fi
- source venv/bin/activate
- fi
-install:
-- |
- # Install dependencies
- if [ -n "$DOCKER" ]; then
- if [ -n "$DEBUG" ]; then
- PY_DEBUG="python$PY-dbg python$PY-scipy-dbg"
- export CMAKE_EXTRA_ARGS="${CMAKE_EXTRA_ARGS} -DPYTHON_EXECUTABLE=/usr/bin/python${PYTHON}dm"
- fi
- $SCRIPT_RUN_PREFIX sh -c "for s in 0 15; do sleep \$s; \
- apt-get -qy --no-install-recommends $APT_GET_EXTRA install \
- $PY_DEBUG python$PY-dev python$PY-pytest python$PY-scipy \
- libeigen3-dev cmake make ${COMPILER_PACKAGES} && break; done"
-
- if [ "$CLANG" = "4.0" ]; then
- # Neither debian nor llvm provide a libc++ deb; luckily it's fairly quick
- # to build and install, so do it ourselves:
- git clone --depth=1 https://github.com/llvm-mirror/llvm.git llvm-source
- git clone https://github.com/llvm-mirror/libcxx.git llvm-source/projects/libcxx -b release_40
- git clone https://github.com/llvm-mirror/libcxxabi.git llvm-source/projects/libcxxabi -b release_40
- $SCRIPT_RUN_PREFIX sh -c "mkdir llvm-build && cd llvm-build && \
- CXXFLAGS= cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr ../llvm-source && \
- make -j2 install-cxxabi install-cxx && \
- cp -a include/c++/v1/*cxxabi*.h /usr/include/c++/v1"
-
- if [ "$CPP" = "-std=c++17" ]; then export CPP="-std=c++1z"; fi
- fi
- elif [ -z "$PYPY" ]; then
- pip install numpy scipy pytest
-
- wget -q -O eigen.tar.gz https://bitbucket.org/eigen/eigen/get/3.3.0.tar.gz
- tar xzf eigen.tar.gz
- export CMAKE_EXTRA_ARGS="${CMAKE_EXTRA_ARGS} -DCMAKE_INCLUDE_PATH=$PWD/eigen-eigen-26667be4f70b"
- fi
-script:
-- $SCRIPT_RUN_PREFIX cmake ${CMAKE_EXTRA_ARGS}
- -DPYBIND11_PYTHON_VERSION=$PYTHON
- -DPYBIND11_CPP_STANDARD=$CPP
- -DPYBIND11_WERROR=${WERROR:-ON}
-- $SCRIPT_RUN_PREFIX make pytest -j 2
-- $SCRIPT_RUN_PREFIX make test_cmake_build
-after_failure: cat tests/test_cmake_build/*.log
-after_script:
-- if [ -n "$DOCKER" ]; then docker stop "$containerid"; docker rm "$containerid"; fi
diff --git a/thirdparty/pybind11/pybind11/CMakeLists.txt b/thirdparty/pybind11/pybind11/CMakeLists.txt
deleted file mode 100644
index 16f1d67f1cadb51e36330592f74ad27df91a5214..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/CMakeLists.txt
+++ /dev/null
@@ -1,124 +0,0 @@
-# CMakeLists.txt -- Build system for the pybind11 modules
-#
-# Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
-#
-# All rights reserved. Use of this source code is governed by a
-# BSD-style license that can be found in the LICENSE file.
-
-cmake_minimum_required(VERSION 2.8.12)
-
-if (POLICY CMP0048)
- # cmake warns if loaded from a min-3.0-required parent dir, so silence the warning:
- cmake_policy(SET CMP0048 NEW)
-endif()
-
-project(pybind11)
-
-# Check if pybind11 is being used directly or via add_subdirectory
-set(PYBIND11_MASTER_PROJECT OFF)
-if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
- set(PYBIND11_MASTER_PROJECT ON)
-endif()
-
-option(PYBIND11_INSTALL "Install pybind11 header files?" ${PYBIND11_MASTER_PROJECT})
-option(PYBIND11_TEST "Build pybind11 test suite?" ${PYBIND11_MASTER_PROJECT})
-
-list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/tools")
-
-include(pybind11Tools)
-
-# Cache variables so pybind11_add_module can be used in parent projects
-set(PYBIND11_INCLUDE_DIR "${CMAKE_CURRENT_LIST_DIR}/include" CACHE INTERNAL "")
-set(PYTHON_INCLUDE_DIRS ${PYTHON_INCLUDE_DIRS} CACHE INTERNAL "")
-set(PYTHON_LIBRARIES ${PYTHON_LIBRARIES} CACHE INTERNAL "")
-set(PYTHON_MODULE_PREFIX ${PYTHON_MODULE_PREFIX} CACHE INTERNAL "")
-set(PYTHON_MODULE_EXTENSION ${PYTHON_MODULE_EXTENSION} CACHE INTERNAL "")
-
-set(PYBIND11_HEADERS
- include/pybind11/attr.h
- include/pybind11/cast.h
- include/pybind11/chrono.h
- include/pybind11/class_support.h
- include/pybind11/common.h
- include/pybind11/complex.h
- include/pybind11/descr.h
- include/pybind11/options.h
- include/pybind11/eigen.h
- include/pybind11/eval.h
- include/pybind11/functional.h
- include/pybind11/numpy.h
- include/pybind11/operators.h
- include/pybind11/pybind11.h
- include/pybind11/pytypes.h
- include/pybind11/stl.h
- include/pybind11/stl_bind.h
- include/pybind11/typeid.h
-)
-string(REPLACE "include/" "${CMAKE_CURRENT_SOURCE_DIR}/include/"
- PYBIND11_HEADERS "${PYBIND11_HEADERS}")
-
-if (PYBIND11_TEST)
- add_subdirectory(tests)
-endif()
-
-include(GNUInstallDirs)
-include(CMakePackageConfigHelpers)
-
-# extract project version from source
-file(STRINGS "${PYBIND11_INCLUDE_DIR}/pybind11/common.h" pybind11_version_defines
- REGEX "#define PYBIND11_VERSION_(MAJOR|MINOR|PATCH) ")
-foreach(ver ${pybind11_version_defines})
- if (ver MATCHES "#define PYBIND11_VERSION_(MAJOR|MINOR|PATCH) +([^ ]+)$")
- set(PYBIND11_VERSION_${CMAKE_MATCH_1} "${CMAKE_MATCH_2}" CACHE INTERNAL "")
- endif()
-endforeach()
-set(${PROJECT_NAME}_VERSION ${PYBIND11_VERSION_MAJOR}.${PYBIND11_VERSION_MINOR}.${PYBIND11_VERSION_PATCH})
-message(STATUS "pybind11 v${${PROJECT_NAME}_VERSION}")
-
-option (USE_PYTHON_INCLUDE_DIR "Install pybind11 headers in Python include directory instead of default installation prefix" OFF)
-if (USE_PYTHON_INCLUDE_DIR)
- file(RELATIVE_PATH CMAKE_INSTALL_INCLUDEDIR ${CMAKE_INSTALL_PREFIX} ${PYTHON_INCLUDE_DIRS})
-endif()
-
-if(NOT (CMAKE_VERSION VERSION_LESS 3.0)) # CMake >= 3.0
- # Build an interface library target:
- add_library(module INTERFACE)
- target_include_directories(module INTERFACE $<BUILD_INTERFACE:${PYBIND11_INCLUDE_DIR}>
- $<BUILD_INTERFACE:${PYTHON_INCLUDE_DIRS}>
- $<INSTALL_INTERFACE:${CMAKE_INSTALL_INCLUDEDIR}>)
- if(WIN32 OR CYGWIN)
- target_link_libraries(module INTERFACE $<BUILD_INTERFACE:${PYTHON_LIBRARIES}>)
- elseif(APPLE)
- target_link_libraries(module INTERFACE "-undefined dynamic_lookup")
- endif()
- target_compile_options(module INTERFACE $<BUILD_INTERFACE:${PYBIND11_CPP_STANDARD}>)
-
- add_library(pybind11::module ALIAS module) # to match exported target
-endif()
-
-if (PYBIND11_INSTALL)
- install(FILES ${PYBIND11_HEADERS}
- DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/pybind11)
- # GNUInstallDirs "DATADIR" wrong here; CMake search path wants "share".
- set(PYBIND11_CMAKECONFIG_INSTALL_DIR "share/cmake/${PROJECT_NAME}" CACHE STRING "install path for pybind11Config.cmake")
-
- configure_package_config_file(tools/${PROJECT_NAME}Config.cmake.in
- "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake"
- INSTALL_DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR})
- write_basic_package_version_file(${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
- VERSION ${${PROJECT_NAME}_VERSION}
- COMPATIBILITY AnyNewerVersion)
- install(FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake
- ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake
- tools/FindPythonLibsNew.cmake
- tools/pybind11Tools.cmake
- DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR})
-
- if(NOT (CMAKE_VERSION VERSION_LESS 3.0))
- install(TARGETS module
- EXPORT "${PROJECT_NAME}Targets")
- install(EXPORT "${PROJECT_NAME}Targets"
- NAMESPACE "${PROJECT_NAME}::"
- DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR})
- endif()
-endif()
diff --git a/thirdparty/pybind11/pybind11/CONTRIBUTING.md b/thirdparty/pybind11/pybind11/CONTRIBUTING.md
deleted file mode 100644
index 2beaf8d4d0c9e79919b7fcefebf3eebebbad6aca..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/CONTRIBUTING.md
+++ /dev/null
@@ -1,37 +0,0 @@
-Thank you for your interest in this project! Please refer to the following
-sections on how to contribute code and bug reports.
-
-### Reporting bugs
-
-At the moment, this project is run in the spare time of a single person
-([Wenzel Jakob](http://rgl.epfl.ch/people/wjakob)) with very limited resources
-for issue tracker tickets. Thus, before submitting a question or bug report,
-please take a moment of your time and ensure that your issue isn't already
-discussed in the project documentation provided at
-[http://pybind11.readthedocs.org/en/latest](http://pybind11.readthedocs.org/en/latest).
-
-Assuming that you have identified a previously unknown problem or an important
-question, it's essential that you submit a self-contained and minimal piece of
-code that reproduces the problem. In other words: no external dependencies,
-isolate the function(s) that cause breakage, submit matched and complete C++
-and Python snippets that can be easily compiled and run on my end.
-
-## Pull requests
-Contributions are submitted, reviewed, and accepted using Github pull requests.
-Please refer to [this
-article](https://help.github.com/articles/using-pull-requests) for details and
-adhere to the following rules to make the process as smooth as possible:
-
-* Make a new branch for every feature you're working on.
-* Make small and clean pull requests that are easy to review but make sure they
- do add value by themselves.
-* Add tests for any new functionality and run the test suite (``make pytest``)
- to ensure that no existing features break.
-* This project has a strong focus on providing general solutions using a
- minimal amount of code, thus small pull requests are greatly preferred.
-
-### License
-
-pybind11 is provided under a BSD-style license that can be found in the
-``LICENSE`` file. By using, distributing, or contributing to this project, you
-agree to the terms and conditions of this license.
diff --git a/thirdparty/pybind11/pybind11/ISSUE_TEMPLATE.md b/thirdparty/pybind11/pybind11/ISSUE_TEMPLATE.md
deleted file mode 100644
index 2e5f920f81b57ca0ffc1a005dbc40738fc67c3bb..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/ISSUE_TEMPLATE.md
+++ /dev/null
@@ -1,17 +0,0 @@
-Make sure you've completed the following steps before submitting your issue -- thank you!
-You can remove this template text afterward.
-
-1. Check if your question has already been answered in the [FAQ](http://pybind11.readthedocs.io/en/latest/faq.html) section.
-2. Make sure you've read the [documentation](http://pybind11.readthedocs.io/en/latest/). Your issue may be addressed there.
-3. If those resources didn't help and you only have a short question (not a bug report), consider asking in the [Gitter chat room](https://gitter.im/pybind/Lobby).
-4. If you have a genuine bug report or a more complex question which is not answered in the previous items (or not suitable for chat), please fill in the details below.
-5. Include a self-contained and minimal piece of code that reproduces the problem. If that's not possible, try to make the description as clear as possible.
-
-
-#### Issue description
-
-(Provide a short description, state the expected behavior and what actually happens.)
-
-#### Reproducible example code
-
-(The code should be minimal, have no external dependencies, isolate the function(s) that cause breakage. Submit matched and complete C++ and Python snippets that can be easily compiled and run to diagnose the issue.)
diff --git a/thirdparty/pybind11/pybind11/LICENSE b/thirdparty/pybind11/pybind11/LICENSE
deleted file mode 100644
index ccf4e97878879e187a6a648118ec39743545604d..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/LICENSE
+++ /dev/null
@@ -1,36 +0,0 @@
-Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>, All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
- list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
- this list of conditions and the following disclaimer in the documentation
- and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its contributors
- may be used to endorse or promote products derived from this software
- without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-You are under no obligation whatsoever to provide any bug fixes, patches, or
-upgrades to the features, functionality or performance of the source code
-("Enhancements") to anyone; however, if you choose to make your Enhancements
-available either publicly, or directly to the author of this software, without
-imposing a separate written license agreement for such Enhancements, then you
-hereby grant the following license: a non-exclusive, royalty-free perpetual
-license to install, use, modify, prepare derivative works, incorporate into
-other computer software, distribute, and sublicense such enhancements or
-derivative works thereof, in binary and source code form.
diff --git a/thirdparty/pybind11/pybind11/MANIFEST.in b/thirdparty/pybind11/pybind11/MANIFEST.in
deleted file mode 100644
index aa51d01100c14be5dd6239514aa7f8bfef56f31d..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/MANIFEST.in
+++ /dev/null
@@ -1,2 +0,0 @@
-include include/pybind11/*.h
-include LICENSE README.md CONTRIBUTING.md
diff --git a/thirdparty/pybind11/pybind11/README.md b/thirdparty/pybind11/pybind11/README.md
deleted file mode 100644
index 4477882405f73be33d850be2509045708d8ee281..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/README.md
+++ /dev/null
@@ -1,129 +0,0 @@
-
-
-# pybind11 — Seamless operability between C++11 and Python
-
-[](http://pybind11.readthedocs.org/en/master/?badge=master)
-[](http://pybind11.readthedocs.org/en/stable/?badge=stable)
-[](https://gitter.im/pybind/Lobby)
-[](https://travis-ci.org/pybind/pybind11)
-[](https://ci.appveyor.com/project/wjakob/pybind11)
-
-**pybind11** is a lightweight header-only library that exposes C++ types in Python
-and vice versa, mainly to create Python bindings of existing C++ code. Its
-goals and syntax are similar to the excellent
-[Boost.Python](http://www.boost.org/doc/libs/1_58_0/libs/python/doc/) library
-by David Abrahams: to minimize boilerplate code in traditional extension
-modules by inferring type information using compile-time introspection.
-
-The main issue with Boost.Python—and the reason for creating such a similar
-project—is Boost. Boost is an enormously large and complex suite of utility
-libraries that works with almost every C++ compiler in existence. This
-compatibility has its cost: arcane template tricks and workarounds are
-necessary to support the oldest and buggiest of compiler specimens. Now that
-C++11-compatible compilers are widely available, this heavy machinery has
-become an excessively large and unnecessary dependency.
-
-Think of this library as a tiny self-contained version of Boost.Python with
-everything stripped away that isn't relevant for binding generation. Without
-comments, the core header files only require ~4K lines of code and depend on
-Python (2.7 or 3.x, or PyPy2.7 >= 5.7) and the C++ standard library. This
-compact implementation was possible thanks to some of the new C++11 language
-features (specifically: tuples, lambda functions and variadic templates). Since
-its creation, this library has grown beyond Boost.Python in many ways, leading
-to dramatically simpler binding code in many common situations.
-
-Tutorial and reference documentation is provided at
-[http://pybind11.readthedocs.org/en/master](http://pybind11.readthedocs.org/en/master).
-A PDF version of the manual is available
-[here](https://media.readthedocs.org/pdf/pybind11/master/pybind11.pdf).
-
-## Core features
-pybind11 can map the following core C++ features to Python
-
-- Functions accepting and returning custom data structures per value, reference, or pointer
-- Instance methods and static methods
-- Overloaded functions
-- Instance attributes and static attributes
-- Arbitrary exception types
-- Enumerations
-- Callbacks
-- Iterators and ranges
-- Custom operators
-- Single and multiple inheritance
-- STL data structures
-- Iterators and ranges
-- Smart pointers with reference counting like ``std::shared_ptr``
-- Internal references with correct reference counting
-- C++ classes with virtual (and pure virtual) methods can be extended in Python
-
-## Goodies
-In addition to the core functionality, pybind11 provides some extra goodies:
-
-- Python 2.7, 3.x, and PyPy (PyPy2.7 >= 5.7) are supported with an
- implementation-agnostic interface.
-
-- It is possible to bind C++11 lambda functions with captured variables. The
- lambda capture data is stored inside the resulting Python function object.
-
-- pybind11 uses C++11 move constructors and move assignment operators whenever
- possible to efficiently transfer custom data types.
-
-- It's easy to expose the internal storage of custom data types through
- Pythons' buffer protocols. This is handy e.g. for fast conversion between
- C++ matrix classes like Eigen and NumPy without expensive copy operations.
-
-- pybind11 can automatically vectorize functions so that they are transparently
- applied to all entries of one or more NumPy array arguments.
-
-- Python's slice-based access and assignment operations can be supported with
- just a few lines of code.
-
-- Everything is contained in just a few header files; there is no need to link
- against any additional libraries.
-
-- Binaries are generally smaller by a factor of at least 2 compared to
- equivalent bindings generated by Boost.Python. A recent pybind11 conversion
- of PyRosetta, an enormous Boost.Python binding project,
- [reported](http://graylab.jhu.edu/RosettaCon2016/PyRosetta-4.pdf) a binary
- size reduction of **5.4x** and compile time reduction by **5.8x**.
-
-- When supported by the compiler, two new C++14 features (relaxed constexpr and
- return value deduction) are used to precompute function signatures at compile
- time, leading to smaller binaries.
-
-- With little extra effort, C++ types can be pickled and unpickled similar to
- regular Python objects.
-
-## Supported compilers
-
-1. Clang/LLVM 3.3 or newer (for Apple Xcode's clang, this is 5.0.0 or newer)
-2. GCC 4.8 or newer
-3. Microsoft Visual Studio 2015 Update 3 or newer
-4. Intel C++ compiler 16 or newer (15 with a [workaround](https://github.com/pybind/pybind11/issues/276))
-5. Cygwin/GCC (tested on 2.5.1)
-
-## About
-
-This project was created by [Wenzel Jakob](http://rgl.epfl.ch/people/wjakob).
-Significant features and/or improvements to the code were contributed by
-Jonas Adler,
-Sylvain Corlay,
-Trent Houliston,
-Axel Huebl,
-@hulucc,
-Sergey Lyskov
-Johan Mabille,
-Tomasz MiÄ…sko,
-Dean Moldovan,
-Ben Pritchard,
-Jason Rhinelander,
-Boris Schäling,
-Pim Schellart,
-Ivan Smirnov, and
-Patrick Stewart.
-
-### License
-
-pybind11 is provided under a BSD-style license that can be found in the
-``LICENSE`` file. By using, distributing, or contributing to this project,
-you agree to the terms and conditions of this license.
diff --git a/thirdparty/pybind11/pybind11/docs/Doxyfile b/thirdparty/pybind11/pybind11/docs/Doxyfile
deleted file mode 100644
index 4dc8bf0591ac0a6babb882c528b9e3e5ceab1a93..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/Doxyfile
+++ /dev/null
@@ -1,19 +0,0 @@
-PROJECT_NAME = pybind11
-INPUT = ../include/pybind11/
-
-GENERATE_HTML = NO
-GENERATE_LATEX = NO
-GENERATE_XML = YES
-XML_OUTPUT = .build/doxygenxml
-XML_PROGRAMLISTING = YES
-
-MACRO_EXPANSION = YES
-EXPAND_ONLY_PREDEF = YES
-EXPAND_AS_DEFINED = PYBIND11_RUNTIME_EXCEPTION
-
-ALIASES = "rst=\verbatim embed:rst"
-ALIASES += "endrst=\endverbatim"
-
-QUIET = YES
-WARNINGS = YES
-WARN_IF_UNDOCUMENTED = NO
diff --git a/thirdparty/pybind11/pybind11/docs/_static/theme_overrides.css b/thirdparty/pybind11/pybind11/docs/_static/theme_overrides.css
deleted file mode 100644
index 1071809fa0fecf7c28d3356f37363266e9128b81..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/_static/theme_overrides.css
+++ /dev/null
@@ -1,11 +0,0 @@
-.wy-table-responsive table td,
-.wy-table-responsive table th {
- white-space: initial !important;
-}
-.rst-content table.docutils td {
- vertical-align: top !important;
-}
-div[class^='highlight'] pre {
- white-space: pre;
- white-space: pre-wrap;
-}
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/cast/chrono.rst b/thirdparty/pybind11/pybind11/docs/advanced/cast/chrono.rst
deleted file mode 100644
index 8c6b3d7e59098724533402847e902aa9317fa8ee..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/cast/chrono.rst
+++ /dev/null
@@ -1,81 +0,0 @@
-Chrono
-======
-
-When including the additional header file :file:`pybind11/chrono.h` conversions
-from C++11 chrono datatypes to python datetime objects are automatically enabled.
-This header also enables conversions of python floats (often from sources such
-as ``time.monotonic()``, ``time.perf_counter()`` and ``time.process_time()``)
-into durations.
-
-An overview of clocks in C++11
-------------------------------
-
-A point of confusion when using these conversions is the differences between
-clocks provided in C++11. There are three clock types defined by the C++11
-standard and users can define their own if needed. Each of these clocks have
-different properties and when converting to and from python will give different
-results.
-
-The first clock defined by the standard is ``std::chrono::system_clock``. This
-clock measures the current date and time. However, this clock changes with to
-updates to the operating system time. For example, if your time is synchronised
-with a time server this clock will change. This makes this clock a poor choice
-for timing purposes but good for measuring the wall time.
-
-The second clock defined in the standard is ``std::chrono::steady_clock``.
-This clock ticks at a steady rate and is never adjusted. This makes it excellent
-for timing purposes, however the value in this clock does not correspond to the
-current date and time. Often this clock will be the amount of time your system
-has been on, although it does not have to be. This clock will never be the same
-clock as the system clock as the system clock can change but steady clocks
-cannot.
-
-The third clock defined in the standard is ``std::chrono::high_resolution_clock``.
-This clock is the clock that has the highest resolution out of the clocks in the
-system. It is normally a typedef to either the system clock or the steady clock
-but can be its own independent clock. This is important as when using these
-conversions as the types you get in python for this clock might be different
-depending on the system.
-If it is a typedef of the system clock, python will get datetime objects, but if
-it is a different clock they will be timedelta objects.
-
-Provided conversions
---------------------
-
-.. rubric:: C++ to Python
-
-- ``std::chrono::system_clock::time_point`` → ``datetime.datetime``
- System clock times are converted to python datetime instances. They are
- in the local timezone, but do not have any timezone information attached
- to them (they are naive datetime objects).
-
-- ``std::chrono::duration`` → ``datetime.timedelta``
- Durations are converted to timedeltas, any precision in the duration
- greater than microseconds is lost by rounding towards zero.
-
-- ``std::chrono::[other_clocks]::time_point`` → ``datetime.timedelta``
- Any clock time that is not the system clock is converted to a time delta.
- This timedelta measures the time from the clocks epoch to now.
-
-.. rubric:: Python to C++
-
-- ``datetime.datetime`` → ``std::chrono::system_clock::time_point``
- Date/time objects are converted into system clock timepoints. Any
- timezone information is ignored and the type is treated as a naive
- object.
-
-- ``datetime.timedelta`` → ``std::chrono::duration``
- Time delta are converted into durations with microsecond precision.
-
-- ``datetime.timedelta`` → ``std::chrono::[other_clocks]::time_point``
- Time deltas that are converted into clock timepoints are treated as
- the amount of time from the start of the clocks epoch.
-
-- ``float`` → ``std::chrono::duration``
- Floats that are passed to C++ as durations be interpreted as a number of
- seconds. These will be converted to the duration using ``duration_cast``
- from the float.
-
-- ``float`` → ``std::chrono::[other_clocks]::time_point``
- Floats that are passed to C++ as time points will be interpreted as the
- number of seconds from the start of the clocks epoch.
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/cast/custom.rst b/thirdparty/pybind11/pybind11/docs/advanced/cast/custom.rst
deleted file mode 100644
index c854e7fcde4376052e7fd83372226a9362332db5..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/cast/custom.rst
+++ /dev/null
@@ -1,85 +0,0 @@
-Custom type casters
-===================
-
-In very rare cases, applications may require custom type casters that cannot be
-expressed using the abstractions provided by pybind11, thus requiring raw
-Python C API calls. This is fairly advanced usage and should only be pursued by
-experts who are familiar with the intricacies of Python reference counting.
-
-The following snippets demonstrate how this works for a very simple ``inty``
-type that that should be convertible from Python types that provide a
-``__int__(self)`` method.
-
-.. code-block:: cpp
-
- struct inty { long long_value; };
-
- void print(inty s) {
- std::cout << s.long_value << std::endl;
- }
-
-The following Python snippet demonstrates the intended usage from the Python side:
-
-.. code-block:: python
-
- class A:
- def __int__(self):
- return 123
-
- from example import print
- print(A())
-
-To register the necessary conversion routines, it is necessary to add
-a partial overload to the ``pybind11::detail::type_caster<T>`` template.
-Although this is an implementation detail, adding partial overloads to this
-type is explicitly allowed.
-
-.. code-block:: cpp
-
- namespace pybind11 { namespace detail {
- template <> struct type_caster<inty> {
- public:
- /**
- * This macro establishes the name 'inty' in
- * function signatures and declares a local variable
- * 'value' of type inty
- */
- PYBIND11_TYPE_CASTER(inty, _("inty"));
-
- /**
- * Conversion part 1 (Python->C++): convert a PyObject into a inty
- * instance or return false upon failure. The second argument
- * indicates whether implicit conversions should be applied.
- */
- bool load(handle src, bool) {
- /* Extract PyObject from handle */
- PyObject *source = src.ptr();
- /* Try converting into a Python integer value */
- PyObject *tmp = PyNumber_Long(source);
- if (!tmp)
- return false;
- /* Now try to convert into a C++ int */
- value.long_value = PyLong_AsLong(tmp);
- Py_DECREF(tmp);
- /* Ensure return code was OK (to avoid out-of-range errors etc) */
- return !(value.long_value == -1 && !PyErr_Occurred());
- }
-
- /**
- * Conversion part 2 (C++ -> Python): convert an inty instance into
- * a Python object. The second and third arguments are used to
- * indicate the return value policy and parent object (for
- * ``return_value_policy::reference_internal``) and are generally
- * ignored by implicit casters.
- */
- static handle cast(inty src, return_value_policy /* policy */, handle /* parent */) {
- return PyLong_FromLong(src.long_value);
- }
- };
- }} // namespace pybind11::detail
-
-.. warning::
-
- When using custom type casters, it's important to declare them consistently
- in every compilation unit of the Python extension module. Otherwise,
- undefined behavior can ensue.
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/cast/eigen.rst b/thirdparty/pybind11/pybind11/docs/advanced/cast/eigen.rst
deleted file mode 100644
index 5b0b08ca66879afc1162816a196676f4c0503d27..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/cast/eigen.rst
+++ /dev/null
@@ -1,310 +0,0 @@
-Eigen
-#####
-
-`Eigen <http://eigen.tuxfamily.org>`_ is C++ header-based library for dense and
-sparse linear algebra. Due to its popularity and widespread adoption, pybind11
-provides transparent conversion and limited mapping support between Eigen and
-Scientific Python linear algebra data types.
-
-To enable the built-in Eigen support you must include the optional header file
-:file:`pybind11/eigen.h`.
-
-Pass-by-value
-=============
-
-When binding a function with ordinary Eigen dense object arguments (for
-example, ``Eigen::MatrixXd``), pybind11 will accept any input value that is
-already (or convertible to) a ``numpy.ndarray`` with dimensions compatible with
-the Eigen type, copy its values into a temporary Eigen variable of the
-appropriate type, then call the function with this temporary variable.
-
-Sparse matrices are similarly copied to or from
-``scipy.sparse.csr_matrix``/``scipy.sparse.csc_matrix`` objects.
-
-Pass-by-reference
-=================
-
-One major limitation of the above is that every data conversion implicitly
-involves a copy, which can be both expensive (for large matrices) and disallows
-binding functions that change their (Matrix) arguments. Pybind11 allows you to
-work around this by using Eigen's ``Eigen::Ref<MatrixType>`` class much as you
-would when writing a function taking a generic type in Eigen itself (subject to
-some limitations discussed below).
-
-When calling a bound function accepting a ``Eigen::Ref<const MatrixType>``
-type, pybind11 will attempt to avoid copying by using an ``Eigen::Map`` object
-that maps into the source ``numpy.ndarray`` data: this requires both that the
-data types are the same (e.g. ``dtype='float64'`` and ``MatrixType::Scalar`` is
-``double``); and that the storage is layout compatible. The latter limitation
-is discussed in detail in the section below, and requires careful
-consideration: by default, numpy matrices and eigen matrices are *not* storage
-compatible.
-
-If the numpy matrix cannot be used as is (either because its types differ, e.g.
-passing an array of integers to an Eigen paramater requiring doubles, or
-because the storage is incompatible), pybind11 makes a temporary copy and
-passes the copy instead.
-
-When a bound function parameter is instead ``Eigen::Ref<MatrixType>`` (note the
-lack of ``const``), pybind11 will only allow the function to be called if it
-can be mapped *and* if the numpy array is writeable (that is
-``a.flags.writeable`` is true). Any access (including modification) made to
-the passed variable will be transparently carried out directly on the
-``numpy.ndarray``.
-
-This means you can can write code such as the following and have it work as
-expected:
-
-.. code-block:: cpp
-
- void scale_by_2(Eigen::Ref<Eigen::VectorXd> m) {
- v *= 2;
- }
-
-Note, however, that you will likely run into limitations due to numpy and
-Eigen's difference default storage order for data; see the below section on
-:ref:`storage_orders` for details on how to bind code that won't run into such
-limitations.
-
-.. note::
-
- Passing by reference is not supported for sparse types.
-
-Returning values to Python
-==========================
-
-When returning an ordinary dense Eigen matrix type to numpy (e.g.
-``Eigen::MatrixXd`` or ``Eigen::RowVectorXf``) pybind11 keeps the matrix and
-returns a numpy array that directly references the Eigen matrix: no copy of the
-data is performed. The numpy array will have ``array.flags.owndata`` set to
-``False`` to indicate that it does not own the data, and the lifetime of the
-stored Eigen matrix will be tied to the returned ``array``.
-
-If you bind a function with a non-reference, ``const`` return type (e.g.
-``const Eigen::MatrixXd``), the same thing happens except that pybind11 also
-sets the numpy array's ``writeable`` flag to false.
-
-If you return an lvalue reference or pointer, the usual pybind11 rules apply,
-as dictated by the binding function's return value policy (see the
-documentation on :ref:`return_value_policies` for full details). That means,
-without an explicit return value policy, lvalue references will be copied and
-pointers will be managed by pybind11. In order to avoid copying, you should
-explictly specify an appropriate return value policy, as in the following
-example:
-
-.. code-block:: cpp
-
- class MyClass {
- Eigen::MatrixXd big_mat = Eigen::MatrixXd::Zero(10000, 10000);
- public:
- Eigen::MatrixXd &getMatrix() { return big_mat; }
- const Eigen::MatrixXd &viewMatrix() { return big_mat; }
- };
-
- // Later, in binding code:
- py::class_<MyClass>(m, "MyClass")
- .def(py::init<>())
- .def("copy_matrix", &MyClass::getMatrix) // Makes a copy!
- .def("get_matrix", &MyClass::getMatrix, py::return_value_policy::reference_internal)
- .def("view_matrix", &MyClass::viewMatrix, py::return_value_policy::reference_internal)
- ;
-
-.. code-block:: python
-
- a = MyClass()
- m = a.get_matrix() # flags.writeable = True, flags.owndata = False
- v = a.view_matrix() # flags.writeable = False, flags.owndata = False
- c = a.copy_matrix() # flags.writeable = True, flags.owndata = True
- # m[5,6] and v[5,6] refer to the same element, c[5,6] does not.
-
-Note in this example that ``py::return_value_policy::reference_internal`` is
-used to tie the life of the MyClass object to the life of the returned arrays.
-
-You may also return an ``Eigen::Ref``, ``Eigen::Map`` or other map-like Eigen
-object (for example, the return value of ``matrix.block()`` and related
-methods) that map into a dense Eigen type. When doing so, the default
-behaviour of pybind11 is to simply reference the returned data: you must take
-care to ensure that this data remains valid! You may ask pybind11 to
-explicitly *copy* such a return value by using the
-``py::return_value_policy::copy`` policy when binding the function. You may
-also use ``py::return_value_policy::reference_internal`` or a
-``py::keep_alive`` to ensure the data stays valid as long as the returned numpy
-array does.
-
-When returning such a reference of map, pybind11 additionally respects the
-readonly-status of the returned value, marking the numpy array as non-writeable
-if the reference or map was itself read-only.
-
-.. note::
-
- Sparse types are always copied when returned.
-
-.. _storage_orders:
-
-Storage orders
-==============
-
-Passing arguments via ``Eigen::Ref`` has some limitations that you must be
-aware of in order to effectively pass matrices by reference. First and
-foremost is that the default ``Eigen::Ref<MatrixType>`` class requires
-contiguous storage along columns (for column-major types, the default in Eigen)
-or rows if ``MatrixType`` is specifically an ``Eigen::RowMajor`` storage type.
-The former, Eigen's default, is incompatible with ``numpy``'s default row-major
-storage, and so you will not be able to pass numpy arrays to Eigen by reference
-without making one of two changes.
-
-(Note that this does not apply to vectors (or column or row matrices): for such
-types the "row-major" and "column-major" distinction is meaningless).
-
-The first approach is to change the use of ``Eigen::Ref<MatrixType>`` to the
-more general ``Eigen::Ref<MatrixType, 0, Eigen::Stride<Eigen::Dynamic,
-Eigen::Dynamic>>`` (or similar type with a fully dynamic stride type in the
-third template argument). Since this is a rather cumbersome type, pybind11
-provides a ``py::EigenDRef<MatrixType>`` type alias for your convenience (along
-with EigenDMap for the equivalent Map, and EigenDStride for just the stride
-type).
-
-This type allows Eigen to map into any arbitrary storage order. This is not
-the default in Eigen for performance reasons: contiguous storage allows
-vectorization that cannot be done when storage is not known to be contiguous at
-compile time. The default ``Eigen::Ref`` stride type allows non-contiguous
-storage along the outer dimension (that is, the rows of a column-major matrix
-or columns of a row-major matrix), but not along the inner dimension.
-
-This type, however, has the added benefit of also being able to map numpy array
-slices. For example, the following (contrived) example uses Eigen with a numpy
-slice to multiply by 2 all coefficients that are both on even rows (0, 2, 4,
-...) and in columns 2, 5, or 8:
-
-.. code-block:: cpp
-
- m.def("scale", [](py::EigenDRef<Eigen::MatrixXd> m, double c) { m *= c; });
-
-.. code-block:: python
-
- # a = np.array(...)
- scale_by_2(myarray[0::2, 2:9:3])
-
-The second approach to avoid copying is more intrusive: rearranging the
-underlying data types to not run into the non-contiguous storage problem in the
-first place. In particular, that means using matrices with ``Eigen::RowMajor``
-storage, where appropriate, such as:
-
-.. code-block:: cpp
-
- using RowMatrixXd = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
- // Use RowMatrixXd instead of MatrixXd
-
-Now bound functions accepting ``Eigen::Ref<RowMatrixXd>`` arguments will be
-callable with numpy's (default) arrays without involving a copying.
-
-You can, alternatively, change the storage order that numpy arrays use by
-adding the ``order='F'`` option when creating an array:
-
-.. code-block:: python
-
- myarray = np.array(source, order='F')
-
-Such an object will be passable to a bound function accepting an
-``Eigen::Ref<MatrixXd>`` (or similar column-major Eigen type).
-
-One major caveat with this approach, however, is that it is not entirely as
-easy as simply flipping all Eigen or numpy usage from one to the other: some
-operations may alter the storage order of a numpy array. For example, ``a2 =
-array.transpose()`` results in ``a2`` being a view of ``array`` that references
-the same data, but in the opposite storage order!
-
-While this approach allows fully optimized vectorized calculations in Eigen, it
-cannot be used with array slices, unlike the first approach.
-
-When *returning* a matrix to Python (either a regular matrix, a reference via
-``Eigen::Ref<>``, or a map/block into a matrix), no special storage
-consideration is required: the created numpy array will have the required
-stride that allows numpy to properly interpret the array, whatever its storage
-order.
-
-Failing rather than copying
-===========================
-
-The default behaviour when binding ``Eigen::Ref<const MatrixType>`` eigen
-references is to copy matrix values when passed a numpy array that does not
-conform to the element type of ``MatrixType`` or does not have a compatible
-stride layout. If you want to explicitly avoid copying in such a case, you
-should bind arguments using the ``py::arg().noconvert()`` annotation (as
-described in the :ref:`nonconverting_arguments` documentation).
-
-The following example shows an example of arguments that don't allow data
-copying to take place:
-
-.. code-block:: cpp
-
- // The method and function to be bound:
- class MyClass {
- // ...
- double some_method(const Eigen::Ref<const MatrixXd> &matrix) { /* ... */ }
- };
- float some_function(const Eigen::Ref<const MatrixXf> &big,
- const Eigen::Ref<const MatrixXf> &small) {
- // ...
- }
-
- // The associated binding code:
- using namespace pybind11::literals; // for "arg"_a
- py::class_<MyClass>(m, "MyClass")
- // ... other class definitions
- .def("some_method", &MyClass::some_method, py::arg().nocopy());
-
- m.def("some_function", &some_function,
- "big"_a.nocopy(), // <- Don't allow copying for this arg
- "small"_a // <- This one can be copied if needed
- );
-
-With the above binding code, attempting to call the the ``some_method(m)``
-method on a ``MyClass`` object, or attempting to call ``some_function(m, m2)``
-will raise a ``RuntimeError`` rather than making a temporary copy of the array.
-It will, however, allow the ``m2`` argument to be copied into a temporary if
-necessary.
-
-Note that explicitly specifying ``.noconvert()`` is not required for *mutable*
-Eigen references (e.g. ``Eigen::Ref<MatrixXd>`` without ``const`` on the
-``MatrixXd``): mutable references will never be called with a temporary copy.
-
-Vectors versus column/row matrices
-==================================
-
-Eigen and numpy have fundamentally different notions of a vector. In Eigen, a
-vector is simply a matrix with the number of columns or rows set to 1 at
-compile time (for a column vector or row vector, respectively). Numpy, in
-contast, has comparable 2-dimensional 1xN and Nx1 arrays, but *also* has
-1-dimensional arrays of size N.
-
-When passing a 2-dimensional 1xN or Nx1 array to Eigen, the Eigen type must
-have matching dimensions: That is, you cannot pass a 2-dimensional Nx1 numpy
-array to an Eigen value expecting a row vector, or a 1xN numpy array as a
-column vector argument.
-
-On the other hand, pybind11 allows you to pass 1-dimensional arrays of length N
-as Eigen parameters. If the Eigen type can hold a column vector of length N it
-will be passed as such a column vector. If not, but the Eigen type constraints
-will accept a row vector, it will be passed as a row vector. (The column
-vector takes precendence when both are supported, for example, when passing a
-1D numpy array to a MatrixXd argument). Note that the type need not be
-expicitly a vector: it is permitted to pass a 1D numpy array of size 5 to an
-Eigen ``Matrix<double, Dynamic, 5>``: you would end up with a 1x5 Eigen matrix.
-Passing the same to an ``Eigen::MatrixXd`` would result in a 5x1 Eigen matrix.
-
-When returning an eigen vector to numpy, the conversion is ambiguous: a row
-vector of length 4 could be returned as either a 1D array of length 4, or as a
-2D array of size 1x4. When encoutering such a situation, pybind11 compromises
-by considering the returned Eigen type: if it is a compile-time vector--that
-is, the type has either the number of rows or columns set to 1 at compile
-time--pybind11 converts to a 1D numpy array when returning the value. For
-instances that are a vector only at run-time (e.g. ``MatrixXd``,
-``Matrix<float, Dynamic, 4>``), pybind11 returns the vector as a 2D array to
-numpy. If this isn't want you want, you can use ``array.reshape(...)`` to get
-a view of the same data in the desired dimensions.
-
-.. seealso::
-
- The file :file:`tests/test_eigen.cpp` contains a complete example that
- shows how to pass Eigen sparse and dense data types in more detail.
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/cast/functional.rst b/thirdparty/pybind11/pybind11/docs/advanced/cast/functional.rst
deleted file mode 100644
index 5d0a01d13eab6946d5b3679e3caa9b0cfa4db713..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/cast/functional.rst
+++ /dev/null
@@ -1,113 +0,0 @@
-Functional
-##########
-
-The following features must be enabled by including :file:`pybind11/functional.h`.
-
-
-Callbacks and passing anonymous functions
-=========================================
-
-The C++11 standard brought lambda functions and the generic polymorphic
-function wrapper ``std::function<>`` to the C++ programming language, which
-enable powerful new ways of working with functions. Lambda functions come in
-two flavors: stateless lambda function resemble classic function pointers that
-link to an anonymous piece of code, while stateful lambda functions
-additionally depend on captured variables that are stored in an anonymous
-*lambda closure object*.
-
-Here is a simple example of a C++ function that takes an arbitrary function
-(stateful or stateless) with signature ``int -> int`` as an argument and runs
-it with the value 10.
-
-.. code-block:: cpp
-
- int func_arg(const std::function<int(int)> &f) {
- return f(10);
- }
-
-The example below is more involved: it takes a function of signature ``int -> int``
-and returns another function of the same kind. The return value is a stateful
-lambda function, which stores the value ``f`` in the capture object and adds 1 to
-its return value upon execution.
-
-.. code-block:: cpp
-
- std::function<int(int)> func_ret(const std::function<int(int)> &f) {
- return [f](int i) {
- return f(i) + 1;
- };
- }
-
-This example demonstrates using python named parameters in C++ callbacks which
-requires using ``py::cpp_function`` as a wrapper. Usage is similar to defining
-methods of classes:
-
-.. code-block:: cpp
-
- py::cpp_function func_cpp() {
- return py::cpp_function([](int i) { return i+1; },
- py::arg("number"));
- }
-
-After including the extra header file :file:`pybind11/functional.h`, it is almost
-trivial to generate binding code for all of these functions.
-
-.. code-block:: cpp
-
- #include <pybind11/functional.h>
-
- PYBIND11_PLUGIN(example) {
- py::module m("example", "pybind11 example plugin");
-
- m.def("func_arg", &func_arg);
- m.def("func_ret", &func_ret);
- m.def("func_cpp", &func_cpp);
-
- return m.ptr();
- }
-
-The following interactive session shows how to call them from Python.
-
-.. code-block:: pycon
-
- $ python
- >>> import example
- >>> def square(i):
- ... return i * i
- ...
- >>> example.func_arg(square)
- 100L
- >>> square_plus_1 = example.func_ret(square)
- >>> square_plus_1(4)
- 17L
- >>> plus_1 = func_cpp()
- >>> plus_1(number=43)
- 44L
-
-.. warning::
-
- Keep in mind that passing a function from C++ to Python (or vice versa)
- will instantiate a piece of wrapper code that translates function
- invocations between the two languages. Naturally, this translation
- increases the computational cost of each function call somewhat. A
- problematic situation can arise when a function is copied back and forth
- between Python and C++ many times in a row, in which case the underlying
- wrappers will accumulate correspondingly. The resulting long sequence of
- C++ -> Python -> C++ -> ... roundtrips can significantly decrease
- performance.
-
- There is one exception: pybind11 detects case where a stateless function
- (i.e. a function pointer or a lambda function without captured variables)
- is passed as an argument to another C++ function exposed in Python. In this
- case, there is no overhead. Pybind11 will extract the underlying C++
- function pointer from the wrapped function to sidestep a potential C++ ->
- Python -> C++ roundtrip. This is demonstrated in :file:`tests/test_callbacks.cpp`.
-
-.. note::
-
- This functionality is very useful when generating bindings for callbacks in
- C++ libraries (e.g. GUI libraries, asynchronous networking libraries, etc.).
-
- The file :file:`tests/test_callbacks.cpp` contains a complete example
- that demonstrates how to work with callbacks and anonymous functions in
- more detail.
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/cast/index.rst b/thirdparty/pybind11/pybind11/docs/advanced/cast/index.rst
deleted file mode 100644
index 54c10570b1ccd106ee98c92ead8c28fde5134d5d..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/cast/index.rst
+++ /dev/null
@@ -1,42 +0,0 @@
-Type conversions
-################
-
-Apart from enabling cross-language function calls, a fundamental problem
-that a binding tool like pybind11 must address is to provide access to
-native Python types in C++ and vice versa. There are three fundamentally
-different ways to do this—which approach is preferable for a particular type
-depends on the situation at hand.
-
-1. Use a native C++ type everywhere. In this case, the type must be wrapped
- using pybind11-generated bindings so that Python can interact with it.
-
-2. Use a native Python type everywhere. It will need to be wrapped so that
- C++ functions can interact with it.
-
-3. Use a native C++ type on the C++ side and a native Python type on the
- Python side. pybind11 refers to this as a *type conversion*.
-
- Type conversions are the most "natural" option in the sense that native
- (non-wrapped) types are used everywhere. The main downside is that a copy
- of the data must be made on every Python ↔ C++ transition: this is
- needed since the C++ and Python versions of the same type generally won't
- have the same memory layout.
-
- pybind11 can perform many kinds of conversions automatically. An overview
- is provided in the table ":ref:`conversion_table`".
-
-The following subsections discuss the differences between these options in more
-detail. The main focus in this section is on type conversions, which represent
-the last case of the above list.
-
-.. toctree::
- :maxdepth: 1
-
- overview
- strings
- stl
- functional
- chrono
- eigen
- custom
-
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/cast/overview.rst b/thirdparty/pybind11/pybind11/docs/advanced/cast/overview.rst
deleted file mode 100644
index 54c11a90a023252cce8100025f16f1bcbe44719f..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/cast/overview.rst
+++ /dev/null
@@ -1,158 +0,0 @@
-Overview
-########
-
-.. rubric:: 1. Native type in C++, wrapper in Python
-
-Exposing a custom C++ type using :class:`py::class_` was covered in detail
-in the :doc:`/classes` section. There, the underlying data structure is
-always the original C++ class while the :class:`py::class_` wrapper provides
-a Python interface. Internally, when an object like this is sent from C++ to
-Python, pybind11 will just add the outer wrapper layer over the native C++
-object. Getting it back from Python is just a matter of peeling off the
-wrapper.
-
-.. rubric:: 2. Wrapper in C++, native type in Python
-
-This is the exact opposite situation. Now, we have a type which is native to
-Python, like a ``tuple`` or a ``list``. One way to get this data into C++ is
-with the :class:`py::object` family of wrappers. These are explained in more
-detail in the :doc:`/advanced/pycpp/object` section. We'll just give a quick
-example here:
-
-.. code-block:: cpp
-
- void print_list(py::list my_list) {
- for (auto item : my_list)
- std::cout << item << " ";
- }
-
-.. code-block:: pycon
-
- >>> print_list([1, 2, 3])
- 1 2 3
-
-The Python ``list`` is not converted in any way -- it's just wrapped in a C++
-:class:`py::list` class. At its core it's still a Python object. Copying a
-:class:`py::list` will do the usual reference-counting like in Python.
-Returning the object to Python will just remove the thin wrapper.
-
-.. rubric:: 3. Converting between native C++ and Python types
-
-In the previous two cases we had a native type in one language and a wrapper in
-the other. Now, we have native types on both sides and we convert between them.
-
-.. code-block:: cpp
-
- void print_vector(const std::vector<int> &v) {
- for (auto item : v)
- std::cout << item << "\n";
- }
-
-.. code-block:: pycon
-
- >>> print_vector([1, 2, 3])
- 1 2 3
-
-In this case, pybind11 will construct a new ``std::vector<int>`` and copy each
-element from the Python ``list``. The newly constructed object will be passed
-to ``print_vector``. The same thing happens in the other direction: a new
-``list`` is made to match the value returned from C++.
-
-Lots of these conversions are supported out of the box, as shown in the table
-below. They are very convenient, but keep in mind that these conversions are
-fundamentally based on copying data. This is perfectly fine for small immutable
-types but it may become quite expensive for large data structures. This can be
-avoided by overriding the automatic conversion with a custom wrapper (i.e. the
-above-mentioned approach 1). This requires some manual effort and more details
-are available in the :ref:`opaque` section.
-
-.. _conversion_table:
-
-List of all builtin conversions
--------------------------------
-
-The following basic data types are supported out of the box (some may require
-an additional extension header to be included). To pass other data structures
-as arguments and return values, refer to the section on binding :ref:`classes`.
-
-+------------------------------------+---------------------------+-------------------------------+
-| Data type | Description | Header file |
-+====================================+===========================+===============================+
-| ``int8_t``, ``uint8_t`` | 8-bit integers | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``int16_t``, ``uint16_t`` | 16-bit integers | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``int32_t``, ``uint32_t`` | 32-bit integers | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``int64_t``, ``uint64_t`` | 64-bit integers | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``ssize_t``, ``size_t`` | Platform-dependent size | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``float``, ``double`` | Floating point types | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``bool`` | Two-state Boolean type | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``char`` | Character literal | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``char16_t`` | UTF-16 character literal | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``char32_t`` | UTF-32 character literal | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``wchar_t`` | Wide character literal | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``const char *`` | UTF-8 string literal | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``const char16_t *`` | UTF-16 string literal | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``const char32_t *`` | UTF-32 string literal | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``const wchar_t *`` | Wide string literal | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::string`` | STL dynamic UTF-8 string | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::u16string`` | STL dynamic UTF-16 string | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::u32string`` | STL dynamic UTF-32 string | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::wstring`` | STL dynamic wide string | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::pair<T1, T2>`` | Pair of two custom types | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::tuple<...>`` | Arbitrary tuple of types | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::reference_wrapper<...>`` | Reference type wrapper | :file:`pybind11/pybind11.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::complex<T>`` | Complex numbers | :file:`pybind11/complex.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::array<T, Size>`` | STL static array | :file:`pybind11/stl.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::vector<T>`` | STL dynamic array | :file:`pybind11/stl.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::valarray<T>`` | STL value array | :file:`pybind11/stl.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::list<T>`` | STL linked list | :file:`pybind11/stl.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::map<T1, T2>`` | STL ordered map | :file:`pybind11/stl.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::unordered_map<T1, T2>`` | STL unordered map | :file:`pybind11/stl.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::set<T>`` | STL ordered set | :file:`pybind11/stl.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::unordered_set<T>`` | STL unordered set | :file:`pybind11/stl.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::optional<T>`` | STL optional type (C++17) | :file:`pybind11/stl.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::experimental::optional<T>`` | STL optional type (exp.) | :file:`pybind11/stl.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::function<...>`` | STL polymorphic function | :file:`pybind11/functional.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::chrono::duration<...>`` | STL time duration | :file:`pybind11/chrono.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``std::chrono::time_point<...>`` | STL date/time | :file:`pybind11/chrono.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``Eigen::Matrix<...>`` | Eigen: dense matrix | :file:`pybind11/eigen.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``Eigen::Map<...>`` | Eigen: mapped memory | :file:`pybind11/eigen.h` |
-+------------------------------------+---------------------------+-------------------------------+
-| ``Eigen::SparseMatrix<...>`` | Eigen: sparse matrix | :file:`pybind11/eigen.h` |
-+------------------------------------+---------------------------+-------------------------------+
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/cast/stl.rst b/thirdparty/pybind11/pybind11/docs/advanced/cast/stl.rst
deleted file mode 100644
index c76da5ca1fc573f7b5a4f69072b9da7c7dc64bd0..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/cast/stl.rst
+++ /dev/null
@@ -1,156 +0,0 @@
-STL containers
-##############
-
-Automatic conversion
-====================
-
-When including the additional header file :file:`pybind11/stl.h`, conversions
-between ``std::vector<>``/``std::list<>``/``std::array<>``,
-``std::set<>``/``std::unordered_set<>``, and
-``std::map<>``/``std::unordered_map<>`` and the Python ``list``, ``set`` and
-``dict`` data structures are automatically enabled. The types ``std::pair<>``
-and ``std::tuple<>`` are already supported out of the box with just the core
-:file:`pybind11/pybind11.h` header.
-
-The major downside of these implicit conversions is that containers must be
-converted (i.e. copied) on every Python->C++ and C++->Python transition, which
-can have implications on the program semantics and performance. Please read the
-next sections for more details and alternative approaches that avoid this.
-
-.. note::
-
- Arbitrary nesting of any of these types is possible.
-
-.. seealso::
-
- The file :file:`tests/test_python_types.cpp` contains a complete
- example that demonstrates how to pass STL data types in more detail.
-
-.. _opaque:
-
-Making opaque types
-===================
-
-pybind11 heavily relies on a template matching mechanism to convert parameters
-and return values that are constructed from STL data types such as vectors,
-linked lists, hash tables, etc. This even works in a recursive manner, for
-instance to deal with lists of hash maps of pairs of elementary and custom
-types, etc.
-
-However, a fundamental limitation of this approach is that internal conversions
-between Python and C++ types involve a copy operation that prevents
-pass-by-reference semantics. What does this mean?
-
-Suppose we bind the following function
-
-.. code-block:: cpp
-
- void append_1(std::vector<int> &v) {
- v.push_back(1);
- }
-
-and call it from Python, the following happens:
-
-.. code-block:: pycon
-
- >>> v = [5, 6]
- >>> append_1(v)
- >>> print(v)
- [5, 6]
-
-As you can see, when passing STL data structures by reference, modifications
-are not propagated back the Python side. A similar situation arises when
-exposing STL data structures using the ``def_readwrite`` or ``def_readonly``
-functions:
-
-.. code-block:: cpp
-
- /* ... definition ... */
-
- class MyClass {
- std::vector<int> contents;
- };
-
- /* ... binding code ... */
-
- py::class_<MyClass>(m, "MyClass")
- .def(py::init<>())
- .def_readwrite("contents", &MyClass::contents);
-
-In this case, properties can be read and written in their entirety. However, an
-``append`` operation involving such a list type has no effect:
-
-.. code-block:: pycon
-
- >>> m = MyClass()
- >>> m.contents = [5, 6]
- >>> print(m.contents)
- [5, 6]
- >>> m.contents.append(7)
- >>> print(m.contents)
- [5, 6]
-
-Finally, the involved copy operations can be costly when dealing with very
-large lists. To deal with all of the above situations, pybind11 provides a
-macro named ``PYBIND11_MAKE_OPAQUE(T)`` that disables the template-based
-conversion machinery of types, thus rendering them *opaque*. The contents of
-opaque objects are never inspected or extracted, hence they *can* be passed by
-reference. For instance, to turn ``std::vector<int>`` into an opaque type, add
-the declaration
-
-.. code-block:: cpp
-
- PYBIND11_MAKE_OPAQUE(std::vector<int>);
-
-before any binding code (e.g. invocations to ``class_::def()``, etc.). This
-macro must be specified at the top level (and outside of any namespaces), since
-it instantiates a partial template overload. If your binding code consists of
-multiple compilation units, it must be present in every file preceding any
-usage of ``std::vector<int>``. Opaque types must also have a corresponding
-``class_`` declaration to associate them with a name in Python, and to define a
-set of available operations, e.g.:
-
-.. code-block:: cpp
-
- py::class_<std::vector<int>>(m, "IntVector")
- .def(py::init<>())
- .def("clear", &std::vector<int>::clear)
- .def("pop_back", &std::vector<int>::pop_back)
- .def("__len__", [](const std::vector<int> &v) { return v.size(); })
- .def("__iter__", [](std::vector<int> &v) {
- return py::make_iterator(v.begin(), v.end());
- }, py::keep_alive<0, 1>()) /* Keep vector alive while iterator is used */
- // ....
-
-The ability to expose STL containers as native Python objects is a fairly
-common request, hence pybind11 also provides an optional header file named
-:file:`pybind11/stl_bind.h` that does exactly this. The mapped containers try
-to match the behavior of their native Python counterparts as much as possible.
-
-The following example showcases usage of :file:`pybind11/stl_bind.h`:
-
-.. code-block:: cpp
-
- // Don't forget this
- #include <pybind11/stl_bind.h>
-
- PYBIND11_MAKE_OPAQUE(std::vector<int>);
- PYBIND11_MAKE_OPAQUE(std::map<std::string, double>);
-
- // ...
-
- // later in binding code:
- py::bind_vector<std::vector<int>>(m, "VectorInt");
- py::bind_map<std::map<std::string, double>>(m, "MapStringDouble");
-
-Please take a look at the :ref:`macro_notes` before using the
-``PYBIND11_MAKE_OPAQUE`` macro.
-
-.. seealso::
-
- The file :file:`tests/test_opaque_types.cpp` contains a complete
- example that demonstrates how to create and expose opaque types using
- pybind11 in more detail.
-
- The file :file:`tests/test_stl_binders.cpp` shows how to use the
- convenience STL container wrappers.
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/cast/strings.rst b/thirdparty/pybind11/pybind11/docs/advanced/cast/strings.rst
deleted file mode 100644
index c70fb0bece080da8a8af174e64739fc344d89b6b..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/cast/strings.rst
+++ /dev/null
@@ -1,243 +0,0 @@
-Strings, bytes and Unicode conversions
-######################################
-
-.. note::
-
- This section discusses string handling in terms of Python 3 strings. For Python 2.7, replace all occurrences of ``str`` with ``unicode`` and ``bytes`` with ``str``. Python 2.7 users may find it best to use ``from __future__ import unicode_literals`` to avoid unintentionally using ``str`` instead of ``unicode``.
-
-Passing Python strings to C++
-=============================
-
-When a Python ``str`` is passed from Python to a C++ function that accepts ``std::string`` or ``char *`` as arguments, pybind11 will encode the Python string to UTF-8. All Python ``str`` can be encoded in UTF-8, so this operation does not fail.
-
-The C++ language is encoding agnostic. It is the responsibility of the programmer to track encodings. It's often easiest to simply `use UTF-8 everywhere <http://utf8everywhere.org/>`_.
-
-.. code-block:: c++
-
- m.def("utf8_test",
- [](const std::string &s) {
- cout << "utf-8 is icing on the cake.\n";
- cout << s;
- }
- );
- m.def("utf8_charptr",
- [](const char *s) {
- cout << "My favorite food is\n";
- cout << s;
- }
- );
-
-.. code-block:: python
-
- >>> utf8_test('🎂')
- utf-8 is icing on the cake.
- 🎂
-
- >>> utf8_charptr('ðŸ•')
- My favorite food is
- ðŸ•
-
-.. note::
-
- Some terminal emulators do not support UTF-8 or emoji fonts and may not display the example above correctly.
-
-The results are the same whether the C++ function accepts arguments by value or reference, and whether or not ``const`` is used.
-
-Passing bytes to C++
---------------------
-
-A Python ``bytes`` object will be passed to C++ functions that accept ``std::string`` or ``char*`` *without* conversion.
-
-
-Returning C++ strings to Python
-===============================
-
-When a C++ function returns a ``std::string`` or ``char*`` to a Python caller, **pybind11 will assume that the string is valid UTF-8** and will decode it to a native Python ``str``, using the same API as Python uses to perform ``bytes.decode('utf-8')``. If this implicit conversion fails, pybind11 will raise a ``UnicodeDecodeError``.
-
-.. code-block:: c++
-
- m.def("std_string_return",
- []() {
- return std::string("This string needs to be UTF-8 encoded");
- }
- );
-
-.. code-block:: python
-
- >>> isinstance(example.std_string_return(), str)
- True
-
-
-Because UTF-8 is inclusive of pure ASCII, there is never any issue with returning a pure ASCII string to Python. If there is any possibility that the string is not pure ASCII, it is necessary to ensure the encoding is valid UTF-8.
-
-.. warning::
-
- Implicit conversion assumes that a returned ``char *`` is null-terminated. If there is no null terminator a buffer overrun will occur.
-
-Explicit conversions
---------------------
-
-If some C++ code constructs a ``std::string`` that is not a UTF-8 string, one can perform a explicit conversion and return a ``py::str`` object. Explicit conversion has the same overhead as implicit conversion.
-
-.. code-block:: c++
-
- // This uses the Python C API to convert Latin-1 to Unicode
- m.def("str_output",
- []() {
- std::string s = "Send your r\xe9sum\xe9 to Alice in HR"; // Latin-1
- py::str py_s = PyUnicode_DecodeLatin1(s.data(), s.length());
- return py_s;
- }
- );
-
-.. code-block:: python
-
- >>> str_output()
- 'Send your résumé to Alice in HR'
-
-The `Python C API <https://docs.python.org/3/c-api/unicode.html#built-in-codecs>`_ provides several built-in codecs.
-
-
-One could also use a third party encoding library such as libiconv to transcode to UTF-8.
-
-Return C++ strings without conversion
--------------------------------------
-
-If the data in a C++ ``std::string`` does not represent text and should be returned to Python as ``bytes``, then one can return the data as a ``py::bytes`` object.
-
-.. code-block:: c++
-
- m.def("return_bytes",
- []() {
- std::string s("\xba\xd0\xba\xd0"); // Not valid UTF-8
- return py::bytes(s); // Return the data without transcoding
- }
- );
-
-.. code-block:: python
-
- >>> example.return_bytes()
- b'\xba\xd0\xba\xd0'
-
-
-Note the asymmetry: pybind11 will convert ``bytes`` to ``std::string`` without encoding, but cannot convert ``std::string`` back to ``bytes`` implicitly.
-
-.. code-block:: c++
-
- m.def("asymmetry",
- [](std::string s) { // Accepts str or bytes from Python
- return s; // Looks harmless, but implicitly converts to str
- }
- );
-
-.. code-block:: python
-
- >>> isinstance(example.asymmetry(b"have some bytes"), str)
- True
-
- >>> example.asymmetry(b"\xba\xd0\xba\xd0") # invalid utf-8 as bytes
- UnicodeDecodeError: 'utf-8' codec can't decode byte 0xba in position 0: invalid start byte
-
-
-Wide character strings
-======================
-
-When a Python ``str`` is passed to a C++ function expecting ``std::wstring``, ``wchar_t*``, ``std::u16string`` or ``std::u32string``, the ``str`` will be encoded to UTF-16 or UTF-32 depending on how the C++ compiler implements each type, in the platform's endian. When strings of these types are returned, they are assumed to contain valid UTF-16 or UTF-32, and will be decoded to Python ``str``.
-
-.. code-block:: c++
-
- #define UNICODE
- #include <windows.h>
-
- m.def("set_window_text",
- [](HWND hwnd, std::wstring s) {
- // Call SetWindowText with null-terminated UTF-16 string
- ::SetWindowText(hwnd, s.c_str());
- }
- );
- m.def("get_window_text",
- [](HWND hwnd) {
- const int buffer_size = ::GetWindowTextLength(hwnd) + 1;
- auto buffer = std::make_unique< wchar_t[] >(buffer_size);
-
- ::GetWindowText(hwnd, buffer.data(), buffer_size);
-
- std::wstring text(buffer.get());
-
- // wstring will be converted to Python str
- return text;
- }
- );
-
-.. warning::
-
- Wide character strings may not work as described on Python 2.7 or Python 3.3 compiled with ``--enable-unicode=ucs2``.
-
-Strings in multibyte encodings such as Shift-JIS must transcoded to a UTF-8/16/32 before being returned to Python.
-
-
-Character literals
-==================
-
-C++ functions that accept character literals as input will receive the first character of a Python ``str`` as their input. If the string is longer than one Unicode character, trailing characters will be ignored.
-
-When a character literal is returned from C++ (such as a ``char`` or a ``wchar_t``), it will be converted to a ``str`` that represents the single character.
-
-.. code-block:: c++
-
- m.def("pass_char", [](char c) { return c; });
- m.def("pass_wchar", [](wchar_t w) { return w; });
-
-.. code-block:: python
-
- >>> example.pass_char('A')
- 'A'
-
-While C++ will cast integers to character types (``char c = 0x65;``), pybind11 does not convert Python integers to characters implicitly. The Python function ``chr()`` can be used to convert integers to characters.
-
-.. code-block:: python
-
- >>> example.pass_char(0x65)
- TypeError
-
- >>> example.pass_char(chr(0x65))
- 'A'
-
-If the desire is to work with an 8-bit integer, use ``int8_t`` or ``uint8_t`` as the argument type.
-
-Grapheme clusters
------------------
-
-A single grapheme may be represented by two or more Unicode characters. For example 'é' is usually represented as U+00E9 but can also be expressed as the combining character sequence U+0065 U+0301 (that is, the letter 'e' followed by a combining acute accent). The combining character will be lost if the two-character sequence is passed as an argument, even though it renders as a single grapheme.
-
-.. code-block:: python
-
- >>> example.pass_wchar('é')
- 'é'
-
- >>> combining_e_acute = 'e' + '\u0301'
-
- >>> combining_e_acute
- 'eÌ'
-
- >>> combining_e_acute == 'é'
- False
-
- >>> example.pass_wchar(combining_e_acute)
- 'e'
-
-Normalizing combining characters before passing the character literal to C++ may resolve *some* of these issues:
-
-.. code-block:: python
-
- >>> example.pass_wchar(unicodedata.normalize('NFC', combining_e_acute))
- 'é'
-
-In some languages (Thai for example), there are `graphemes that cannot be expressed as a single Unicode code point <http://unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries>`_, so there is no way to capture them in a C++ character type.
-
-
-References
-==========
-
-* `The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!) <https://www.joelonsoftware.com/2003/10/08/the-absolute-minimum-every-software-developer-absolutely-positively-must-know-about-unicode-and-character-sets-no-excuses/>`_
-* `C++ - Using STL Strings at Win32 API Boundaries <https://msdn.microsoft.com/en-ca/magazine/mt238407.aspx>`_
\ No newline at end of file
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/classes.rst b/thirdparty/pybind11/pybind11/docs/advanced/classes.rst
deleted file mode 100644
index 8896441b6647600ed3bf3dd4b73f71b00687a70e..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/classes.rst
+++ /dev/null
@@ -1,657 +0,0 @@
-Classes
-#######
-
-This section presents advanced binding code for classes and it is assumed
-that you are already familiar with the basics from :doc:`/classes`.
-
-.. _overriding_virtuals:
-
-Overriding virtual functions in Python
-======================================
-
-Suppose that a C++ class or interface has a virtual function that we'd like to
-to override from within Python (we'll focus on the class ``Animal``; ``Dog`` is
-given as a specific example of how one would do this with traditional C++
-code).
-
-.. code-block:: cpp
-
- class Animal {
- public:
- virtual ~Animal() { }
- virtual std::string go(int n_times) = 0;
- };
-
- class Dog : public Animal {
- public:
- std::string go(int n_times) override {
- std::string result;
- for (int i=0; i<n_times; ++i)
- result += "woof! ";
- return result;
- }
- };
-
-Let's also suppose that we are given a plain function which calls the
-function ``go()`` on an arbitrary ``Animal`` instance.
-
-.. code-block:: cpp
-
- std::string call_go(Animal *animal) {
- return animal->go(3);
- }
-
-Normally, the binding code for these classes would look as follows:
-
-.. code-block:: cpp
-
- PYBIND11_PLUGIN(example) {
- py::module m("example", "pybind11 example plugin");
-
- py::class_<Animal> animal(m, "Animal");
- animal
- .def("go", &Animal::go);
-
- py::class_<Dog>(m, "Dog", animal)
- .def(py::init<>());
-
- m.def("call_go", &call_go);
-
- return m.ptr();
- }
-
-However, these bindings are impossible to extend: ``Animal`` is not
-constructible, and we clearly require some kind of "trampoline" that
-redirects virtual calls back to Python.
-
-Defining a new type of ``Animal`` from within Python is possible but requires a
-helper class that is defined as follows:
-
-.. code-block:: cpp
-
- class PyAnimal : public Animal {
- public:
- /* Inherit the constructors */
- using Animal::Animal;
-
- /* Trampoline (need one for each virtual function) */
- std::string go(int n_times) override {
- PYBIND11_OVERLOAD_PURE(
- std::string, /* Return type */
- Animal, /* Parent class */
- go, /* Name of function in C++ (must match Python name) */
- n_times /* Argument(s) */
- );
- }
- };
-
-The macro :func:`PYBIND11_OVERLOAD_PURE` should be used for pure virtual
-functions, and :func:`PYBIND11_OVERLOAD` should be used for functions which have
-a default implementation. There are also two alternate macros
-:func:`PYBIND11_OVERLOAD_PURE_NAME` and :func:`PYBIND11_OVERLOAD_NAME` which
-take a string-valued name argument between the *Parent class* and *Name of the
-function* slots, which defines the name of function in Python. This is required
-when the C++ and Python versions of the
-function have different names, e.g. ``operator()`` vs ``__call__``.
-
-The binding code also needs a few minor adaptations (highlighted):
-
-.. code-block:: cpp
- :emphasize-lines: 4,6,7
-
- PYBIND11_PLUGIN(example) {
- py::module m("example", "pybind11 example plugin");
-
- py::class_<Animal, PyAnimal /* <--- trampoline*/> animal(m, "Animal");
- animal
- .def(py::init<>())
- .def("go", &Animal::go);
-
- py::class_<Dog>(m, "Dog", animal)
- .def(py::init<>());
-
- m.def("call_go", &call_go);
-
- return m.ptr();
- }
-
-Importantly, pybind11 is made aware of the trampoline helper class by
-specifying it as an extra template argument to :class:`class_`. (This can also
-be combined with other template arguments such as a custom holder type; the
-order of template types does not matter). Following this, we are able to
-define a constructor as usual.
-
-Bindings should be made against the actual class, not the trampoline helper class.
-
-.. code-block:: cpp
-
- py::class_<Animal, PyAnimal /* <--- trampoline*/> animal(m, "Animal");
- animal
- .def(py::init<>())
- .def("go", &PyAnimal::go); /* <--- THIS IS WRONG, use &Animal::go */
-
-Note, however, that the above is sufficient for allowing python classes to
-extend ``Animal``, but not ``Dog``: see ref:`virtual_and_inheritance` for the
-necessary steps required to providing proper overload support for inherited
-classes.
-
-The Python session below shows how to override ``Animal::go`` and invoke it via
-a virtual method call.
-
-.. code-block:: pycon
-
- >>> from example import *
- >>> d = Dog()
- >>> call_go(d)
- u'woof! woof! woof! '
- >>> class Cat(Animal):
- ... def go(self, n_times):
- ... return "meow! " * n_times
- ...
- >>> c = Cat()
- >>> call_go(c)
- u'meow! meow! meow! '
-
-Please take a look at the :ref:`macro_notes` before using this feature.
-
-.. note::
-
- When the overridden type returns a reference or pointer to a type that
- pybind11 converts from Python (for example, numeric values, std::string,
- and other built-in value-converting types), there are some limitations to
- be aware of:
-
- - because in these cases there is no C++ variable to reference (the value
- is stored in the referenced Python variable), pybind11 provides one in
- the PYBIND11_OVERLOAD macros (when needed) with static storage duration.
- Note that this means that invoking the overloaded method on *any*
- instance will change the referenced value stored in *all* instances of
- that type.
-
- - Attempts to modify a non-const reference will not have the desired
- effect: it will change only the static cache variable, but this change
- will not propagate to underlying Python instance, and the change will be
- replaced the next time the overload is invoked.
-
-.. seealso::
-
- The file :file:`tests/test_virtual_functions.cpp` contains a complete
- example that demonstrates how to override virtual functions using pybind11
- in more detail.
-
-.. _virtual_and_inheritance:
-
-Combining virtual functions and inheritance
-===========================================
-
-When combining virtual methods with inheritance, you need to be sure to provide
-an override for each method for which you want to allow overrides from derived
-python classes. For example, suppose we extend the above ``Animal``/``Dog``
-example as follows:
-
-.. code-block:: cpp
-
- class Animal {
- public:
- virtual std::string go(int n_times) = 0;
- virtual std::string name() { return "unknown"; }
- };
- class Dog : public Animal {
- public:
- std::string go(int n_times) override {
- std::string result;
- for (int i=0; i<n_times; ++i)
- result += bark() + " ";
- return result;
- }
- virtual std::string bark() { return "woof!"; }
- };
-
-then the trampoline class for ``Animal`` must, as described in the previous
-section, override ``go()`` and ``name()``, but in order to allow python code to
-inherit properly from ``Dog``, we also need a trampoline class for ``Dog`` that
-overrides both the added ``bark()`` method *and* the ``go()`` and ``name()``
-methods inherited from ``Animal`` (even though ``Dog`` doesn't directly
-override the ``name()`` method):
-
-.. code-block:: cpp
-
- class PyAnimal : public Animal {
- public:
- using Animal::Animal; // Inherit constructors
- std::string go(int n_times) override { PYBIND11_OVERLOAD_PURE(std::string, Animal, go, n_times); }
- std::string name() override { PYBIND11_OVERLOAD(std::string, Animal, name, ); }
- };
- class PyDog : public Dog {
- public:
- using Dog::Dog; // Inherit constructors
- std::string go(int n_times) override { PYBIND11_OVERLOAD_PURE(std::string, Dog, go, n_times); }
- std::string name() override { PYBIND11_OVERLOAD(std::string, Dog, name, ); }
- std::string bark() override { PYBIND11_OVERLOAD(std::string, Dog, bark, ); }
- };
-
-.. note::
-
- Note the trailing commas in the ``PYBIND11_OVERLOAD`` calls to ``name()``
- and ``bark()``. These are needed to portably implement a trampoline for a
- function that does not take any arguments. For functions that take
- a nonzero number of arguments, the trailing comma must be omitted.
-
-A registered class derived from a pybind11-registered class with virtual
-methods requires a similar trampoline class, *even if* it doesn't explicitly
-declare or override any virtual methods itself:
-
-.. code-block:: cpp
-
- class Husky : public Dog {};
- class PyHusky : public Husky {
- public:
- using Husky::Husky; // Inherit constructors
- std::string go(int n_times) override { PYBIND11_OVERLOAD_PURE(std::string, Husky, go, n_times); }
- std::string name() override { PYBIND11_OVERLOAD(std::string, Husky, name, ); }
- std::string bark() override { PYBIND11_OVERLOAD(std::string, Husky, bark, ); }
- };
-
-There is, however, a technique that can be used to avoid this duplication
-(which can be especially helpful for a base class with several virtual
-methods). The technique involves using template trampoline classes, as
-follows:
-
-.. code-block:: cpp
-
- template <class AnimalBase = Animal> class PyAnimal : public AnimalBase {
- public:
- using AnimalBase::AnimalBase; // Inherit constructors
- std::string go(int n_times) override { PYBIND11_OVERLOAD_PURE(std::string, AnimalBase, go, n_times); }
- std::string name() override { PYBIND11_OVERLOAD(std::string, AnimalBase, name, ); }
- };
- template <class DogBase = Dog> class PyDog : public PyAnimal<DogBase> {
- public:
- using PyAnimal<DogBase>::PyAnimal; // Inherit constructors
- // Override PyAnimal's pure virtual go() with a non-pure one:
- std::string go(int n_times) override { PYBIND11_OVERLOAD(std::string, DogBase, go, n_times); }
- std::string bark() override { PYBIND11_OVERLOAD(std::string, DogBase, bark, ); }
- };
-
-This technique has the advantage of requiring just one trampoline method to be
-declared per virtual method and pure virtual method override. It does,
-however, require the compiler to generate at least as many methods (and
-possibly more, if both pure virtual and overridden pure virtual methods are
-exposed, as above).
-
-The classes are then registered with pybind11 using:
-
-.. code-block:: cpp
-
- py::class_<Animal, PyAnimal<>> animal(m, "Animal");
- py::class_<Dog, PyDog<>> dog(m, "Dog");
- py::class_<Husky, PyDog<Husky>> husky(m, "Husky");
- // ... add animal, dog, husky definitions
-
-Note that ``Husky`` did not require a dedicated trampoline template class at
-all, since it neither declares any new virtual methods nor provides any pure
-virtual method implementations.
-
-With either the repeated-virtuals or templated trampoline methods in place, you
-can now create a python class that inherits from ``Dog``:
-
-.. code-block:: python
-
- class ShihTzu(Dog):
- def bark(self):
- return "yip!"
-
-.. seealso::
-
- See the file :file:`tests/test_virtual_functions.cpp` for complete examples
- using both the duplication and templated trampoline approaches.
-
-Extended trampoline class functionality
-=======================================
-
-The trampoline classes described in the previous sections are, by default, only
-initialized when needed. More specifically, they are initialized when a python
-class actually inherits from a registered type (instead of merely creating an
-instance of the registered type), or when a registered constructor is only
-valid for the trampoline class but not the registered class. This is primarily
-for performance reasons: when the trampoline class is not needed for anything
-except virtual method dispatching, not initializing the trampoline class
-improves performance by avoiding needing to do a run-time check to see if the
-inheriting python instance has an overloaded method.
-
-Sometimes, however, it is useful to always initialize a trampoline class as an
-intermediate class that does more than just handle virtual method dispatching.
-For example, such a class might perform extra class initialization, extra
-destruction operations, and might define new members and methods to enable a
-more python-like interface to a class.
-
-In order to tell pybind11 that it should *always* initialize the trampoline
-class when creating new instances of a type, the class constructors should be
-declared using ``py::init_alias<Args, ...>()`` instead of the usual
-``py::init<Args, ...>()``. This forces construction via the trampoline class,
-ensuring member initialization and (eventual) destruction.
-
-.. seealso::
-
- See the file :file:`tests/test_alias_initialization.cpp` for complete examples
- showing both normal and forced trampoline instantiation.
-
-.. _custom_constructors:
-
-Custom constructors
-===================
-
-The syntax for binding constructors was previously introduced, but it only
-works when a constructor with the given parameters actually exists on the C++
-side. To extend this to more general cases, let's take a look at what actually
-happens under the hood: the following statement
-
-.. code-block:: cpp
-
- py::class_<Example>(m, "Example")
- .def(py::init<int>());
-
-is short hand notation for
-
-.. code-block:: cpp
-
- py::class_<Example>(m, "Example")
- .def("__init__",
- [](Example &instance, int arg) {
- new (&instance) Example(arg);
- }
- );
-
-In other words, :func:`init` creates an anonymous function that invokes an
-in-place constructor. Memory allocation etc. is already take care of beforehand
-within pybind11.
-
-.. _classes_with_non_public_destructors:
-
-Non-public destructors
-======================
-
-If a class has a private or protected destructor (as might e.g. be the case in
-a singleton pattern), a compile error will occur when creating bindings via
-pybind11. The underlying issue is that the ``std::unique_ptr`` holder type that
-is responsible for managing the lifetime of instances will reference the
-destructor even if no deallocations ever take place. In order to expose classes
-with private or protected destructors, it is possible to override the holder
-type via a holder type argument to ``class_``. Pybind11 provides a helper class
-``py::nodelete`` that disables any destructor invocations. In this case, it is
-crucial that instances are deallocated on the C++ side to avoid memory leaks.
-
-.. code-block:: cpp
-
- /* ... definition ... */
-
- class MyClass {
- private:
- ~MyClass() { }
- };
-
- /* ... binding code ... */
-
- py::class_<MyClass, std::unique_ptr<MyClass, py::nodelete>>(m, "MyClass")
- .def(py::init<>())
-
-.. _implicit_conversions:
-
-Implicit conversions
-====================
-
-Suppose that instances of two types ``A`` and ``B`` are used in a project, and
-that an ``A`` can easily be converted into an instance of type ``B`` (examples of this
-could be a fixed and an arbitrary precision number type).
-
-.. code-block:: cpp
-
- py::class_<A>(m, "A")
- /// ... members ...
-
- py::class_<B>(m, "B")
- .def(py::init<A>())
- /// ... members ...
-
- m.def("func",
- [](const B &) { /* .... */ }
- );
-
-To invoke the function ``func`` using a variable ``a`` containing an ``A``
-instance, we'd have to write ``func(B(a))`` in Python. On the other hand, C++
-will automatically apply an implicit type conversion, which makes it possible
-to directly write ``func(a)``.
-
-In this situation (i.e. where ``B`` has a constructor that converts from
-``A``), the following statement enables similar implicit conversions on the
-Python side:
-
-.. code-block:: cpp
-
- py::implicitly_convertible<A, B>();
-
-.. note::
-
- Implicit conversions from ``A`` to ``B`` only work when ``B`` is a custom
- data type that is exposed to Python via pybind11.
-
-.. _static_properties:
-
-Static properties
-=================
-
-The section on :ref:`properties` discussed the creation of instance properties
-that are implemented in terms of C++ getters and setters.
-
-Static properties can also be created in a similar way to expose getters and
-setters of static class attributes. Note that the implicit ``self`` argument
-also exists in this case and is used to pass the Python ``type`` subclass
-instance. This parameter will often not be needed by the C++ side, and the
-following example illustrates how to instantiate a lambda getter function
-that ignores it:
-
-.. code-block:: cpp
-
- py::class_<Foo>(m, "Foo")
- .def_property_readonly_static("foo", [](py::object /* self */) { return Foo(); });
-
-Operator overloading
-====================
-
-Suppose that we're given the following ``Vector2`` class with a vector addition
-and scalar multiplication operation, all implemented using overloaded operators
-in C++.
-
-.. code-block:: cpp
-
- class Vector2 {
- public:
- Vector2(float x, float y) : x(x), y(y) { }
-
- Vector2 operator+(const Vector2 &v) const { return Vector2(x + v.x, y + v.y); }
- Vector2 operator*(float value) const { return Vector2(x * value, y * value); }
- Vector2& operator+=(const Vector2 &v) { x += v.x; y += v.y; return *this; }
- Vector2& operator*=(float v) { x *= v; y *= v; return *this; }
-
- friend Vector2 operator*(float f, const Vector2 &v) {
- return Vector2(f * v.x, f * v.y);
- }
-
- std::string toString() const {
- return "[" + std::to_string(x) + ", " + std::to_string(y) + "]";
- }
- private:
- float x, y;
- };
-
-The following snippet shows how the above operators can be conveniently exposed
-to Python.
-
-.. code-block:: cpp
-
- #include <pybind11/operators.h>
-
- PYBIND11_PLUGIN(example) {
- py::module m("example", "pybind11 example plugin");
-
- py::class_<Vector2>(m, "Vector2")
- .def(py::init<float, float>())
- .def(py::self + py::self)
- .def(py::self += py::self)
- .def(py::self *= float())
- .def(float() * py::self)
- .def(py::self * float())
- .def("__repr__", &Vector2::toString);
-
- return m.ptr();
- }
-
-Note that a line like
-
-.. code-block:: cpp
-
- .def(py::self * float())
-
-is really just short hand notation for
-
-.. code-block:: cpp
-
- .def("__mul__", [](const Vector2 &a, float b) {
- return a * b;
- }, py::is_operator())
-
-This can be useful for exposing additional operators that don't exist on the
-C++ side, or to perform other types of customization. The ``py::is_operator``
-flag marker is needed to inform pybind11 that this is an operator, which
-returns ``NotImplemented`` when invoked with incompatible arguments rather than
-throwing a type error.
-
-.. note::
-
- To use the more convenient ``py::self`` notation, the additional
- header file :file:`pybind11/operators.h` must be included.
-
-.. seealso::
-
- The file :file:`tests/test_operator_overloading.cpp` contains a
- complete example that demonstrates how to work with overloaded operators in
- more detail.
-
-Pickling support
-================
-
-Python's ``pickle`` module provides a powerful facility to serialize and
-de-serialize a Python object graph into a binary data stream. To pickle and
-unpickle C++ classes using pybind11, two additional functions must be provided.
-Suppose the class in question has the following signature:
-
-.. code-block:: cpp
-
- class Pickleable {
- public:
- Pickleable(const std::string &value) : m_value(value) { }
- const std::string &value() const { return m_value; }
-
- void setExtra(int extra) { m_extra = extra; }
- int extra() const { return m_extra; }
- private:
- std::string m_value;
- int m_extra = 0;
- };
-
-The binding code including the requisite ``__setstate__`` and ``__getstate__`` methods [#f3]_
-looks as follows:
-
-.. code-block:: cpp
-
- py::class_<Pickleable>(m, "Pickleable")
- .def(py::init<std::string>())
- .def("value", &Pickleable::value)
- .def("extra", &Pickleable::extra)
- .def("setExtra", &Pickleable::setExtra)
- .def("__getstate__", [](const Pickleable &p) {
- /* Return a tuple that fully encodes the state of the object */
- return py::make_tuple(p.value(), p.extra());
- })
- .def("__setstate__", [](Pickleable &p, py::tuple t) {
- if (t.size() != 2)
- throw std::runtime_error("Invalid state!");
-
- /* Invoke the in-place constructor. Note that this is needed even
- when the object just has a trivial default constructor */
- new (&p) Pickleable(t[0].cast<std::string>());
-
- /* Assign any additional state */
- p.setExtra(t[1].cast<int>());
- });
-
-An instance can now be pickled as follows:
-
-.. code-block:: python
-
- try:
- import cPickle as pickle # Use cPickle on Python 2.7
- except ImportError:
- import pickle
-
- p = Pickleable("test_value")
- p.setExtra(15)
- data = pickle.dumps(p, 2)
-
-Note that only the cPickle module is supported on Python 2.7. The second
-argument to ``dumps`` is also crucial: it selects the pickle protocol version
-2, since the older version 1 is not supported. Newer versions are also fine—for
-instance, specify ``-1`` to always use the latest available version. Beware:
-failure to follow these instructions will cause important pybind11 memory
-allocation routines to be skipped during unpickling, which will likely lead to
-memory corruption and/or segmentation faults.
-
-.. seealso::
-
- The file :file:`tests/test_pickling.cpp` contains a complete example
- that demonstrates how to pickle and unpickle types using pybind11 in more
- detail.
-
-.. [#f3] http://docs.python.org/3/library/pickle.html#pickling-class-instances
-
-Multiple Inheritance
-====================
-
-pybind11 can create bindings for types that derive from multiple base types
-(aka. *multiple inheritance*). To do so, specify all bases in the template
-arguments of the ``class_`` declaration:
-
-.. code-block:: cpp
-
- py::class_<MyType, BaseType1, BaseType2, BaseType3>(m, "MyType")
- ...
-
-The base types can be specified in arbitrary order, and they can even be
-interspersed with alias types and holder types (discussed earlier in this
-document)---pybind11 will automatically find out which is which. The only
-requirement is that the first template argument is the type to be declared.
-
-There are two caveats regarding the implementation of this feature:
-
-1. When only one base type is specified for a C++ type that actually has
- multiple bases, pybind11 will assume that it does not participate in
- multiple inheritance, which can lead to undefined behavior. In such cases,
- add the tag ``multiple_inheritance``:
-
- .. code-block:: cpp
-
- py::class_<MyType, BaseType2>(m, "MyType", py::multiple_inheritance());
-
- The tag is redundant and does not need to be specified when multiple base
- types are listed.
-
-2. As was previously discussed in the section on :ref:`overriding_virtuals`, it
- is easy to create Python types that derive from C++ classes. It is even
- possible to make use of multiple inheritance to declare a Python class which
- has e.g. a C++ and a Python class as bases. However, any attempt to create a
- type that has *two or more* C++ classes in its hierarchy of base types will
- fail with a fatal error message: ``TypeError: multiple bases have instance
- lay-out conflict``. Core Python types that are implemented in C (e.g.
- ``dict``, ``list``, ``Exception``, etc.) also fall under this combination
- and cannot be combined with C++ types bound using pybind11 via multiple
- inheritance.
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/exceptions.rst b/thirdparty/pybind11/pybind11/docs/advanced/exceptions.rst
deleted file mode 100644
index 348337916dbd8ff259df61be51bee13ecf0ba979..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/exceptions.rst
+++ /dev/null
@@ -1,142 +0,0 @@
-Exceptions
-##########
-
-Built-in exception translation
-==============================
-
-When C++ code invoked from Python throws an ``std::exception``, it is
-automatically converted into a Python ``Exception``. pybind11 defines multiple
-special exception classes that will map to different types of Python
-exceptions:
-
-.. tabularcolumns:: |p{0.5\textwidth}|p{0.45\textwidth}|
-
-+--------------------------------------+------------------------------+
-| C++ exception type | Python exception type |
-+======================================+==============================+
-| :class:`std::exception` | ``RuntimeError`` |
-+--------------------------------------+------------------------------+
-| :class:`std::bad_alloc` | ``MemoryError`` |
-+--------------------------------------+------------------------------+
-| :class:`std::domain_error` | ``ValueError`` |
-+--------------------------------------+------------------------------+
-| :class:`std::invalid_argument` | ``ValueError`` |
-+--------------------------------------+------------------------------+
-| :class:`std::length_error` | ``ValueError`` |
-+--------------------------------------+------------------------------+
-| :class:`std::out_of_range` | ``ValueError`` |
-+--------------------------------------+------------------------------+
-| :class:`std::range_error` | ``ValueError`` |
-+--------------------------------------+------------------------------+
-| :class:`pybind11::stop_iteration` | ``StopIteration`` (used to |
-| | implement custom iterators) |
-+--------------------------------------+------------------------------+
-| :class:`pybind11::index_error` | ``IndexError`` (used to |
-| | indicate out of bounds |
-| | accesses in ``__getitem__``, |
-| | ``__setitem__``, etc.) |
-+--------------------------------------+------------------------------+
-| :class:`pybind11::value_error` | ``ValueError`` (used to |
-| | indicate wrong value passed |
-| | in ``container.remove(...)`` |
-+--------------------------------------+------------------------------+
-| :class:`pybind11::key_error` | ``KeyError`` (used to |
-| | indicate out of bounds |
-| | accesses in ``__getitem__``, |
-| | ``__setitem__`` in dict-like |
-| | objects, etc.) |
-+--------------------------------------+------------------------------+
-| :class:`pybind11::error_already_set` | Indicates that the Python |
-| | exception flag has already |
-| | been initialized |
-+--------------------------------------+------------------------------+
-
-When a Python function invoked from C++ throws an exception, it is converted
-into a C++ exception of type :class:`error_already_set` whose string payload
-contains a textual summary.
-
-There is also a special exception :class:`cast_error` that is thrown by
-:func:`handle::call` when the input arguments cannot be converted to Python
-objects.
-
-Registering custom translators
-==============================
-
-If the default exception conversion policy described above is insufficient,
-pybind11 also provides support for registering custom exception translators.
-To register a simple exception conversion that translates a C++ exception into
-a new Python exception using the C++ exception's ``what()`` method, a helper
-function is available:
-
-.. code-block:: cpp
-
- py::register_exception<CppExp>(module, "PyExp");
-
-This call creates a Python exception class with the name ``PyExp`` in the given
-module and automatically converts any encountered exceptions of type ``CppExp``
-into Python exceptions of type ``PyExp``.
-
-When more advanced exception translation is needed, the function
-``py::register_exception_translator(translator)`` can be used to register
-functions that can translate arbitrary exception types (and which may include
-additional logic to do so). The function takes a stateless callable (e.g. a
-function pointer or a lambda function without captured variables) with the call
-signature ``void(std::exception_ptr)``.
-
-When a C++ exception is thrown, the registered exception translators are tried
-in reverse order of registration (i.e. the last registered translator gets the
-first shot at handling the exception).
-
-Inside the translator, ``std::rethrow_exception`` should be used within
-a try block to re-throw the exception. One or more catch clauses to catch
-the appropriate exceptions should then be used with each clause using
-``PyErr_SetString`` to set a Python exception or ``ex(string)`` to set
-the python exception to a custom exception type (see below).
-
-To declare a custom Python exception type, declare a ``py::exception`` variable
-and use this in the associated exception translator (note: it is often useful
-to make this a static declaration when using it inside a lambda expression
-without requiring capturing).
-
-
-The following example demonstrates this for a hypothetical exception classes
-``MyCustomException`` and ``OtherException``: the first is translated to a
-custom python exception ``MyCustomError``, while the second is translated to a
-standard python RuntimeError:
-
-.. code-block:: cpp
-
- static py::exception<MyCustomException> exc(m, "MyCustomError");
- py::register_exception_translator([](std::exception_ptr p) {
- try {
- if (p) std::rethrow_exception(p);
- } catch (const MyCustomException &e) {
- exc(e.what());
- } catch (const OtherException &e) {
- PyErr_SetString(PyExc_RuntimeError, e.what());
- }
- });
-
-Multiple exceptions can be handled by a single translator, as shown in the
-example above. If the exception is not caught by the current translator, the
-previously registered one gets a chance.
-
-If none of the registered exception translators is able to handle the
-exception, it is handled by the default converter as described in the previous
-section.
-
-.. seealso::
-
- The file :file:`tests/test_exceptions.cpp` contains examples
- of various custom exception translators and custom exception types.
-
-.. note::
-
- You must call either ``PyErr_SetString`` or a custom exception's call
- operator (``exc(string)``) for every exception caught in a custom exception
- translator. Failure to do so will cause Python to crash with ``SystemError:
- error return without exception set``.
-
- Exceptions that you do not plan to handle should simply not be caught, or
- may be explicity (re-)thrown to delegate it to the other,
- previously-declared existing exception translators.
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/functions.rst b/thirdparty/pybind11/pybind11/docs/advanced/functions.rst
deleted file mode 100644
index e0b0fe095a57100dc4c4c3d1fc9d060843be07ad..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/functions.rst
+++ /dev/null
@@ -1,409 +0,0 @@
-Functions
-#########
-
-Before proceeding with this section, make sure that you are already familiar
-with the basics of binding functions and classes, as explained in :doc:`/basics`
-and :doc:`/classes`. The following guide is applicable to both free and member
-functions, i.e. *methods* in Python.
-
-.. _return_value_policies:
-
-Return value policies
-=====================
-
-Python and C++ use fundamentally different ways of managing the memory and
-lifetime of objects managed by them. This can lead to issues when creating
-bindings for functions that return a non-trivial type. Just by looking at the
-type information, it is not clear whether Python should take charge of the
-returned value and eventually free its resources, or if this is handled on the
-C++ side. For this reason, pybind11 provides a several *return value policy*
-annotations that can be passed to the :func:`module::def` and
-:func:`class_::def` functions. The default policy is
-:enum:`return_value_policy::automatic`.
-
-Return value policies are tricky, and it's very important to get them right.
-Just to illustrate what can go wrong, consider the following simple example:
-
-.. code-block:: cpp
-
- /* Function declaration */
- Data *get_data() { return _data; /* (pointer to a static data structure) */ }
- ...
-
- /* Binding code */
- m.def("get_data", &get_data); // <-- KABOOM, will cause crash when called from Python
-
-What's going on here? When ``get_data()`` is called from Python, the return
-value (a native C++ type) must be wrapped to turn it into a usable Python type.
-In this case, the default return value policy (:enum:`return_value_policy::automatic`)
-causes pybind11 to assume ownership of the static ``_data`` instance.
-
-When Python's garbage collector eventually deletes the Python
-wrapper, pybind11 will also attempt to delete the C++ instance (via ``operator
-delete()``) due to the implied ownership. At this point, the entire application
-will come crashing down, though errors could also be more subtle and involve
-silent data corruption.
-
-In the above example, the policy :enum:`return_value_policy::reference` should have
-been specified so that the global data instance is only *referenced* without any
-implied transfer of ownership, i.e.:
-
-.. code-block:: cpp
-
- m.def("get_data", &get_data, return_value_policy::reference);
-
-On the other hand, this is not the right policy for many other situations,
-where ignoring ownership could lead to resource leaks.
-As a developer using pybind11, it's important to be familiar with the different
-return value policies, including which situation calls for which one of them.
-The following table provides an overview of available policies:
-
-.. tabularcolumns:: |p{0.5\textwidth}|p{0.45\textwidth}|
-
-+--------------------------------------------------+----------------------------------------------------------------------------+
-| Return value policy | Description |
-+==================================================+============================================================================+
-| :enum:`return_value_policy::take_ownership` | Reference an existing object (i.e. do not create a new copy) and take |
-| | ownership. Python will call the destructor and delete operator when the |
-| | object's reference count reaches zero. Undefined behavior ensues when the |
-| | C++ side does the same, or when the data was not dynamically allocated. |
-+--------------------------------------------------+----------------------------------------------------------------------------+
-| :enum:`return_value_policy::copy` | Create a new copy of the returned object, which will be owned by Python. |
-| | This policy is comparably safe because the lifetimes of the two instances |
-| | are decoupled. |
-+--------------------------------------------------+----------------------------------------------------------------------------+
-| :enum:`return_value_policy::move` | Use ``std::move`` to move the return value contents into a new instance |
-| | that will be owned by Python. This policy is comparably safe because the |
-| | lifetimes of the two instances (move source and destination) are decoupled.|
-+--------------------------------------------------+----------------------------------------------------------------------------+
-| :enum:`return_value_policy::reference` | Reference an existing object, but do not take ownership. The C++ side is |
-| | responsible for managing the object's lifetime and deallocating it when |
-| | it is no longer used. Warning: undefined behavior will ensue when the C++ |
-| | side deletes an object that is still referenced and used by Python. |
-+--------------------------------------------------+----------------------------------------------------------------------------+
-| :enum:`return_value_policy::reference_internal` | Indicates that the lifetime of the return value is tied to the lifetime |
-| | of a parent object, namely the implicit ``this``, or ``self`` argument of |
-| | the called method or property. Internally, this policy works just like |
-| | :enum:`return_value_policy::reference` but additionally applies a |
-| | ``keep_alive<0, 1>`` *call policy* (described in the next section) that |
-| | prevents the parent object from being garbage collected as long as the |
-| | return value is referenced by Python. This is the default policy for |
-| | property getters created via ``def_property``, ``def_readwrite``, etc. |
-+--------------------------------------------------+----------------------------------------------------------------------------+
-| :enum:`return_value_policy::automatic` | **Default policy.** This policy falls back to the policy |
-| | :enum:`return_value_policy::take_ownership` when the return value is a |
-| | pointer. Otherwise, it uses :enum:`return_value_policy::move` or |
-| | :enum:`return_value_policy::copy` for rvalue and lvalue references, |
-| | respectively. See above for a description of what all of these different |
-| | policies do. |
-+--------------------------------------------------+----------------------------------------------------------------------------+
-| :enum:`return_value_policy::automatic_reference` | As above, but use policy :enum:`return_value_policy::reference` when the |
-| | return value is a pointer. This is the default conversion policy for |
-| | function arguments when calling Python functions manually from C++ code |
-| | (i.e. via handle::operator()). You probably won't need to use this. |
-+--------------------------------------------------+----------------------------------------------------------------------------+
-
-Return value policies can also be applied to properties:
-
-.. code-block:: cpp
-
- class_<MyClass>(m, "MyClass")
- .def_property("data", &MyClass::getData, &MyClass::setData,
- py::return_value_policy::copy);
-
-Technically, the code above applies the policy to both the getter and the
-setter function, however, the setter doesn't really care about *return*
-value policies which makes this a convenient terse syntax. Alternatively,
-targeted arguments can be passed through the :class:`cpp_function` constructor:
-
-.. code-block:: cpp
-
- class_<MyClass>(m, "MyClass")
- .def_property("data"
- py::cpp_function(&MyClass::getData, py::return_value_policy::copy),
- py::cpp_function(&MyClass::setData)
- );
-
-.. warning::
-
- Code with invalid return value policies might access unitialized memory or
- free data structures multiple times, which can lead to hard-to-debug
- non-determinism and segmentation faults, hence it is worth spending the
- time to understand all the different options in the table above.
-
-.. note::
-
- One important aspect of the above policies is that they only apply to
- instances which pybind11 has *not* seen before, in which case the policy
- clarifies essential questions about the return value's lifetime and
- ownership. When pybind11 knows the instance already (as identified by its
- type and address in memory), it will return the existing Python object
- wrapper rather than creating a new copy.
-
-.. note::
-
- The next section on :ref:`call_policies` discusses *call policies* that can be
- specified *in addition* to a return value policy from the list above. Call
- policies indicate reference relationships that can involve both return values
- and parameters of functions.
-
-.. note::
-
- As an alternative to elaborate call policies and lifetime management logic,
- consider using smart pointers (see the section on :ref:`smart_pointers` for
- details). Smart pointers can tell whether an object is still referenced from
- C++ or Python, which generally eliminates the kinds of inconsistencies that
- can lead to crashes or undefined behavior. For functions returning smart
- pointers, it is not necessary to specify a return value policy.
-
-.. _call_policies:
-
-Additional call policies
-========================
-
-In addition to the above return value policies, further *call policies* can be
-specified to indicate dependencies between parameters. In general, call policies
-are required when the C++ object is any kind of container and another object is being
-added to the container.
-
-There is currently just
-one policy named ``keep_alive<Nurse, Patient>``, which indicates that the
-argument with index ``Patient`` should be kept alive at least until the
-argument with index ``Nurse`` is freed by the garbage collector. Argument
-indices start at one, while zero refers to the return value. For methods, index
-``1`` refers to the implicit ``this`` pointer, while regular arguments begin at
-index ``2``. Arbitrarily many call policies can be specified. When a ``Nurse``
-with value ``None`` is detected at runtime, the call policy does nothing.
-
-This feature internally relies on the ability to create a *weak reference* to
-the nurse object, which is permitted by all classes exposed via pybind11. When
-the nurse object does not support weak references, an exception will be thrown.
-
-Consider the following example: here, the binding code for a list append
-operation ties the lifetime of the newly added element to the underlying
-container:
-
-.. code-block:: cpp
-
- py::class_<List>(m, "List")
- .def("append", &List::append, py::keep_alive<1, 2>());
-
-.. note::
-
- ``keep_alive`` is analogous to the ``with_custodian_and_ward`` (if Nurse,
- Patient != 0) and ``with_custodian_and_ward_postcall`` (if Nurse/Patient ==
- 0) policies from Boost.Python.
-
-.. seealso::
-
- The file :file:`tests/test_keep_alive.cpp` contains a complete example
- that demonstrates using :class:`keep_alive` in more detail.
-
-.. _python_objects_as_args:
-
-Python objects as arguments
-===========================
-
-pybind11 exposes all major Python types using thin C++ wrapper classes. These
-wrapper classes can also be used as parameters of functions in bindings, which
-makes it possible to directly work with native Python types on the C++ side.
-For instance, the following statement iterates over a Python ``dict``:
-
-.. code-block:: cpp
-
- void print_dict(py::dict dict) {
- /* Easily interact with Python types */
- for (auto item : dict)
- std::cout << "key=" << std::string(py::str(item.first)) << ", "
- << "value=" << std::string(py::str(item.second)) << std::endl;
- }
-
-It can be exported:
-
-.. code-block:: cpp
-
- m.def("print_dict", &print_dict);
-
-And used in Python as usual:
-
-.. code-block:: pycon
-
- >>> print_dict({'foo': 123, 'bar': 'hello'})
- key=foo, value=123
- key=bar, value=hello
-
-For more information on using Python objects in C++, see :doc:`/advanced/pycpp/index`.
-
-Accepting \*args and \*\*kwargs
-===============================
-
-Python provides a useful mechanism to define functions that accept arbitrary
-numbers of arguments and keyword arguments:
-
-.. code-block:: python
-
- def generic(*args, **kwargs):
- ... # do something with args and kwargs
-
-Such functions can also be created using pybind11:
-
-.. code-block:: cpp
-
- void generic(py::args args, py::kwargs kwargs) {
- /// .. do something with args
- if (kwargs)
- /// .. do something with kwargs
- }
-
- /// Binding code
- m.def("generic", &generic);
-
-The class ``py::args`` derives from ``py::tuple`` and ``py::kwargs`` derives
-from ``py::dict``.
-
-You may also use just one or the other, and may combine these with other
-arguments as long as the ``py::args`` and ``py::kwargs`` arguments are the last
-arguments accepted by the function.
-
-Please refer to the other examples for details on how to iterate over these,
-and on how to cast their entries into C++ objects. A demonstration is also
-available in ``tests/test_kwargs_and_defaults.cpp``.
-
-.. note::
-
- When combining \*args or \*\*kwargs with :ref:`keyword_args` you should
- *not* include ``py::arg`` tags for the ``py::args`` and ``py::kwargs``
- arguments.
-
-Default arguments revisited
-===========================
-
-The section on :ref:`default_args` previously discussed basic usage of default
-arguments using pybind11. One noteworthy aspect of their implementation is that
-default arguments are converted to Python objects right at declaration time.
-Consider the following example:
-
-.. code-block:: cpp
-
- py::class_<MyClass>("MyClass")
- .def("myFunction", py::arg("arg") = SomeType(123));
-
-In this case, pybind11 must already be set up to deal with values of the type
-``SomeType`` (via a prior instantiation of ``py::class_<SomeType>``), or an
-exception will be thrown.
-
-Another aspect worth highlighting is that the "preview" of the default argument
-in the function signature is generated using the object's ``__repr__`` method.
-If not available, the signature may not be very helpful, e.g.:
-
-.. code-block:: pycon
-
- FUNCTIONS
- ...
- | myFunction(...)
- | Signature : (MyClass, arg : SomeType = <SomeType object at 0x101b7b080>) -> NoneType
- ...
-
-The first way of addressing this is by defining ``SomeType.__repr__``.
-Alternatively, it is possible to specify the human-readable preview of the
-default argument manually using the ``arg_v`` notation:
-
-.. code-block:: cpp
-
- py::class_<MyClass>("MyClass")
- .def("myFunction", py::arg_v("arg", SomeType(123), "SomeType(123)"));
-
-Sometimes it may be necessary to pass a null pointer value as a default
-argument. In this case, remember to cast it to the underlying type in question,
-like so:
-
-.. code-block:: cpp
-
- py::class_<MyClass>("MyClass")
- .def("myFunction", py::arg("arg") = (SomeType *) nullptr);
-
-.. _nonconverting_arguments:
-
-Non-converting arguments
-========================
-
-Certain argument types may support conversion from one type to another. Some
-examples of conversions are:
-
-* :ref:`implicit_conversions` declared using ``py::implicitly_convertible<A,B>()``
-* Calling a method accepting a double with an integer argument
-* Calling a ``std::complex<float>`` argument with a non-complex python type
- (for example, with a float). (Requires the optional ``pybind11/complex.h``
- header).
-* Calling a function taking an Eigen matrix reference with a numpy array of the
- wrong type or of an incompatible data layout. (Requires the optional
- ``pybind11/eigen.h`` header).
-
-This behaviour is sometimes undesirable: the binding code may prefer to raise
-an error rather than convert the argument. This behaviour can be obtained
-through ``py::arg`` by calling the ``.noconvert()`` method of the ``py::arg``
-object, such as:
-
-.. code-block:: cpp
-
- m.def("floats_only", [](double f) { return 0.5 * f; }, py::arg("f").noconvert());
- m.def("floats_preferred", [](double f) { return 0.5 * f; }, py::arg("f"));
-
-Attempting the call the second function (the one without ``.noconvert()``) with
-an integer will succeed, but attempting to call the ``.noconvert()`` version
-will fail with a ``TypeError``:
-
-.. code-block:: pycon
-
- >>> floats_preferred(4)
- 2.0
- >>> floats_only(4)
- Traceback (most recent call last):
- File "<stdin>", line 1, in <module>
- TypeError: floats_only(): incompatible function arguments. The following argument types are supported:
- 1. (f: float) -> float
-
- Invoked with: 4
-
-You may, of course, combine this with the :var:`_a` shorthand notation (see
-:ref:`keyword_args`) and/or :ref:`default_args`. It is also permitted to omit
-the argument name by using the ``py::arg()`` constructor without an argument
-name, i.e. by specifying ``py::arg().noconvert()``.
-
-.. note::
-
- When specifying ``py::arg`` options it is necessary to provide the same
- number of options as the bound function has arguments. Thus if you want to
- enable no-convert behaviour for just one of several arguments, you will
- need to specify a ``py::arg()`` annotation for each argument with the
- no-convert argument modified to ``py::arg().noconvert()``.
-
-Overload resolution order
-=========================
-
-When a function or method with multiple overloads is called from Python,
-pybind11 determines which overload to call in two passes. The first pass
-attempts to call each overload without allowing argument conversion (as if
-every argument had been specified as ``py::arg().noconvert()`` as decribed
-above).
-
-If no overload succeeds in the no-conversion first pass, a second pass is
-attempted in which argument conversion is allowed (except where prohibited via
-an explicit ``py::arg().noconvert()`` attribute in the function definition).
-
-If the second pass also fails a ``TypeError`` is raised.
-
-Within each pass, overloads are tried in the order they were registered with
-pybind11.
-
-What this means in practice is that pybind11 will prefer any overload that does
-not require conversion of arguments to an overload that does, but otherwise prefers
-earlier-defined overloads to later-defined ones.
-
-.. note::
-
- pybind11 does *not* further prioritize based on the number/pattern of
- overloaded arguments. That is, pybind11 does not prioritize a function
- requiring one conversion over one requiring three, but only prioritizes
- overloads requiring no conversion at all to overloads that require
- conversion of at least one argument.
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/misc.rst b/thirdparty/pybind11/pybind11/docs/advanced/misc.rst
deleted file mode 100644
index d98466512b8d45e84692c1b1d396488d6cf1e5c4..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/misc.rst
+++ /dev/null
@@ -1,244 +0,0 @@
-Miscellaneous
-#############
-
-.. _macro_notes:
-
-General notes regarding convenience macros
-==========================================
-
-pybind11 provides a few convenience macros such as
-:func:`PYBIND11_MAKE_OPAQUE` and :func:`PYBIND11_DECLARE_HOLDER_TYPE`, and
-``PYBIND11_OVERLOAD_*``. Since these are "just" macros that are evaluated
-in the preprocessor (which has no concept of types), they *will* get confused
-by commas in a template argument such as ``PYBIND11_OVERLOAD(MyReturnValue<T1,
-T2>, myFunc)``. In this case, the preprocessor assumes that the comma indicates
-the beginning of the next parameter. Use a ``typedef`` to bind the template to
-another name and use it in the macro to avoid this problem.
-
-
-Global Interpreter Lock (GIL)
-=============================
-
-When calling a C++ function from Python, the GIL is always held.
-The classes :class:`gil_scoped_release` and :class:`gil_scoped_acquire` can be
-used to acquire and release the global interpreter lock in the body of a C++
-function call. In this way, long-running C++ code can be parallelized using
-multiple Python threads. Taking :ref:`overriding_virtuals` as an example, this
-could be realized as follows (important changes highlighted):
-
-.. code-block:: cpp
- :emphasize-lines: 8,9,33,34
-
- class PyAnimal : public Animal {
- public:
- /* Inherit the constructors */
- using Animal::Animal;
-
- /* Trampoline (need one for each virtual function) */
- std::string go(int n_times) {
- /* Acquire GIL before calling Python code */
- py::gil_scoped_acquire acquire;
-
- PYBIND11_OVERLOAD_PURE(
- std::string, /* Return type */
- Animal, /* Parent class */
- go, /* Name of function */
- n_times /* Argument(s) */
- );
- }
- };
-
- PYBIND11_PLUGIN(example) {
- py::module m("example", "pybind11 example plugin");
-
- py::class_<Animal, PyAnimal> animal(m, "Animal");
- animal
- .def(py::init<>())
- .def("go", &Animal::go);
-
- py::class_<Dog>(m, "Dog", animal)
- .def(py::init<>());
-
- m.def("call_go", [](Animal *animal) -> std::string {
- /* Release GIL before calling into (potentially long-running) C++ code */
- py::gil_scoped_release release;
- return call_go(animal);
- });
-
- return m.ptr();
- }
-
-
-Binding sequence data types, iterators, the slicing protocol, etc.
-==================================================================
-
-Please refer to the supplemental example for details.
-
-.. seealso::
-
- The file :file:`tests/test_sequences_and_iterators.cpp` contains a
- complete example that shows how to bind a sequence data type, including
- length queries (``__len__``), iterators (``__iter__``), the slicing
- protocol and other kinds of useful operations.
-
-
-Partitioning code over multiple extension modules
-=================================================
-
-It's straightforward to split binding code over multiple extension modules,
-while referencing types that are declared elsewhere. Everything "just" works
-without any special precautions. One exception to this rule occurs when
-extending a type declared in another extension module. Recall the basic example
-from Section :ref:`inheritance`.
-
-.. code-block:: cpp
-
- py::class_<Pet> pet(m, "Pet");
- pet.def(py::init<const std::string &>())
- .def_readwrite("name", &Pet::name);
-
- py::class_<Dog>(m, "Dog", pet /* <- specify parent */)
- .def(py::init<const std::string &>())
- .def("bark", &Dog::bark);
-
-Suppose now that ``Pet`` bindings are defined in a module named ``basic``,
-whereas the ``Dog`` bindings are defined somewhere else. The challenge is of
-course that the variable ``pet`` is not available anymore though it is needed
-to indicate the inheritance relationship to the constructor of ``class_<Dog>``.
-However, it can be acquired as follows:
-
-.. code-block:: cpp
-
- py::object pet = (py::object) py::module::import("basic").attr("Pet");
-
- py::class_<Dog>(m, "Dog", pet)
- .def(py::init<const std::string &>())
- .def("bark", &Dog::bark);
-
-Alternatively, you can specify the base class as a template parameter option to
-``class_``, which performs an automated lookup of the corresponding Python
-type. Like the above code, however, this also requires invoking the ``import``
-function once to ensure that the pybind11 binding code of the module ``basic``
-has been executed:
-
-.. code-block:: cpp
-
- py::module::import("basic");
-
- py::class_<Dog, Pet>(m, "Dog")
- .def(py::init<const std::string &>())
- .def("bark", &Dog::bark);
-
-Naturally, both methods will fail when there are cyclic dependencies.
-
-Note that compiling code which has its default symbol visibility set to
-*hidden* (e.g. via the command line flag ``-fvisibility=hidden`` on GCC/Clang) can interfere with the
-ability to access types defined in another extension module. Workarounds
-include changing the global symbol visibility (not recommended, because it will
-lead unnecessarily large binaries) or manually exporting types that are
-accessed by multiple extension modules:
-
-.. code-block:: cpp
-
- #ifdef _WIN32
- # define EXPORT_TYPE __declspec(dllexport)
- #else
- # define EXPORT_TYPE __attribute__ ((visibility("default")))
- #endif
-
- class EXPORT_TYPE Dog : public Animal {
- ...
- };
-
-Note also that it is possible (although would rarely be required) to share arbitrary
-C++ objects between extension modules at runtime. Internal library data is shared
-between modules using capsule machinery [#f6]_ which can be also utilized for
-storing, modifying and accessing user-defined data. Note that an extension module
-will "see" other extensions' data if and only if they were built with the same
-pybind11 version. Consider the following example:
-
-.. code-block:: cpp
-
- auto data = (MyData *) py::get_shared_data("mydata");
- if (!data)
- data = (MyData *) py::set_shared_data("mydata", new MyData(42));
-
-If the above snippet was used in several separately compiled extension modules,
-the first one to be imported would create a ``MyData`` instance and associate
-a ``"mydata"`` key with a pointer to it. Extensions that are imported later
-would be then able to access the data behind the same pointer.
-
-.. [#f6] https://docs.python.org/3/extending/extending.html#using-capsules
-
-Module Destructors
-==================
-
-pybind11 does not provide an explicit mechanism to invoke cleanup code at
-module destruction time. In rare cases where such functionality is required, it
-is possible to emulate it using Python capsules with a destruction callback.
-
-.. code-block:: cpp
-
- auto cleanup_callback = []() {
- // perform cleanup here -- this function is called with the GIL held
- };
-
- m.add_object("_cleanup", py::capsule(cleanup_callback));
-
-Generating documentation using Sphinx
-=====================================
-
-Sphinx [#f4]_ has the ability to inspect the signatures and documentation
-strings in pybind11-based extension modules to automatically generate beautiful
-documentation in a variety formats. The python_example repository [#f5]_ contains a
-simple example repository which uses this approach.
-
-There are two potential gotchas when using this approach: first, make sure that
-the resulting strings do not contain any :kbd:`TAB` characters, which break the
-docstring parsing routines. You may want to use C++11 raw string literals,
-which are convenient for multi-line comments. Conveniently, any excess
-indentation will be automatically be removed by Sphinx. However, for this to
-work, it is important that all lines are indented consistently, i.e.:
-
-.. code-block:: cpp
-
- // ok
- m.def("foo", &foo, R"mydelimiter(
- The foo function
-
- Parameters
- ----------
- )mydelimiter");
-
- // *not ok*
- m.def("foo", &foo, R"mydelimiter(The foo function
-
- Parameters
- ----------
- )mydelimiter");
-
-By default, pybind11 automatically generates and prepends a signature to the docstring of a function
-registered with ``module::def()`` and ``class_::def()``. Sometimes this
-behavior is not desirable, because you want to provide your own signature or remove
-the docstring completely to exclude the function from the Sphinx documentation.
-The class ``options`` allows you to selectively suppress auto-generated signatures:
-
-.. code-block:: cpp
-
- PYBIND11_PLUGIN(example) {
- py::module m("example", "pybind11 example plugin");
-
- py::options options;
- options.disable_function_signatures();
-
- m.def("add", [](int a, int b) { return a + b; }, "A function which adds two numbers");
-
- return m.ptr();
- }
-
-Note that changes to the settings affect only function bindings created during the
-lifetime of the ``options`` instance. When it goes out of scope at the end of the module's init function,
-the default settings are restored to prevent unwanted side effects.
-
-.. [#f4] http://www.sphinx-doc.org
-.. [#f5] http://github.com/pybind/python_example
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/pycpp/index.rst b/thirdparty/pybind11/pybind11/docs/advanced/pycpp/index.rst
deleted file mode 100644
index 6885bdcff1b56bbab5605873ccb1e0676864bb03..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/pycpp/index.rst
+++ /dev/null
@@ -1,13 +0,0 @@
-Python C++ interface
-####################
-
-pybind11 exposes Python types and functions using thin C++ wrappers, which
-makes it possible to conveniently call Python code from C++ without resorting
-to Python's C API.
-
-.. toctree::
- :maxdepth: 2
-
- object
- numpy
- utilities
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/pycpp/numpy.rst b/thirdparty/pybind11/pybind11/docs/advanced/pycpp/numpy.rst
deleted file mode 100644
index 6bcc46719d3519db26011411f46ebcaede1ceaaf..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/pycpp/numpy.rst
+++ /dev/null
@@ -1,379 +0,0 @@
-.. _numpy:
-
-NumPy
-#####
-
-Buffer protocol
-===============
-
-Python supports an extremely general and convenient approach for exchanging
-data between plugin libraries. Types can expose a buffer view [#f2]_, which
-provides fast direct access to the raw internal data representation. Suppose we
-want to bind the following simplistic Matrix class:
-
-.. code-block:: cpp
-
- class Matrix {
- public:
- Matrix(size_t rows, size_t cols) : m_rows(rows), m_cols(cols) {
- m_data = new float[rows*cols];
- }
- float *data() { return m_data; }
- size_t rows() const { return m_rows; }
- size_t cols() const { return m_cols; }
- private:
- size_t m_rows, m_cols;
- float *m_data;
- };
-
-The following binding code exposes the ``Matrix`` contents as a buffer object,
-making it possible to cast Matrices into NumPy arrays. It is even possible to
-completely avoid copy operations with Python expressions like
-``np.array(matrix_instance, copy = False)``.
-
-.. code-block:: cpp
-
- py::class_<Matrix>(m, "Matrix", py::buffer_protocol())
- .def_buffer([](Matrix &m) -> py::buffer_info {
- return py::buffer_info(
- m.data(), /* Pointer to buffer */
- sizeof(float), /* Size of one scalar */
- py::format_descriptor<float>::format(), /* Python struct-style format descriptor */
- 2, /* Number of dimensions */
- { m.rows(), m.cols() }, /* Buffer dimensions */
- { sizeof(float) * m.rows(), /* Strides (in bytes) for each index */
- sizeof(float) }
- );
- });
-
-Supporting the buffer protocol in a new type involves specifying the special
-``py::buffer_protocol()`` tag in the ``py::class_`` constructor and calling the
-``def_buffer()`` method with a lambda function that creates a
-``py::buffer_info`` description record on demand describing a given matrix
-instance. The contents of ``py::buffer_info`` mirror the Python buffer protocol
-specification.
-
-.. code-block:: cpp
-
- struct buffer_info {
- void *ptr;
- size_t itemsize;
- std::string format;
- int ndim;
- std::vector<size_t> shape;
- std::vector<size_t> strides;
- };
-
-To create a C++ function that can take a Python buffer object as an argument,
-simply use the type ``py::buffer`` as one of its arguments. Buffers can exist
-in a great variety of configurations, hence some safety checks are usually
-necessary in the function body. Below, you can see an basic example on how to
-define a custom constructor for the Eigen double precision matrix
-(``Eigen::MatrixXd``) type, which supports initialization from compatible
-buffer objects (e.g. a NumPy matrix).
-
-.. code-block:: cpp
-
- /* Bind MatrixXd (or some other Eigen type) to Python */
- typedef Eigen::MatrixXd Matrix;
-
- typedef Matrix::Scalar Scalar;
- constexpr bool rowMajor = Matrix::Flags & Eigen::RowMajorBit;
-
- py::class_<Matrix>(m, "Matrix", py::buffer_protocol())
- .def("__init__", [](Matrix &m, py::buffer b) {
- typedef Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic> Strides;
-
- /* Request a buffer descriptor from Python */
- py::buffer_info info = b.request();
-
- /* Some sanity checks ... */
- if (info.format != py::format_descriptor<Scalar>::format())
- throw std::runtime_error("Incompatible format: expected a double array!");
-
- if (info.ndim != 2)
- throw std::runtime_error("Incompatible buffer dimension!");
-
- auto strides = Strides(
- info.strides[rowMajor ? 0 : 1] / sizeof(Scalar),
- info.strides[rowMajor ? 1 : 0] / sizeof(Scalar));
-
- auto map = Eigen::Map<Matrix, 0, Strides>(
- static_cat<Scalar *>(info.ptr), info.shape[0], info.shape[1], strides);
-
- new (&m) Matrix(map);
- });
-
-For reference, the ``def_buffer()`` call for this Eigen data type should look
-as follows:
-
-.. code-block:: cpp
-
- .def_buffer([](Matrix &m) -> py::buffer_info {
- return py::buffer_info(
- m.data(), /* Pointer to buffer */
- sizeof(Scalar), /* Size of one scalar */
- /* Python struct-style format descriptor */
- py::format_descriptor<Scalar>::format(),
- /* Number of dimensions */
- 2,
- /* Buffer dimensions */
- { (size_t) m.rows(),
- (size_t) m.cols() },
- /* Strides (in bytes) for each index */
- { sizeof(Scalar) * (rowMajor ? m.cols() : 1),
- sizeof(Scalar) * (rowMajor ? 1 : m.rows()) }
- );
- })
-
-For a much easier approach of binding Eigen types (although with some
-limitations), refer to the section on :doc:`/advanced/cast/eigen`.
-
-.. seealso::
-
- The file :file:`tests/test_buffers.cpp` contains a complete example
- that demonstrates using the buffer protocol with pybind11 in more detail.
-
-.. [#f2] http://docs.python.org/3/c-api/buffer.html
-
-Arrays
-======
-
-By exchanging ``py::buffer`` with ``py::array`` in the above snippet, we can
-restrict the function so that it only accepts NumPy arrays (rather than any
-type of Python object satisfying the buffer protocol).
-
-In many situations, we want to define a function which only accepts a NumPy
-array of a certain data type. This is possible via the ``py::array_t<T>``
-template. For instance, the following function requires the argument to be a
-NumPy array containing double precision values.
-
-.. code-block:: cpp
-
- void f(py::array_t<double> array);
-
-When it is invoked with a different type (e.g. an integer or a list of
-integers), the binding code will attempt to cast the input into a NumPy array
-of the requested type. Note that this feature requires the
-:file:`pybind11/numpy.h` header to be included.
-
-Data in NumPy arrays is not guaranteed to packed in a dense manner;
-furthermore, entries can be separated by arbitrary column and row strides.
-Sometimes, it can be useful to require a function to only accept dense arrays
-using either the C (row-major) or Fortran (column-major) ordering. This can be
-accomplished via a second template argument with values ``py::array::c_style``
-or ``py::array::f_style``.
-
-.. code-block:: cpp
-
- void f(py::array_t<double, py::array::c_style | py::array::forcecast> array);
-
-The ``py::array::forcecast`` argument is the default value of the second
-template parameter, and it ensures that non-conforming arguments are converted
-into an array satisfying the specified requirements instead of trying the next
-function overload.
-
-Structured types
-================
-
-In order for ``py::array_t`` to work with structured (record) types, we first
-need to register the memory layout of the type. This can be done via
-``PYBIND11_NUMPY_DTYPE`` macro, called in the plugin definition code, which
-expects the type followed by field names:
-
-.. code-block:: cpp
-
- struct A {
- int x;
- double y;
- };
-
- struct B {
- int z;
- A a;
- };
-
- // ...
- PYBIND11_PLUGIN(test) {
- // ...
-
- PYBIND11_NUMPY_DTYPE(A, x, y);
- PYBIND11_NUMPY_DTYPE(B, z, a);
- /* now both A and B can be used as template arguments to py::array_t */
- }
-
-Vectorizing functions
-=====================
-
-Suppose we want to bind a function with the following signature to Python so
-that it can process arbitrary NumPy array arguments (vectors, matrices, general
-N-D arrays) in addition to its normal arguments:
-
-.. code-block:: cpp
-
- double my_func(int x, float y, double z);
-
-After including the ``pybind11/numpy.h`` header, this is extremely simple:
-
-.. code-block:: cpp
-
- m.def("vectorized_func", py::vectorize(my_func));
-
-Invoking the function like below causes 4 calls to be made to ``my_func`` with
-each of the array elements. The significant advantage of this compared to
-solutions like ``numpy.vectorize()`` is that the loop over the elements runs
-entirely on the C++ side and can be crunched down into a tight, optimized loop
-by the compiler. The result is returned as a NumPy array of type
-``numpy.dtype.float64``.
-
-.. code-block:: pycon
-
- >>> x = np.array([[1, 3],[5, 7]])
- >>> y = np.array([[2, 4],[6, 8]])
- >>> z = 3
- >>> result = vectorized_func(x, y, z)
-
-The scalar argument ``z`` is transparently replicated 4 times. The input
-arrays ``x`` and ``y`` are automatically converted into the right types (they
-are of type ``numpy.dtype.int64`` but need to be ``numpy.dtype.int32`` and
-``numpy.dtype.float32``, respectively)
-
-Sometimes we might want to explicitly exclude an argument from the vectorization
-because it makes little sense to wrap it in a NumPy array. For instance,
-suppose the function signature was
-
-.. code-block:: cpp
-
- double my_func(int x, float y, my_custom_type *z);
-
-This can be done with a stateful Lambda closure:
-
-.. code-block:: cpp
-
- // Vectorize a lambda function with a capture object (e.g. to exclude some arguments from the vectorization)
- m.def("vectorized_func",
- [](py::array_t<int> x, py::array_t<float> y, my_custom_type *z) {
- auto stateful_closure = [z](int x, float y) { return my_func(x, y, z); };
- return py::vectorize(stateful_closure)(x, y);
- }
- );
-
-In cases where the computation is too complicated to be reduced to
-``vectorize``, it will be necessary to create and access the buffer contents
-manually. The following snippet contains a complete example that shows how this
-works (the code is somewhat contrived, since it could have been done more
-simply using ``vectorize``).
-
-.. code-block:: cpp
-
- #include <pybind11/pybind11.h>
- #include <pybind11/numpy.h>
-
- namespace py = pybind11;
-
- py::array_t<double> add_arrays(py::array_t<double> input1, py::array_t<double> input2) {
- auto buf1 = input1.request(), buf2 = input2.request();
-
- if (buf1.ndim != 1 || buf2.ndim != 1)
- throw std::runtime_error("Number of dimensions must be one");
-
- if (buf1.size != buf2.size)
- throw std::runtime_error("Input shapes must match");
-
- /* No pointer is passed, so NumPy will allocate the buffer */
- auto result = py::array_t<double>(buf1.size);
-
- auto buf3 = result.request();
-
- double *ptr1 = (double *) buf1.ptr,
- *ptr2 = (double *) buf2.ptr,
- *ptr3 = (double *) buf3.ptr;
-
- for (size_t idx = 0; idx < buf1.shape[0]; idx++)
- ptr3[idx] = ptr1[idx] + ptr2[idx];
-
- return result;
- }
-
- PYBIND11_PLUGIN(test) {
- py::module m("test");
- m.def("add_arrays", &add_arrays, "Add two NumPy arrays");
- return m.ptr();
- }
-
-.. seealso::
-
- The file :file:`tests/test_numpy_vectorize.cpp` contains a complete
- example that demonstrates using :func:`vectorize` in more detail.
-
-Direct access
-=============
-
-For performance reasons, particularly when dealing with very large arrays, it
-is often desirable to directly access array elements without internal checking
-of dimensions and bounds on every access when indices are known to be already
-valid. To avoid such checks, the ``array`` class and ``array_t<T>`` template
-class offer an unchecked proxy object that can be used for this unchecked
-access through the ``unchecked<N>`` and ``mutable_unchecked<N>`` methods,
-where ``N`` gives the required dimensionality of the array:
-
-.. code-block:: cpp
-
- m.def("sum_3d", [](py::array_t<double> x) {
- auto r = x.unchecked<3>(); // x must have ndim = 3; can be non-writeable
- double sum = 0;
- for (size_t i = 0; i < r.shape(0); i++)
- for (size_t j = 0; j < r.shape(1); j++)
- for (size_t k = 0; k < r.shape(2); k++)
- sum += r(i, j, k);
- return sum;
- });
- m.def("increment_3d", [](py::array_t<double> x) {
- auto r = x.mutable_unchecked<3>(); // Will throw if ndim != 3 or flags.writeable is false
- for (size_t i = 0; i < r.shape(0); i++)
- for (size_t j = 0; j < r.shape(1); j++)
- for (size_t k = 0; k < r.shape(2); k++)
- r(i, j, k) += 1.0;
- }, py::arg().noconvert());
-
-To obtain the proxy from an ``array`` object, you must specify both the data
-type and number of dimensions as template arguments, such as ``auto r =
-myarray.mutable_unchecked<float, 2>()``.
-
-If the number of dimensions is not known at compile time, you can omit the
-dimensions template parameter (i.e. calling ``arr_t.unchecked()`` or
-``arr.unchecked<T>()``. This will give you a proxy object that works in the
-same way, but results in less optimizable code and thus a small efficiency
-loss in tight loops.
-
-Note that the returned proxy object directly references the array's data, and
-only reads its shape, strides, and writeable flag when constructed. You must
-take care to ensure that the referenced array is not destroyed or reshaped for
-the duration of the returned object, typically by limiting the scope of the
-returned instance.
-
-The returned proxy object supports some of the same methods as ``py::array`` so
-that it can be used as a drop-in replacement for some existing, index-checked
-uses of ``py::array``:
-
-- ``r.ndim()`` returns the number of dimensions
-
-- ``r.data(1, 2, ...)`` and ``r.mutable_data(1, 2, ...)``` returns a pointer to
- the ``const T`` or ``T`` data, respectively, at the given indices. The
- latter is only available to proxies obtained via ``a.mutable_unchecked()``.
-
-- ``itemsize()`` returns the size of an item in bytes, i.e. ``sizeof(T)``.
-
-- ``ndim()`` returns the number of dimensions.
-
-- ``shape(n)`` returns the size of dimension ``n``
-
-- ``size()`` returns the total number of elements (i.e. the product of the shapes).
-
-- ``nbytes()`` returns the number of bytes used by the referenced elements
- (i.e. ``itemsize()`` times ``size()``).
-
-.. seealso::
-
- The file :file:`tests/test_numpy_array.cpp` contains additional examples
- demonstrating the use of this feature.
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/pycpp/object.rst b/thirdparty/pybind11/pybind11/docs/advanced/pycpp/object.rst
deleted file mode 100644
index ae58876de594bea5b90695c97c8e4d66a0da8b7d..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/pycpp/object.rst
+++ /dev/null
@@ -1,98 +0,0 @@
-Python types
-############
-
-Available wrappers
-==================
-
-All major Python types are available as thin C++ wrapper classes. These
-can also be used as function parameters -- see :ref:`python_objects_as_args`.
-
-Available types include :class:`handle`, :class:`object`, :class:`bool_`,
-:class:`int_`, :class:`float_`, :class:`str`, :class:`bytes`, :class:`tuple`,
-:class:`list`, :class:`dict`, :class:`slice`, :class:`none`, :class:`capsule`,
-:class:`iterable`, :class:`iterator`, :class:`function`, :class:`buffer`,
-:class:`array`, and :class:`array_t`.
-
-Casting back and forth
-======================
-
-In this kind of mixed code, it is often necessary to convert arbitrary C++
-types to Python, which can be done using :func:`py::cast`:
-
-.. code-block:: cpp
-
- MyClass *cls = ..;
- py::object obj = py::cast(cls);
-
-The reverse direction uses the following syntax:
-
-.. code-block:: cpp
-
- py::object obj = ...;
- MyClass *cls = obj.cast<MyClass *>();
-
-When conversion fails, both directions throw the exception :class:`cast_error`.
-
-.. _calling_python_functions:
-
-Calling Python functions
-========================
-
-It is also possible to call python functions via ``operator()``.
-
-.. code-block:: cpp
-
- py::function f = <...>;
- py::object result_py = f(1234, "hello", some_instance);
- MyClass &result = result_py.cast<MyClass>();
-
-Keyword arguments are also supported. In Python, there is the usual call syntax:
-
-.. code-block:: python
-
- def f(number, say, to):
- ... # function code
-
- f(1234, say="hello", to=some_instance) # keyword call in Python
-
-In C++, the same call can be made using:
-
-.. code-block:: cpp
-
- using namespace pybind11::literals; // to bring in the `_a` literal
- f(1234, "say"_a="hello", "to"_a=some_instance); // keyword call in C++
-
-Unpacking of ``*args`` and ``**kwargs`` is also possible and can be mixed with
-other arguments:
-
-.. code-block:: cpp
-
- // * unpacking
- py::tuple args = py::make_tuple(1234, "hello", some_instance);
- f(*args);
-
- // ** unpacking
- py::dict kwargs = py::dict("number"_a=1234, "say"_a="hello", "to"_a=some_instance);
- f(**kwargs);
-
- // mixed keywords, * and ** unpacking
- py::tuple args = py::make_tuple(1234);
- py::dict kwargs = py::dict("to"_a=some_instance);
- f(*args, "say"_a="hello", **kwargs);
-
-Generalized unpacking according to PEP448_ is also supported:
-
-.. code-block:: cpp
-
- py::dict kwargs1 = py::dict("number"_a=1234);
- py::dict kwargs2 = py::dict("to"_a=some_instance);
- f(**kwargs1, "say"_a="hello", **kwargs2);
-
-.. seealso::
-
- The file :file:`tests/test_python_types.cpp` contains a complete
- example that demonstrates passing native Python types in more detail. The
- file :file:`tests/test_callbacks.cpp` presents a few examples of calling
- Python functions from C++, including keywords arguments and unpacking.
-
-.. _PEP448: https://www.python.org/dev/peps/pep-0448/
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/pycpp/utilities.rst b/thirdparty/pybind11/pybind11/docs/advanced/pycpp/utilities.rst
deleted file mode 100644
index ba0dbef88cf89db361f82021afc3d05bb51cf6a5..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/pycpp/utilities.rst
+++ /dev/null
@@ -1,57 +0,0 @@
-Utilities
-#########
-
-Using Python's print function in C++
-====================================
-
-The usual way to write output in C++ is using ``std::cout`` while in Python one
-would use ``print``. Since these methods use different buffers, mixing them can
-lead to output order issues. To resolve this, pybind11 modules can use the
-:func:`py::print` function which writes to Python's ``sys.stdout`` for consistency.
-
-Python's ``print`` function is replicated in the C++ API including optional
-keyword arguments ``sep``, ``end``, ``file``, ``flush``. Everything works as
-expected in Python:
-
-.. code-block:: cpp
-
- py::print(1, 2.0, "three"); // 1 2.0 three
- py::print(1, 2.0, "three", "sep"_a="-"); // 1-2.0-three
-
- auto args = py::make_tuple("unpacked", true);
- py::print("->", *args, "end"_a="<-"); // -> unpacked True <-
-
-Evaluating Python expressions from strings and files
-====================================================
-
-pybind11 provides the :func:`eval` and :func:`eval_file` functions to evaluate
-Python expressions and statements. The following example illustrates how they
-can be used.
-
-Both functions accept a template parameter that describes how the argument
-should be interpreted. Possible choices include ``eval_expr`` (isolated
-expression), ``eval_single_statement`` (a single statement, return value is
-always ``none``), and ``eval_statements`` (sequence of statements, return value
-is always ``none``).
-
-.. code-block:: cpp
-
- // At beginning of file
- #include <pybind11/eval.h>
-
- ...
-
- // Evaluate in scope of main module
- py::object scope = py::module::import("__main__").attr("__dict__");
-
- // Evaluate an isolated expression
- int result = py::eval("my_variable + 10", scope).cast<int>();
-
- // Evaluate a sequence of statements
- py::eval<py::eval_statements>(
- "print('Hello')\n"
- "print('world!');",
- scope);
-
- // Evaluate the statements in an separate Python file on disk
- py::eval_file("script.py", scope);
diff --git a/thirdparty/pybind11/pybind11/docs/advanced/smart_ptrs.rst b/thirdparty/pybind11/pybind11/docs/advanced/smart_ptrs.rst
deleted file mode 100644
index e4a238603ee9f3d2f262ab800a4dec0f40b01e8d..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/advanced/smart_ptrs.rst
+++ /dev/null
@@ -1,177 +0,0 @@
-Smart pointers
-##############
-
-std::unique_ptr
-===============
-
-Given a class ``Example`` with Python bindings, it's possible to return
-instances wrapped in C++11 unique pointers, like so
-
-.. code-block:: cpp
-
- std::unique_ptr<Example> create_example() { return std::unique_ptr<Example>(new Example()); }
-
-.. code-block:: cpp
-
- m.def("create_example", &create_example);
-
-In other words, there is nothing special that needs to be done. While returning
-unique pointers in this way is allowed, it is *illegal* to use them as function
-arguments. For instance, the following function signature cannot be processed
-by pybind11.
-
-.. code-block:: cpp
-
- void do_something_with_example(std::unique_ptr<Example> ex) { ... }
-
-The above signature would imply that Python needs to give up ownership of an
-object that is passed to this function, which is generally not possible (for
-instance, the object might be referenced elsewhere).
-
-std::shared_ptr
-===============
-
-The binding generator for classes, :class:`class_`, can be passed a template
-type that denotes a special *holder* type that is used to manage references to
-the object. If no such holder type template argument is given, the default for
-a type named ``Type`` is ``std::unique_ptr<Type>``, which means that the object
-is deallocated when Python's reference count goes to zero.
-
-It is possible to switch to other types of reference counting wrappers or smart
-pointers, which is useful in codebases that rely on them. For instance, the
-following snippet causes ``std::shared_ptr`` to be used instead.
-
-.. code-block:: cpp
-
- py::class_<Example, std::shared_ptr<Example> /* <- holder type */> obj(m, "Example");
-
-Note that any particular class can only be associated with a single holder type.
-
-One potential stumbling block when using holder types is that they need to be
-applied consistently. Can you guess what's broken about the following binding
-code?
-
-.. code-block:: cpp
-
- class Child { };
-
- class Parent {
- public:
- Parent() : child(std::make_shared<Child>()) { }
- Child *get_child() { return child.get(); } /* Hint: ** DON'T DO THIS ** */
- private:
- std::shared_ptr<Child> child;
- };
-
- PYBIND11_PLUGIN(example) {
- py::module m("example");
-
- py::class_<Child, std::shared_ptr<Child>>(m, "Child");
-
- py::class_<Parent, std::shared_ptr<Parent>>(m, "Parent")
- .def(py::init<>())
- .def("get_child", &Parent::get_child);
-
- return m.ptr();
- }
-
-The following Python code will cause undefined behavior (and likely a
-segmentation fault).
-
-.. code-block:: python
-
- from example import Parent
- print(Parent().get_child())
-
-The problem is that ``Parent::get_child()`` returns a pointer to an instance of
-``Child``, but the fact that this instance is already managed by
-``std::shared_ptr<...>`` is lost when passing raw pointers. In this case,
-pybind11 will create a second independent ``std::shared_ptr<...>`` that also
-claims ownership of the pointer. In the end, the object will be freed **twice**
-since these shared pointers have no way of knowing about each other.
-
-There are two ways to resolve this issue:
-
-1. For types that are managed by a smart pointer class, never use raw pointers
- in function arguments or return values. In other words: always consistently
- wrap pointers into their designated holder types (such as
- ``std::shared_ptr<...>``). In this case, the signature of ``get_child()``
- should be modified as follows:
-
-.. code-block:: cpp
-
- std::shared_ptr<Child> get_child() { return child; }
-
-2. Adjust the definition of ``Child`` by specifying
- ``std::enable_shared_from_this<T>`` (see cppreference_ for details) as a
- base class. This adds a small bit of information to ``Child`` that allows
- pybind11 to realize that there is already an existing
- ``std::shared_ptr<...>`` and communicate with it. In this case, the
- declaration of ``Child`` should look as follows:
-
-.. _cppreference: http://en.cppreference.com/w/cpp/memory/enable_shared_from_this
-
-.. code-block:: cpp
-
- class Child : public std::enable_shared_from_this<Child> { };
-
-.. _smart_pointers:
-
-Custom smart pointers
-=====================
-
-pybind11 supports ``std::unique_ptr`` and ``std::shared_ptr`` right out of the
-box. For any other custom smart pointer, transparent conversions can be enabled
-using a macro invocation similar to the following. It must be declared at the
-top namespace level before any binding code:
-
-.. code-block:: cpp
-
- PYBIND11_DECLARE_HOLDER_TYPE(T, SmartPtr<T>);
-
-The first argument of :func:`PYBIND11_DECLARE_HOLDER_TYPE` should be a
-placeholder name that is used as a template parameter of the second argument.
-Thus, feel free to use any identifier, but use it consistently on both sides;
-also, don't use the name of a type that already exists in your codebase.
-
-The macro also accepts a third optional boolean parameter that is set to false
-by default. Specify
-
-.. code-block:: cpp
-
- PYBIND11_DECLARE_HOLDER_TYPE(T, SmartPtr<T>, true);
-
-if ``SmartPtr<T>`` can always be initialized from a ``T*`` pointer without the
-risk of inconsistencies (such as multiple independent ``SmartPtr`` instances
-believing that they are the sole owner of the ``T*`` pointer). A common
-situation where ``true`` should be passed is when the ``T`` instances use
-*intrusive* reference counting.
-
-Please take a look at the :ref:`macro_notes` before using this feature.
-
-By default, pybind11 assumes that your custom smart pointer has a standard
-interface, i.e. provides a ``.get()`` member function to access the underlying
-raw pointer. If this is not the case, pybind11's ``holder_helper`` must be
-specialized:
-
-.. code-block:: cpp
-
- // Always needed for custom holder types
- PYBIND11_DECLARE_HOLDER_TYPE(T, SmartPtr<T>);
-
- // Only needed if the type's `.get()` goes by another name
- namespace pybind11 { namespace detail {
- template <typename T>
- struct holder_helper<SmartPtr<T>> { // <-- specialization
- static const T *get(const SmartPtr<T> &p) { return p.getPointer(); }
- };
- }}
-
-The above specialization informs pybind11 that the custom ``SmartPtr`` class
-provides ``.get()`` functionality via ``.getPointer()``.
-
-.. seealso::
-
- The file :file:`tests/test_smart_ptr.cpp` contains a complete example
- that demonstrates how to work with custom reference-counting holder types
- in more detail.
diff --git a/thirdparty/pybind11/pybind11/docs/basics.rst b/thirdparty/pybind11/pybind11/docs/basics.rst
deleted file mode 100644
index 33c60049df64e1c0ef84e93a4beed0d5e8717782..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/basics.rst
+++ /dev/null
@@ -1,289 +0,0 @@
-.. _basics:
-
-First steps
-###########
-
-This sections demonstrates the basic features of pybind11. Before getting
-started, make sure that development environment is set up to compile the
-included set of test cases.
-
-
-Compiling the test cases
-========================
-
-Linux/MacOS
------------
-
-On Linux you'll need to install the **python-dev** or **python3-dev** packages as
-well as **cmake**. On Mac OS, the included python version works out of the box,
-but **cmake** must still be installed.
-
-After installing the prerequisites, run
-
-.. code-block:: bash
-
- mkdir build
- cd build
- cmake ..
- make check -j 4
-
-The last line will both compile and run the tests.
-
-Windows
--------
-
-On Windows, only **Visual Studio 2015** and newer are supported since pybind11 relies
-on various C++11 language features that break older versions of Visual Studio.
-
-To compile and run the tests:
-
-.. code-block:: batch
-
- mkdir build
- cd build
- cmake ..
- cmake --build . --config Release --target check
-
-This will create a Visual Studio project, compile and run the target, all from the
-command line.
-
-.. Note::
-
- If all tests fail, make sure that the Python binary and the testcases are compiled
- for the same processor type and bitness (i.e. either **i386** or **x86_64**). You
- can specify **x86_64** as the target architecture for the generated Visual Studio
- project using ``cmake -A x64 ..``.
-
-.. seealso::
-
- Advanced users who are already familiar with Boost.Python may want to skip
- the tutorial and look at the test cases in the :file:`tests` directory,
- which exercise all features of pybind11.
-
-Header and namespace conventions
-================================
-
-For brevity, all code examples assume that the following two lines are present:
-
-.. code-block:: cpp
-
- #include <pybind11/pybind11.h>
-
- namespace py = pybind11;
-
-Some features may require additional headers, but those will be specified as needed.
-
-Creating bindings for a simple function
-=======================================
-
-Let's start by creating Python bindings for an extremely simple function, which
-adds two numbers and returns their result:
-
-.. code-block:: cpp
-
- int add(int i, int j) {
- return i + j;
- }
-
-For simplicity [#f1]_, we'll put both this function and the binding code into
-a file named :file:`example.cpp` with the following contents:
-
-.. code-block:: cpp
-
- #include <pybind11/pybind11.h>
-
- int add(int i, int j) {
- return i + j;
- }
-
- namespace py = pybind11;
-
- PYBIND11_PLUGIN(example) {
- py::module m("example", "pybind11 example plugin");
-
- m.def("add", &add, "A function which adds two numbers");
-
- return m.ptr();
- }
-
-.. [#f1] In practice, implementation and binding code will generally be located
- in separate files.
-
-The :func:`PYBIND11_PLUGIN` macro creates a function that will be called when an
-``import`` statement is issued from within Python. The next line creates a
-module named ``example`` (with the supplied docstring). The method
-:func:`module::def` generates binding code that exposes the
-``add()`` function to Python. The last line returns the internal Python object
-associated with ``m`` to the Python interpreter.
-
-.. note::
-
- Notice how little code was needed to expose our function to Python: all
- details regarding the function's parameters and return value were
- automatically inferred using template metaprogramming. This overall
- approach and the used syntax are borrowed from Boost.Python, though the
- underlying implementation is very different.
-
-pybind11 is a header-only-library, hence it is not necessary to link against
-any special libraries (other than Python itself). On Windows, use the CMake
-build file discussed in section :ref:`cmake`. On Linux and Mac OS, the above
-example can be compiled using the following command
-
-.. code-block:: bash
-
- $ c++ -O3 -shared -std=c++11 -I <path-to-pybind11>/include `python-config --cflags --ldflags` example.cpp -o example.so
-
-In general, it is advisable to include several additional build parameters
-that can considerably reduce the size of the created binary. Refer to section
-:ref:`cmake` for a detailed example of a suitable cross-platform CMake-based
-build system.
-
-Assuming that the created file :file:`example.so` (:file:`example.pyd` on Windows)
-is located in the current directory, the following interactive Python session
-shows how to load and execute the example.
-
-.. code-block:: pycon
-
- $ python
- Python 2.7.10 (default, Aug 22 2015, 20:33:39)
- [GCC 4.2.1 Compatible Apple LLVM 7.0.0 (clang-700.0.59.1)] on darwin
- Type "help", "copyright", "credits" or "license" for more information.
- >>> import example
- >>> example.add(1, 2)
- 3L
- >>>
-
-.. _keyword_args:
-
-Keyword arguments
-=================
-
-With a simple modification code, it is possible to inform Python about the
-names of the arguments ("i" and "j" in this case).
-
-.. code-block:: cpp
-
- m.def("add", &add, "A function which adds two numbers",
- py::arg("i"), py::arg("j"));
-
-:class:`arg` is one of several special tag classes which can be used to pass
-metadata into :func:`module::def`. With this modified binding code, we can now
-call the function using keyword arguments, which is a more readable alternative
-particularly for functions taking many parameters:
-
-.. code-block:: pycon
-
- >>> import example
- >>> example.add(i=1, j=2)
- 3L
-
-The keyword names also appear in the function signatures within the documentation.
-
-.. code-block:: pycon
-
- >>> help(example)
-
- ....
-
- FUNCTIONS
- add(...)
- Signature : (i: int, j: int) -> int
-
- A function which adds two numbers
-
-A shorter notation for named arguments is also available:
-
-.. code-block:: cpp
-
- // regular notation
- m.def("add1", &add, py::arg("i"), py::arg("j"));
- // shorthand
- using namespace pybind11::literals;
- m.def("add2", &add, "i"_a, "j"_a);
-
-The :var:`_a` suffix forms a C++11 literal which is equivalent to :class:`arg`.
-Note that the literal operator must first be made visible with the directive
-``using namespace pybind11::literals``. This does not bring in anything else
-from the ``pybind11`` namespace except for literals.
-
-.. _default_args:
-
-Default arguments
-=================
-
-Suppose now that the function to be bound has default arguments, e.g.:
-
-.. code-block:: cpp
-
- int add(int i = 1, int j = 2) {
- return i + j;
- }
-
-Unfortunately, pybind11 cannot automatically extract these parameters, since they
-are not part of the function's type information. However, they are simple to specify
-using an extension of :class:`arg`:
-
-.. code-block:: cpp
-
- m.def("add", &add, "A function which adds two numbers",
- py::arg("i") = 1, py::arg("j") = 2);
-
-The default values also appear within the documentation.
-
-.. code-block:: pycon
-
- >>> help(example)
-
- ....
-
- FUNCTIONS
- add(...)
- Signature : (i: int = 1, j: int = 2) -> int
-
- A function which adds two numbers
-
-The shorthand notation is also available for default arguments:
-
-.. code-block:: cpp
-
- // regular notation
- m.def("add1", &add, py::arg("i") = 1, py::arg("j") = 2);
- // shorthand
- m.def("add2", &add, "i"_a=1, "j"_a=2);
-
-Exporting variables
-===================
-
-To expose a value from C++, use the ``attr`` function to register it in a
-module as shown below. Built-in types and general objects (more on that later)
-are automatically converted when assigned as attributes, and can be explicitly
-converted using the function ``py::cast``.
-
-.. code-block:: cpp
-
- PYBIND11_PLUGIN(example) {
- py::module m("example", "pybind11 example plugin");
- m.attr("the_answer") = 42;
- py::object world = py::cast("World");
- m.attr("what") = world;
- return m.ptr();
- }
-
-These are then accessible from Python:
-
-.. code-block:: pycon
-
- >>> import example
- >>> example.the_answer
- 42
- >>> example.what
- 'World'
-
-.. _supported_types:
-
-Supported data types
-====================
-
-A large number of data types are supported out of the box and can be used
-seamlessly as functions arguments, return values or with ``py::cast`` in general.
-For a full overview, see the :doc:`advanced/cast/index` section.
diff --git a/thirdparty/pybind11/pybind11/docs/benchmark.py b/thirdparty/pybind11/pybind11/docs/benchmark.py
deleted file mode 100644
index 6f02e92ffc6e82f7b23596004efb306da61bd428..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/benchmark.py
+++ /dev/null
@@ -1,90 +0,0 @@
-import random
-import os
-import time
-import datetime as dt
-
-nfns = 4 # Functions per class
-nargs = 4 # Arguments per function
-
-
-def generate_dummy_code_pybind11(nclasses=10):
- decl = ""
- bindings = ""
-
- for cl in range(nclasses):
- decl += "class cl%03i;\n" % cl
- decl += '\n'
-
- for cl in range(nclasses):
- decl += "class cl%03i {\n" % cl
- decl += "public:\n"
- bindings += ' py::class_<cl%03i>(m, "cl%03i")\n' % (cl, cl)
- for fn in range(nfns):
- ret = random.randint(0, nclasses - 1)
- params = [random.randint(0, nclasses - 1) for i in range(nargs)]
- decl += " cl%03i *fn_%03i(" % (ret, fn)
- decl += ", ".join("cl%03i *" % p for p in params)
- decl += ");\n"
- bindings += ' .def("fn_%03i", &cl%03i::fn_%03i)\n' % \
- (fn, cl, fn)
- decl += "};\n\n"
- bindings += ' ;\n'
-
- result = "#include <pybind11/pybind11.h>\n\n"
- result += "namespace py = pybind11;\n\n"
- result += decl + '\n'
- result += "PYBIND11_PLUGIN(example) {\n"
- result += " py::module m(\"example\");"
- result += bindings
- result += " return m.ptr();"
- result += "}"
- return result
-
-
-def generate_dummy_code_boost(nclasses=10):
- decl = ""
- bindings = ""
-
- for cl in range(nclasses):
- decl += "class cl%03i;\n" % cl
- decl += '\n'
-
- for cl in range(nclasses):
- decl += "class cl%03i {\n" % cl
- decl += "public:\n"
- bindings += ' py::class_<cl%03i>("cl%03i")\n' % (cl, cl)
- for fn in range(nfns):
- ret = random.randint(0, nclasses - 1)
- params = [random.randint(0, nclasses - 1) for i in range(nargs)]
- decl += " cl%03i *fn_%03i(" % (ret, fn)
- decl += ", ".join("cl%03i *" % p for p in params)
- decl += ");\n"
- bindings += ' .def("fn_%03i", &cl%03i::fn_%03i, py::return_value_policy<py::manage_new_object>())\n' % \
- (fn, cl, fn)
- decl += "};\n\n"
- bindings += ' ;\n'
-
- result = "#include <boost/python.hpp>\n\n"
- result += "namespace py = boost::python;\n\n"
- result += decl + '\n'
- result += "BOOST_PYTHON_MODULE(example) {\n"
- result += bindings
- result += "}"
- return result
-
-
-for codegen in [generate_dummy_code_pybind11, generate_dummy_code_boost]:
- print ("{")
- for i in range(0, 10):
- nclasses = 2 ** i
- with open("test.cpp", "w") as f:
- f.write(codegen(nclasses))
- n1 = dt.datetime.now()
- os.system("g++ -Os -shared -rdynamic -undefined dynamic_lookup "
- "-fvisibility=hidden -std=c++14 test.cpp -I include "
- "-I /System/Library/Frameworks/Python.framework/Headers -o test.so")
- n2 = dt.datetime.now()
- elapsed = (n2 - n1).total_seconds()
- size = os.stat('test.so').st_size
- print(" {%i, %f, %i}," % (nclasses * nfns, elapsed, size))
- print ("}")
diff --git a/thirdparty/pybind11/pybind11/docs/benchmark.rst b/thirdparty/pybind11/pybind11/docs/benchmark.rst
deleted file mode 100644
index 8babaa319cfdbcd049fc717883c27fce68573325..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/benchmark.rst
+++ /dev/null
@@ -1,99 +0,0 @@
-Benchmark
-=========
-
-The following is the result of a synthetic benchmark comparing both compilation
-time and module size of pybind11 against Boost.Python. A detailed report about a
-Boost.Python to pybind11 conversion of a real project is available here: [#f1]_.
-
-.. [#f1] http://graylab.jhu.edu/RosettaCon2016/PyRosetta-4.pdf
-
-Setup
------
-
-A python script (see the ``docs/benchmark.py`` file) was used to generate a set
-of files with dummy classes whose count increases for each successive benchmark
-(between 1 and 2048 classes in powers of two). Each class has four methods with
-a randomly generated signature with a return value and four arguments. (There
-was no particular reason for this setup other than the desire to generate many
-unique function signatures whose count could be controlled in a simple way.)
-
-Here is an example of the binding code for one class:
-
-.. code-block:: cpp
-
- ...
- class cl034 {
- public:
- cl279 *fn_000(cl084 *, cl057 *, cl065 *, cl042 *);
- cl025 *fn_001(cl098 *, cl262 *, cl414 *, cl121 *);
- cl085 *fn_002(cl445 *, cl297 *, cl145 *, cl421 *);
- cl470 *fn_003(cl200 *, cl323 *, cl332 *, cl492 *);
- };
- ...
-
- PYBIND11_PLUGIN(example) {
- py::module m("example");
- ...
- py::class_<cl034>(m, "cl034")
- .def("fn_000", &cl034::fn_000)
- .def("fn_001", &cl034::fn_001)
- .def("fn_002", &cl034::fn_002)
- .def("fn_003", &cl034::fn_003)
- ...
- return m.ptr();
- }
-
-The Boost.Python version looks almost identical except that a return value
-policy had to be specified as an argument to ``def()``. For both libraries,
-compilation was done with
-
-.. code-block:: bash
-
- Apple LLVM version 7.0.2 (clang-700.1.81)
-
-and the following compilation flags
-
-.. code-block:: bash
-
- g++ -Os -shared -rdynamic -undefined dynamic_lookup -fvisibility=hidden -std=c++14
-
-Compilation time
-----------------
-
-The following log-log plot shows how the compilation time grows for an
-increasing number of class and function declarations. pybind11 includes many
-fewer headers, which initially leads to shorter compilation times, but the
-performance is ultimately fairly similar (pybind11 is 19.8 seconds faster for
-the largest largest file with 2048 classes and a total of 8192 methods -- a
-modest **1.2x** speedup relative to Boost.Python, which required 116.35
-seconds).
-
-.. only:: not latex
-
- .. image:: pybind11_vs_boost_python1.svg
-
-.. only:: latex
-
- .. image:: pybind11_vs_boost_python1.png
-
-Module size
------------
-
-Differences between the two libraries become much more pronounced when
-considering the file size of the generated Python plugin: for the largest file,
-the binary generated by Boost.Python required 16.8 MiB, which was **2.17
-times** / **9.1 megabytes** larger than the output generated by pybind11. For
-very small inputs, Boost.Python has an edge in the plot below -- however, note
-that it stores many definitions in an external library, whose size was not
-included here, hence the comparison is slightly shifted in Boost.Python's
-favor.
-
-.. only:: not latex
-
- .. image:: pybind11_vs_boost_python2.svg
-
-.. only:: latex
-
- .. image:: pybind11_vs_boost_python2.png
-
-
diff --git a/thirdparty/pybind11/pybind11/docs/changelog.rst b/thirdparty/pybind11/pybind11/docs/changelog.rst
deleted file mode 100644
index aba8a20091c6d3987101e6e2edc3380fdca96d2c..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/changelog.rst
+++ /dev/null
@@ -1,568 +0,0 @@
-.. _changelog:
-
-Changelog
-#########
-
-Starting with version 1.8.0, pybind11 releases use a `semantic versioning
-<http://semver.org>`_ policy.
-
-
-v2.1.1 (April 7, 2017)
------------------------------------------------------
-
-* Fixed minimum version requirement for MSVC 2015u3
- `#773 <https://github.com/pybind/pybind11/pull/773>`_.
-
-v2.1.0 (March 22, 2017)
------------------------------------------------------
-
-* pybind11 now performs function overload resolution in two phases. The first
- phase only considers exact type matches, while the second allows for implicit
- conversions to take place. A special ``noconvert()`` syntax can be used to
- completely disable implicit conversions for specific arguments.
- `#643 <https://github.com/pybind/pybind11/pull/643>`_,
- `#634 <https://github.com/pybind/pybind11/pull/634>`_,
- `#650 <https://github.com/pybind/pybind11/pull/650>`_.
-
-* Fixed a regression where static properties no longer worked with classes
- using multiple inheritance. The ``py::metaclass`` attribute is no longer
- necessary (and deprecated as of this release) when binding classes with
- static properties.
- `#679 <https://github.com/pybind/pybind11/pull/679>`_,
-
-* Classes bound using ``pybind11`` can now use custom metaclasses.
- `#679 <https://github.com/pybind/pybind11/pull/679>`_,
-
-* ``py::args`` and ``py::kwargs`` can now be mixed with other positional
- arguments when binding functions using pybind11.
- `#611 <https://github.com/pybind/pybind11/pull/611>`_.
-
-* Improved support for C++11 unicode string and character types; added
- extensive documentation regarding pybind11's string conversion behavior.
- `#624 <https://github.com/pybind/pybind11/pull/624>`_,
- `#636 <https://github.com/pybind/pybind11/pull/636>`_,
- `#715 <https://github.com/pybind/pybind11/pull/715>`_.
-
-* pybind11 can now avoid expensive copies when converting Eigen arrays to NumPy
- arrays (and vice versa). `#610 <https://github.com/pybind/pybind11/pull/610>`_.
-
-* The "fast path" in ``py::vectorize`` now works for any full-size group of C or
- F-contiguous arrays. The non-fast path is also faster since it no longer performs
- copies of the input arguments (except when type conversions are necessary).
- `#610 <https://github.com/pybind/pybind11/pull/610>`_.
-
-* Added fast, unchecked access to NumPy arrays via a proxy object.
- `#746 <https://github.com/pybind/pybind11/pull/746>`_.
-
-* Transparent support for class-specific ``operator new`` and
- ``operator delete`` implementations.
- `#755 <https://github.com/pybind/pybind11/pull/755>`_.
-
-* Slimmer and more efficient STL-compatible iterator interface for sequence types.
- `#662 <https://github.com/pybind/pybind11/pull/662>`_.
-
-* Improved custom holder type support.
- `#607 <https://github.com/pybind/pybind11/pull/607>`_.
-
-* ``nullptr`` to ``None`` conversion fixed in various builtin type casters.
- `#732 <https://github.com/pybind/pybind11/pull/732>`_.
-
-* ``enum_`` now exposes its members via a special ``__members__`` attribute.
- `#666 <https://github.com/pybind/pybind11/pull/666>`_.
-
-* ``std::vector`` bindings created using ``stl_bind.h`` can now optionally
- implement the buffer protocol. `#488 <https://github.com/pybind/pybind11/pull/488>`_.
-
-* Automated C++ reference documentation using doxygen and breathe.
- `#598 <https://github.com/pybind/pybind11/pull/598>`_.
-
-* Added minimum compiler version assertions.
- `#727 <https://github.com/pybind/pybind11/pull/727>`_.
-
-* Improved compatibility with C++1z.
- `#677 <https://github.com/pybind/pybind11/pull/677>`_.
-
-* Improved ``py::capsule`` API. Can be used to implement cleanup
- callbacks that are involved at module destruction time.
- `#752 <https://github.com/pybind/pybind11/pull/752>`_.
-
-* Various minor improvements and fixes.
- `#595 <https://github.com/pybind/pybind11/pull/595>`_,
- `#588 <https://github.com/pybind/pybind11/pull/588>`_,
- `#589 <https://github.com/pybind/pybind11/pull/589>`_,
- `#603 <https://github.com/pybind/pybind11/pull/603>`_,
- `#619 <https://github.com/pybind/pybind11/pull/619>`_,
- `#648 <https://github.com/pybind/pybind11/pull/648>`_,
- `#695 <https://github.com/pybind/pybind11/pull/695>`_,
- `#720 <https://github.com/pybind/pybind11/pull/720>`_,
- `#723 <https://github.com/pybind/pybind11/pull/723>`_,
- `#729 <https://github.com/pybind/pybind11/pull/729>`_,
- `#724 <https://github.com/pybind/pybind11/pull/724>`_,
- `#742 <https://github.com/pybind/pybind11/pull/742>`_,
- `#753 <https://github.com/pybind/pybind11/pull/753>`_.
-
-v2.0.1 (Jan 4, 2017)
------------------------------------------------------
-
-* Fix pointer to reference error in type_caster on MSVC
- `#583 <https://github.com/pybind/pybind11/pull/583>`_.
-
-* Fixed a segmentation in the test suite due to a typo
- `cd7eac <https://github.com/pybind/pybind11/commit/cd7eac>`_.
-
-v2.0.0 (Jan 1, 2017)
------------------------------------------------------
-
-* Fixed a reference counting regression affecting types with custom metaclasses
- (introduced in v2.0.0-rc1).
- `#571 <https://github.com/pybind/pybind11/pull/571>`_.
-
-* Quenched a CMake policy warning.
- `#570 <https://github.com/pybind/pybind11/pull/570>`_.
-
-v2.0.0-rc1 (Dec 23, 2016)
------------------------------------------------------
-
-The pybind11 developers are excited to issue a release candidate of pybind11
-with a subsequent v2.0.0 release planned in early January next year.
-
-An incredible amount of effort by went into pybind11 over the last ~5 months,
-leading to a release that is jam-packed with exciting new features and numerous
-usability improvements. The following list links PRs or individual commits
-whenever applicable.
-
-Happy Christmas!
-
-* Support for binding C++ class hierarchies that make use of multiple
- inheritance. `#410 <https://github.com/pybind/pybind11/pull/410>`_.
-
-* PyPy support: pybind11 now supports nightly builds of PyPy and will
- interoperate with the future 5.7 release. No code changes are necessary,
- everything "just" works as usual. Note that we only target the Python 2.7
- branch for now; support for 3.x will be added once its ``cpyext`` extension
- support catches up. A few minor features remain unsupported for the time
- being (notably dynamic attributes in custom types).
- `#527 <https://github.com/pybind/pybind11/pull/527>`_.
-
-* Significant work on the documentation -- in particular, the monolitic
- ``advanced.rst`` file was restructured into a easier to read hierarchical
- organization. `#448 <https://github.com/pybind/pybind11/pull/448>`_.
-
-* Many NumPy-related improvements:
-
- 1. Object-oriented API to access and modify NumPy ``ndarray`` instances,
- replicating much of the corresponding NumPy C API functionality.
- `#402 <https://github.com/pybind/pybind11/pull/402>`_.
-
- 2. NumPy array ``dtype`` array descriptors are now first-class citizens and
- are exposed via a new class ``py::dtype``.
-
- 3. Structured dtypes can be registered using the ``PYBIND11_NUMPY_DTYPE()``
- macro. Special ``array`` constructors accepting dtype objects were also
- added.
-
- One potential caveat involving this change: format descriptor strings
- should now be accessed via ``format_descriptor::format()`` (however, for
- compatibility purposes, the old syntax ``format_descriptor::value`` will
- still work for non-structured data types). `#308
- <https://github.com/pybind/pybind11/pull/308>`_.
-
- 4. Further improvements to support structured dtypes throughout the system.
- `#472 <https://github.com/pybind/pybind11/pull/472>`_,
- `#474 <https://github.com/pybind/pybind11/pull/474>`_,
- `#459 <https://github.com/pybind/pybind11/pull/459>`_,
- `#453 <https://github.com/pybind/pybind11/pull/453>`_,
- `#452 <https://github.com/pybind/pybind11/pull/452>`_, and
- `#505 <https://github.com/pybind/pybind11/pull/505>`_.
-
- 5. Fast access operators. `#497 <https://github.com/pybind/pybind11/pull/497>`_.
-
- 6. Constructors for arrays whose storage is owned by another object.
- `#440 <https://github.com/pybind/pybind11/pull/440>`_.
-
- 7. Added constructors for ``array`` and ``array_t`` explicitly accepting shape
- and strides; if strides are not provided, they are deduced assuming
- C-contiguity. Also added simplified constructors for 1-dimensional case.
-
- 8. Added buffer/NumPy support for ``char[N]`` and ``std::array<char, N>`` types.
-
- 9. Added ``memoryview`` wrapper type which is constructible from ``buffer_info``.
-
-* Eigen: many additional conversions and support for non-contiguous
- arrays/slices.
- `#427 <https://github.com/pybind/pybind11/pull/427>`_,
- `#315 <https://github.com/pybind/pybind11/pull/315>`_,
- `#316 <https://github.com/pybind/pybind11/pull/316>`_,
- `#312 <https://github.com/pybind/pybind11/pull/312>`_, and
- `#267 <https://github.com/pybind/pybind11/pull/267>`_
-
-* Incompatible changes in ``class_<...>::class_()``:
-
- 1. Declarations of types that provide access via the buffer protocol must
- now include the ``py::buffer_protocol()`` annotation as an argument to
- the ``class_`` constructor.
-
- 2. Declarations of types that require a custom metaclass (i.e. all classes
- which include static properties via commands such as
- ``def_readwrite_static()``) must now include the ``py::metaclass()``
- annotation as an argument to the ``class_`` constructor.
-
- These two changes were necessary to make type definitions in pybind11
- future-proof, and to support PyPy via its cpyext mechanism. `#527
- <https://github.com/pybind/pybind11/pull/527>`_.
-
-
- 3. This version of pybind11 uses a redesigned mechnism for instantiating
- trempoline classes that are used to override virtual methods from within
- Python. This led to the following user-visible syntax change: instead of
-
- .. code-block:: cpp
-
- py::class_<TrampolineClass>("MyClass")
- .alias<MyClass>()
- ....
-
- write
-
- .. code-block:: cpp
-
- py::class_<MyClass, TrampolineClass>("MyClass")
- ....
-
- Importantly, both the original and the trampoline class are now
- specified as an arguments (in arbitrary order) to the ``py::class_``
- template, and the ``alias<..>()`` call is gone. The new scheme has zero
- overhead in cases when Python doesn't override any functions of the
- underlying C++ class. `rev. 86d825
- <https://github.com/pybind/pybind11/commit/86d825>`_.
-
-* Added ``eval`` and ``eval_file`` functions for evaluating expressions and
- statements from a string or file. `rev. 0d3fc3
- <https://github.com/pybind/pybind11/commit/0d3fc3>`_.
-
-* pybind11 can now create types with a modifiable dictionary.
- `#437 <https://github.com/pybind/pybind11/pull/437>`_ and
- `#444 <https://github.com/pybind/pybind11/pull/444>`_.
-
-* Support for translation of arbitrary C++ exceptions to Python counterparts.
- `#296 <https://github.com/pybind/pybind11/pull/296>`_ and
- `#273 <https://github.com/pybind/pybind11/pull/273>`_.
-
-* Report full backtraces through mixed C++/Python code, better reporting for
- import errors, fixed GIL management in exception processing.
- `#537 <https://github.com/pybind/pybind11/pull/537>`_,
- `#494 <https://github.com/pybind/pybind11/pull/494>`_,
- `rev. e72d95 <https://github.com/pybind/pybind11/commit/e72d95>`_, and
- `rev. 099d6e <https://github.com/pybind/pybind11/commit/099d6e>`_.
-
-* Support for bit-level operations, comparisons, and serialization of C++
- enumerations. `#503 <https://github.com/pybind/pybind11/pull/503>`_,
- `#508 <https://github.com/pybind/pybind11/pull/508>`_,
- `#380 <https://github.com/pybind/pybind11/pull/380>`_,
- `#309 <https://github.com/pybind/pybind11/pull/309>`_.
- `#311 <https://github.com/pybind/pybind11/pull/311>`_.
-
-* The ``class_`` constructor now accepts its template arguments in any order.
- `#385 <https://github.com/pybind/pybind11/pull/385>`_.
-
-* Attribute and item accessors now have a more complete interface which makes
- it possible to chain attributes as in
- ``obj.attr("a")[key].attr("b").attr("method")(1, 2, 3)``. `#425
- <https://github.com/pybind/pybind11/pull/425>`_.
-
-* Major redesign of the default and conversion constructors in ``pytypes.h``.
- `#464 <https://github.com/pybind/pybind11/pull/464>`_.
-
-* Added built-in support for ``std::shared_ptr`` holder type. It is no longer
- necessary to to include a declaration of the form
- ``PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>)`` (though continuing to
- do so won't cause an error).
- `#454 <https://github.com/pybind/pybind11/pull/454>`_.
-
-* New ``py::overload_cast`` casting operator to select among multiple possible
- overloads of a function. An example:
-
- .. code-block:: cpp
-
- py::class_<Pet>(m, "Pet")
- .def("set", py::overload_cast<int>(&Pet::set), "Set the pet's age")
- .def("set", py::overload_cast<const std::string &>(&Pet::set), "Set the pet's name");
-
- This feature only works on C++14-capable compilers.
- `#541 <https://github.com/pybind/pybind11/pull/541>`_.
-
-* C++ types are automatically cast to Python types, e.g. when assigning
- them as an attribute. For instance, the following is now legal:
-
- .. code-block:: cpp
-
- py::module m = /* ... */
- m.attr("constant") = 123;
-
- (Previously, a ``py::cast`` call was necessary to avoid a compilation error.)
- `#551 <https://github.com/pybind/pybind11/pull/551>`_.
-
-* Redesigned ``pytest``-based test suite. `#321 <https://github.com/pybind/pybind11/pull/321>`_.
-
-* Instance tracking to detect reference leaks in test suite. `#324 <https://github.com/pybind/pybind11/pull/324>`_
-
-* pybind11 can now distinguish between multiple different instances that are
- located at the same memory address, but which have different types.
- `#329 <https://github.com/pybind/pybind11/pull/329>`_.
-
-* Improved logic in ``move`` return value policy.
- `#510 <https://github.com/pybind/pybind11/pull/510>`_,
- `#297 <https://github.com/pybind/pybind11/pull/297>`_.
-
-* Generalized unpacking API to permit calling Python functions from C++ using
- notation such as ``foo(a1, a2, *args, "ka"_a=1, "kb"_a=2, **kwargs)``. `#372 <https://github.com/pybind/pybind11/pull/372>`_.
-
-* ``py::print()`` function whose behavior matches that of the native Python
- ``print()`` function. `#372 <https://github.com/pybind/pybind11/pull/372>`_.
-
-* Added ``py::dict`` keyword constructor:``auto d = dict("number"_a=42,
- "name"_a="World");``. `#372 <https://github.com/pybind/pybind11/pull/372>`_.
-
-* Added ``py::str::format()`` method and ``_s`` literal: ``py::str s = "1 + 2
- = {}"_s.format(3);``. `#372 <https://github.com/pybind/pybind11/pull/372>`_.
-
-* Added ``py::repr()`` function which is equivalent to Python's builtin
- ``repr()``. `#333 <https://github.com/pybind/pybind11/pull/333>`_.
-
-* Improved construction and destruction logic for holder types. It is now
- possible to reference instances with smart pointer holder types without
- constructing the holder if desired. The ``PYBIND11_DECLARE_HOLDER_TYPE``
- macro now accepts an optional second parameter to indicate whether the holder
- type uses intrusive reference counting.
- `#533 <https://github.com/pybind/pybind11/pull/533>`_ and
- `#561 <https://github.com/pybind/pybind11/pull/561>`_.
-
-* Mapping a stateless C++ function to Python and back is now "for free" (i.e.
- no extra indirections or argument conversion overheads). `rev. 954b79
- <https://github.com/pybind/pybind11/commit/954b79>`_.
-
-* Bindings for ``std::valarray<T>``.
- `#545 <https://github.com/pybind/pybind11/pull/545>`_.
-
-* Improved support for C++17 capable compilers.
- `#562 <https://github.com/pybind/pybind11/pull/562>`_.
-
-* Bindings for ``std::optional<t>``.
- `#475 <https://github.com/pybind/pybind11/pull/475>`_,
- `#476 <https://github.com/pybind/pybind11/pull/476>`_,
- `#479 <https://github.com/pybind/pybind11/pull/479>`_,
- `#499 <https://github.com/pybind/pybind11/pull/499>`_, and
- `#501 <https://github.com/pybind/pybind11/pull/501>`_.
-
-* ``stl_bind.h``: general improvements and support for ``std::map`` and
- ``std::unordered_map``.
- `#490 <https://github.com/pybind/pybind11/pull/490>`_,
- `#282 <https://github.com/pybind/pybind11/pull/282>`_,
- `#235 <https://github.com/pybind/pybind11/pull/235>`_.
-
-* The ``std::tuple``, ``std::pair``, ``std::list``, and ``std::vector`` type
- casters now accept any Python sequence type as input. `rev. 107285
- <https://github.com/pybind/pybind11/commit/107285>`_.
-
-* Improved CMake Python detection on multi-architecture Linux.
- `#532 <https://github.com/pybind/pybind11/pull/532>`_.
-
-* Infrastructure to selectively disable or enable parts of the automatically
- generated docstrings. `#486 <https://github.com/pybind/pybind11/pull/486>`_.
-
-* ``reference`` and ``reference_internal`` are now the default return value
- properties for static and non-static properties, respectively. `#473
- <https://github.com/pybind/pybind11/pull/473>`_. (the previous defaults
- were ``automatic``). `#473 <https://github.com/pybind/pybind11/pull/473>`_.
-
-* Support for ``std::unique_ptr`` with non-default deleters or no deleter at
- all (``py::nodelete``). `#384 <https://github.com/pybind/pybind11/pull/384>`_.
-
-* Deprecated ``handle::call()`` method. The new syntax to call Python
- functions is simply ``handle()``. It can also be invoked explicitly via
- ``handle::operator<X>()``, where ``X`` is an optional return value policy.
-
-* Print more informative error messages when ``make_tuple()`` or ``cast()``
- fail. `#262 <https://github.com/pybind/pybind11/pull/262>`_.
-
-* Creation of holder types for classes deriving from
- ``std::enable_shared_from_this<>`` now also works for ``const`` values.
- `#260 <https://github.com/pybind/pybind11/pull/260>`_.
-
-* ``make_iterator()`` improvements for better compatibility with various
- types (now uses prefix increment operator); it now also accepts iterators
- with different begin/end types as long as they are equality comparable.
- `#247 <https://github.com/pybind/pybind11/pull/247>`_.
-
-* ``arg()`` now accepts a wider range of argument types for default values.
- `#244 <https://github.com/pybind/pybind11/pull/244>`_.
-
-* Support ``keep_alive`` where the nurse object may be ``None``. `#341
- <https://github.com/pybind/pybind11/pull/341>`_.
-
-* Added constructors for ``str`` and ``bytes`` from zero-terminated char
- pointers, and from char pointers and length. Added constructors for ``str``
- from ``bytes`` and for ``bytes`` from ``str``, which will perform UTF-8
- decoding/encoding as required.
-
-* Many other improvements of library internals without user-visible changes
-
-
-1.8.1 (July 12, 2016)
-----------------------
-* Fixed a rare but potentially very severe issue when the garbage collector ran
- during pybind11 type creation.
-
-1.8.0 (June 14, 2016)
-----------------------
-* Redesigned CMake build system which exports a convenient
- ``pybind11_add_module`` function to parent projects.
-* ``std::vector<>`` type bindings analogous to Boost.Python's ``indexing_suite``
-* Transparent conversion of sparse and dense Eigen matrices and vectors (``eigen.h``)
-* Added an ``ExtraFlags`` template argument to the NumPy ``array_t<>`` wrapper
- to disable an enforced cast that may lose precision, e.g. to create overloads
- for different precisions and complex vs real-valued matrices.
-* Prevent implicit conversion of floating point values to integral types in
- function arguments
-* Fixed incorrect default return value policy for functions returning a shared
- pointer
-* Don't allow registering a type via ``class_`` twice
-* Don't allow casting a ``None`` value into a C++ lvalue reference
-* Fixed a crash in ``enum_::operator==`` that was triggered by the ``help()`` command
-* Improved detection of whether or not custom C++ types can be copy/move-constructed
-* Extended ``str`` type to also work with ``bytes`` instances
-* Added a ``"name"_a`` user defined string literal that is equivalent to ``py::arg("name")``.
-* When specifying function arguments via ``py::arg``, the test that verifies
- the number of arguments now runs at compile time.
-* Added ``[[noreturn]]`` attribute to ``pybind11_fail()`` to quench some
- compiler warnings
-* List function arguments in exception text when the dispatch code cannot find
- a matching overload
-* Added ``PYBIND11_OVERLOAD_NAME`` and ``PYBIND11_OVERLOAD_PURE_NAME`` macros which
- can be used to override virtual methods whose name differs in C++ and Python
- (e.g. ``__call__`` and ``operator()``)
-* Various minor ``iterator`` and ``make_iterator()`` improvements
-* Transparently support ``__bool__`` on Python 2.x and Python 3.x
-* Fixed issue with destructor of unpickled object not being called
-* Minor CMake build system improvements on Windows
-* New ``pybind11::args`` and ``pybind11::kwargs`` types to create functions which
- take an arbitrary number of arguments and keyword arguments
-* New syntax to call a Python function from C++ using ``*args`` and ``*kwargs``
-* The functions ``def_property_*`` now correctly process docstring arguments (these
- formerly caused a segmentation fault)
-* Many ``mkdoc.py`` improvements (enumerations, template arguments, ``DOC()``
- macro accepts more arguments)
-* Cygwin support
-* Documentation improvements (pickling support, ``keep_alive``, macro usage)
-
-1.7 (April 30, 2016)
-----------------------
-* Added a new ``move`` return value policy that triggers C++11 move semantics.
- The automatic return value policy falls back to this case whenever a rvalue
- reference is encountered
-* Significantly more general GIL state routines that are used instead of
- Python's troublesome ``PyGILState_Ensure`` and ``PyGILState_Release`` API
-* Redesign of opaque types that drastically simplifies their usage
-* Extended ability to pass values of type ``[const] void *``
-* ``keep_alive`` fix: don't fail when there is no patient
-* ``functional.h``: acquire the GIL before calling a Python function
-* Added Python RAII type wrappers ``none`` and ``iterable``
-* Added ``*args`` and ``*kwargs`` pass-through parameters to
- ``pybind11.get_include()`` function
-* Iterator improvements and fixes
-* Documentation on return value policies and opaque types improved
-
-1.6 (April 30, 2016)
-----------------------
-* Skipped due to upload to PyPI gone wrong and inability to recover
- (https://github.com/pypa/packaging-problems/issues/74)
-
-1.5 (April 21, 2016)
-----------------------
-* For polymorphic types, use RTTI to try to return the closest type registered with pybind11
-* Pickling support for serializing and unserializing C++ instances to a byte stream in Python
-* Added a convenience routine ``make_iterator()`` which turns a range indicated
- by a pair of C++ iterators into a iterable Python object
-* Added ``len()`` and a variadic ``make_tuple()`` function
-* Addressed a rare issue that could confuse the current virtual function
- dispatcher and another that could lead to crashes in multi-threaded
- applications
-* Added a ``get_include()`` function to the Python module that returns the path
- of the directory containing the installed pybind11 header files
-* Documentation improvements: import issues, symbol visibility, pickling, limitations
-* Added casting support for ``std::reference_wrapper<>``
-
-1.4 (April 7, 2016)
---------------------------
-* Transparent type conversion for ``std::wstring`` and ``wchar_t``
-* Allow passing ``nullptr``-valued strings
-* Transparent passing of ``void *`` pointers using capsules
-* Transparent support for returning values wrapped in ``std::unique_ptr<>``
-* Improved docstring generation for compatibility with Sphinx
-* Nicer debug error message when default parameter construction fails
-* Support for "opaque" types that bypass the transparent conversion layer for STL containers
-* Redesigned type casting interface to avoid ambiguities that could occasionally cause compiler errors
-* Redesigned property implementation; fixes crashes due to an unfortunate default return value policy
-* Anaconda package generation support
-
-1.3 (March 8, 2016)
---------------------------
-
-* Added support for the Intel C++ compiler (v15+)
-* Added support for the STL unordered set/map data structures
-* Added support for the STL linked list data structure
-* NumPy-style broadcasting support in ``pybind11::vectorize``
-* pybind11 now displays more verbose error messages when ``arg::operator=()`` fails
-* pybind11 internal data structures now live in a version-dependent namespace to avoid ABI issues
-* Many, many bugfixes involving corner cases and advanced usage
-
-1.2 (February 7, 2016)
---------------------------
-
-* Optional: efficient generation of function signatures at compile time using C++14
-* Switched to a simpler and more general way of dealing with function default
- arguments. Unused keyword arguments in function calls are now detected and
- cause errors as expected
-* New ``keep_alive`` call policy analogous to Boost.Python's ``with_custodian_and_ward``
-* New ``pybind11::base<>`` attribute to indicate a subclass relationship
-* Improved interface for RAII type wrappers in ``pytypes.h``
-* Use RAII type wrappers consistently within pybind11 itself. This
- fixes various potential refcount leaks when exceptions occur
-* Added new ``bytes`` RAII type wrapper (maps to ``string`` in Python 2.7)
-* Made handle and related RAII classes const correct, using them more
- consistently everywhere now
-* Got rid of the ugly ``__pybind11__`` attributes on the Python side---they are
- now stored in a C++ hash table that is not visible in Python
-* Fixed refcount leaks involving NumPy arrays and bound functions
-* Vastly improved handling of shared/smart pointers
-* Removed an unnecessary copy operation in ``pybind11::vectorize``
-* Fixed naming clashes when both pybind11 and NumPy headers are included
-* Added conversions for additional exception types
-* Documentation improvements (using multiple extension modules, smart pointers,
- other minor clarifications)
-* unified infrastructure for parsing variadic arguments in ``class_`` and cpp_function
-* Fixed license text (was: ZLIB, should have been: 3-clause BSD)
-* Python 3.2 compatibility
-* Fixed remaining issues when accessing types in another plugin module
-* Added enum comparison and casting methods
-* Improved SFINAE-based detection of whether types are copy-constructible
-* Eliminated many warnings about unused variables and the use of ``offsetof()``
-* Support for ``std::array<>`` conversions
-
-1.1 (December 7, 2015)
---------------------------
-
-* Documentation improvements (GIL, wrapping functions, casting, fixed many typos)
-* Generalized conversion of integer types
-* Improved support for casting function objects
-* Improved support for ``std::shared_ptr<>`` conversions
-* Initial support for ``std::set<>`` conversions
-* Fixed type resolution issue for types defined in a separate plugin module
-* Cmake build system improvements
-* Factored out generic functionality to non-templated code (smaller code size)
-* Added a code size / compile time benchmark vs Boost.Python
-* Added an appveyor CI script
-
-1.0 (October 15, 2015)
-------------------------
-* Initial release
diff --git a/thirdparty/pybind11/pybind11/docs/classes.rst b/thirdparty/pybind11/pybind11/docs/classes.rst
deleted file mode 100644
index 30fb2a2d5fb28bf8606b20c526d806f05de499a1..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/classes.rst
+++ /dev/null
@@ -1,445 +0,0 @@
-.. _classes:
-
-Object-oriented code
-####################
-
-Creating bindings for a custom type
-===================================
-
-Let's now look at a more complex example where we'll create bindings for a
-custom C++ data structure named ``Pet``. Its definition is given below:
-
-.. code-block:: cpp
-
- struct Pet {
- Pet(const std::string &name) : name(name) { }
- void setName(const std::string &name_) { name = name_; }
- const std::string &getName() const { return name; }
-
- std::string name;
- };
-
-The binding code for ``Pet`` looks as follows:
-
-.. code-block:: cpp
-
- #include <pybind11/pybind11.h>
-
- namespace py = pybind11;
-
- PYBIND11_PLUGIN(example) {
- py::module m("example", "pybind11 example plugin");
-
- py::class_<Pet>(m, "Pet")
- .def(py::init<const std::string &>())
- .def("setName", &Pet::setName)
- .def("getName", &Pet::getName);
-
- return m.ptr();
- }
-
-:class:`class_` creates bindings for a C++ *class* or *struct*-style data
-structure. :func:`init` is a convenience function that takes the types of a
-constructor's parameters as template arguments and wraps the corresponding
-constructor (see the :ref:`custom_constructors` section for details). An
-interactive Python session demonstrating this example is shown below:
-
-.. code-block:: pycon
-
- % python
- >>> import example
- >>> p = example.Pet('Molly')
- >>> print(p)
- <example.Pet object at 0x10cd98060>
- >>> p.getName()
- u'Molly'
- >>> p.setName('Charly')
- >>> p.getName()
- u'Charly'
-
-.. seealso::
-
- Static member functions can be bound in the same way using
- :func:`class_::def_static`.
-
-Keyword and default arguments
-=============================
-It is possible to specify keyword and default arguments using the syntax
-discussed in the previous chapter. Refer to the sections :ref:`keyword_args`
-and :ref:`default_args` for details.
-
-Binding lambda functions
-========================
-
-Note how ``print(p)`` produced a rather useless summary of our data structure in the example above:
-
-.. code-block:: pycon
-
- >>> print(p)
- <example.Pet object at 0x10cd98060>
-
-To address this, we could bind an utility function that returns a human-readable
-summary to the special method slot named ``__repr__``. Unfortunately, there is no
-suitable functionality in the ``Pet`` data structure, and it would be nice if
-we did not have to change it. This can easily be accomplished by binding a
-Lambda function instead:
-
-.. code-block:: cpp
-
- py::class_<Pet>(m, "Pet")
- .def(py::init<const std::string &>())
- .def("setName", &Pet::setName)
- .def("getName", &Pet::getName)
- .def("__repr__",
- [](const Pet &a) {
- return "<example.Pet named '" + a.name + "'>";
- }
- );
-
-Both stateless [#f1]_ and stateful lambda closures are supported by pybind11.
-With the above change, the same Python code now produces the following output:
-
-.. code-block:: pycon
-
- >>> print(p)
- <example.Pet named 'Molly'>
-
-.. [#f1] Stateless closures are those with an empty pair of brackets ``[]`` as the capture object.
-
-.. _properties:
-
-Instance and static fields
-==========================
-
-We can also directly expose the ``name`` field using the
-:func:`class_::def_readwrite` method. A similar :func:`class_::def_readonly`
-method also exists for ``const`` fields.
-
-.. code-block:: cpp
-
- py::class_<Pet>(m, "Pet")
- .def(py::init<const std::string &>())
- .def_readwrite("name", &Pet::name)
- // ... remainder ...
-
-This makes it possible to write
-
-.. code-block:: pycon
-
- >>> p = example.Pet('Molly')
- >>> p.name
- u'Molly'
- >>> p.name = 'Charly'
- >>> p.name
- u'Charly'
-
-Now suppose that ``Pet::name`` was a private internal variable
-that can only be accessed via setters and getters.
-
-.. code-block:: cpp
-
- class Pet {
- public:
- Pet(const std::string &name) : name(name) { }
- void setName(const std::string &name_) { name = name_; }
- const std::string &getName() const { return name; }
- private:
- std::string name;
- };
-
-In this case, the method :func:`class_::def_property`
-(:func:`class_::def_property_readonly` for read-only data) can be used to
-provide a field-like interface within Python that will transparently call
-the setter and getter functions:
-
-.. code-block:: cpp
-
- py::class_<Pet>(m, "Pet")
- .def(py::init<const std::string &>())
- .def_property("name", &Pet::getName, &Pet::setName)
- // ... remainder ...
-
-.. seealso::
-
- Similar functions :func:`class_::def_readwrite_static`,
- :func:`class_::def_readonly_static` :func:`class_::def_property_static`,
- and :func:`class_::def_property_readonly_static` are provided for binding
- static variables and properties. Please also see the section on
- :ref:`static_properties` in the advanced part of the documentation.
-
-Dynamic attributes
-==================
-
-Native Python classes can pick up new attributes dynamically:
-
-.. code-block:: pycon
-
- >>> class Pet:
- ... name = 'Molly'
- ...
- >>> p = Pet()
- >>> p.name = 'Charly' # overwrite existing
- >>> p.age = 2 # dynamically add a new attribute
-
-By default, classes exported from C++ do not support this and the only writable
-attributes are the ones explicitly defined using :func:`class_::def_readwrite`
-or :func:`class_::def_property`.
-
-.. code-block:: cpp
-
- py::class_<Pet>(m, "Pet")
- .def(py::init<>())
- .def_readwrite("name", &Pet::name);
-
-Trying to set any other attribute results in an error:
-
-.. code-block:: pycon
-
- >>> p = example.Pet()
- >>> p.name = 'Charly' # OK, attribute defined in C++
- >>> p.age = 2 # fail
- AttributeError: 'Pet' object has no attribute 'age'
-
-To enable dynamic attributes for C++ classes, the :class:`py::dynamic_attr` tag
-must be added to the :class:`py::class_` constructor:
-
-.. code-block:: cpp
-
- py::class_<Pet>(m, "Pet", py::dynamic_attr())
- .def(py::init<>())
- .def_readwrite("name", &Pet::name);
-
-Now everything works as expected:
-
-.. code-block:: pycon
-
- >>> p = example.Pet()
- >>> p.name = 'Charly' # OK, overwrite value in C++
- >>> p.age = 2 # OK, dynamically add a new attribute
- >>> p.__dict__ # just like a native Python class
- {'age': 2}
-
-Note that there is a small runtime cost for a class with dynamic attributes.
-Not only because of the addition of a ``__dict__``, but also because of more
-expensive garbage collection tracking which must be activated to resolve
-possible circular references. Native Python classes incur this same cost by
-default, so this is not anything to worry about. By default, pybind11 classes
-are more efficient than native Python classes. Enabling dynamic attributes
-just brings them on par.
-
-.. _inheritance:
-
-Inheritance
-===========
-
-Suppose now that the example consists of two data structures with an
-inheritance relationship:
-
-.. code-block:: cpp
-
- struct Pet {
- Pet(const std::string &name) : name(name) { }
- std::string name;
- };
-
- struct Dog : Pet {
- Dog(const std::string &name) : Pet(name) { }
- std::string bark() const { return "woof!"; }
- };
-
-There are two different ways of indicating a hierarchical relationship to
-pybind11: the first specifies the C++ base class as an extra template
-parameter of the :class:`class_`:
-
-.. code-block:: cpp
-
- py::class_<Pet>(m, "Pet")
- .def(py::init<const std::string &>())
- .def_readwrite("name", &Pet::name);
-
- // Method 1: template parameter:
- py::class_<Dog, Pet /* <- specify C++ parent type */>(m, "Dog")
- .def(py::init<const std::string &>())
- .def("bark", &Dog::bark);
-
-Alternatively, we can also assign a name to the previously bound ``Pet``
-:class:`class_` object and reference it when binding the ``Dog`` class:
-
-.. code-block:: cpp
-
- py::class_<Pet> pet(m, "Pet");
- pet.def(py::init<const std::string &>())
- .def_readwrite("name", &Pet::name);
-
- // Method 2: pass parent class_ object:
- py::class_<Dog>(m, "Dog", pet /* <- specify Python parent type */)
- .def(py::init<const std::string &>())
- .def("bark", &Dog::bark);
-
-Functionality-wise, both approaches are equivalent. Afterwards, instances will
-expose fields and methods of both types:
-
-.. code-block:: pycon
-
- >>> p = example.Dog('Molly')
- >>> p.name
- u'Molly'
- >>> p.bark()
- u'woof!'
-
-Overloaded methods
-==================
-
-Sometimes there are several overloaded C++ methods with the same name taking
-different kinds of input arguments:
-
-.. code-block:: cpp
-
- struct Pet {
- Pet(const std::string &name, int age) : name(name), age(age) { }
-
- void set(int age_) { age = age_; }
- void set(const std::string &name_) { name = name_; }
-
- std::string name;
- int age;
- };
-
-Attempting to bind ``Pet::set`` will cause an error since the compiler does not
-know which method the user intended to select. We can disambiguate by casting
-them to function pointers. Binding multiple functions to the same Python name
-automatically creates a chain of function overloads that will be tried in
-sequence.
-
-.. code-block:: cpp
-
- py::class_<Pet>(m, "Pet")
- .def(py::init<const std::string &, int>())
- .def("set", (void (Pet::*)(int)) &Pet::set, "Set the pet's age")
- .def("set", (void (Pet::*)(const std::string &)) &Pet::set, "Set the pet's name");
-
-The overload signatures are also visible in the method's docstring:
-
-.. code-block:: pycon
-
- >>> help(example.Pet)
-
- class Pet(__builtin__.object)
- | Methods defined here:
- |
- | __init__(...)
- | Signature : (Pet, str, int) -> NoneType
- |
- | set(...)
- | 1. Signature : (Pet, int) -> NoneType
- |
- | Set the pet's age
- |
- | 2. Signature : (Pet, str) -> NoneType
- |
- | Set the pet's name
-
-If you have a C++14 compatible compiler [#cpp14]_, you can use an alternative
-syntax to cast the overloaded function:
-
-.. code-block:: cpp
-
- py::class_<Pet>(m, "Pet")
- .def("set", py::overload_cast<int>(&Pet::set), "Set the pet's age")
- .def("set", py::overload_cast<const std::string &>(&Pet::set), "Set the pet's name");
-
-Here, ``py::overload_cast`` only requires the parameter types to be specified.
-The return type and class are deduced. This avoids the additional noise of
-``void (Pet::*)()`` as seen in the raw cast. If a function is overloaded based
-on constness, the ``py::const_`` tag should be used:
-
-.. code-block:: cpp
-
- struct Widget {
- int foo(int x, float y);
- int foo(int x, float y) const;
- };
-
- py::class_<Widget>(m, "Widget")
- .def("foo_mutable", py::overload_cast<int, float>(&Widget::foo))
- .def("foo_const", py::overload_cast<int, float>(&Widget::foo, py::const_));
-
-
-.. [#cpp14] A compiler which supports the ``-std=c++14`` flag
- or Visual Studio 2015 Update 2 and newer.
-
-.. note::
-
- To define multiple overloaded constructors, simply declare one after the
- other using the ``.def(py::init<...>())`` syntax. The existing machinery
- for specifying keyword and default arguments also works.
-
-Enumerations and internal types
-===============================
-
-Let's now suppose that the example class contains an internal enumeration type,
-e.g.:
-
-.. code-block:: cpp
-
- struct Pet {
- enum Kind {
- Dog = 0,
- Cat
- };
-
- Pet(const std::string &name, Kind type) : name(name), type(type) { }
-
- std::string name;
- Kind type;
- };
-
-The binding code for this example looks as follows:
-
-.. code-block:: cpp
-
- py::class_<Pet> pet(m, "Pet");
-
- pet.def(py::init<const std::string &, Pet::Kind>())
- .def_readwrite("name", &Pet::name)
- .def_readwrite("type", &Pet::type);
-
- py::enum_<Pet::Kind>(pet, "Kind")
- .value("Dog", Pet::Kind::Dog)
- .value("Cat", Pet::Kind::Cat)
- .export_values();
-
-To ensure that the ``Kind`` type is created within the scope of ``Pet``, the
-``pet`` :class:`class_` instance must be supplied to the :class:`enum_`.
-constructor. The :func:`enum_::export_values` function exports the enum entries
-into the parent scope, which should be skipped for newer C++11-style strongly
-typed enums.
-
-.. code-block:: pycon
-
- >>> p = Pet('Lucy', Pet.Cat)
- >>> p.type
- Kind.Cat
- >>> int(p.type)
- 1L
-
-The entries defined by the enumeration type are exposed in the ``__members__`` property:
-
-.. code-block:: pycon
-
- >>> Pet.Kind.__members__
- {'Dog': Kind.Dog, 'Cat': Kind.Cat}
-
-.. note::
-
- When the special tag ``py::arithmetic()`` is specified to the ``enum_``
- constructor, pybind11 creates an enumeration that also supports rudimentary
- arithmetic and bit-level operations like comparisons, and, or, xor, negation,
- etc.
-
- .. code-block:: cpp
-
- py::enum_<Pet::Kind>(pet, "Kind", py::arithmetic())
- ...
-
- By default, these are omitted to conserve space.
diff --git a/thirdparty/pybind11/pybind11/docs/compiling.rst b/thirdparty/pybind11/pybind11/docs/compiling.rst
deleted file mode 100644
index c7053dbf99d8c3a9c5f4c28a8e078bdf0fb31d43..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/compiling.rst
+++ /dev/null
@@ -1,185 +0,0 @@
-Build systems
-#############
-
-Building with setuptools
-========================
-
-For projects on PyPI, building with setuptools is the way to go. Sylvain Corlay
-has kindly provided an example project which shows how to set up everything,
-including automatic generation of documentation using Sphinx. Please refer to
-the [python_example]_ repository.
-
-.. [python_example] https://github.com/pybind/python_example
-
-Building with cppimport
-========================
-
- cppimport is a small Python import hook that determines whether there is a C++
- source file whose name matches the requested module. If there is, the file is
- compiled as a Python extension using pybind11 and placed in the same folder as
- the C++ source file. Python is then able to find the module and load it.
-
-.. [cppimport] https://github.com/tbenthompson/cppimport
-
-.. _cmake:
-
-Building with CMake
-===================
-
-For C++ codebases that have an existing CMake-based build system, a Python
-extension module can be created with just a few lines of code:
-
-.. code-block:: cmake
-
- cmake_minimum_required(VERSION 2.8.12)
- project(example)
-
- add_subdirectory(pybind11)
- pybind11_add_module(example example.cpp)
-
-This assumes that the pybind11 repository is located in a subdirectory named
-:file:`pybind11` and that the code is located in a file named :file:`example.cpp`.
-The CMake command ``add_subdirectory`` will import the pybind11 project which
-provides the ``pybind11_add_module`` function. It will take care of all the
-details needed to build a Python extension module on any platform.
-
-A working sample project, including a way to invoke CMake from :file:`setup.py` for
-PyPI integration, can be found in the [cmake_example]_ repository.
-
-.. [cmake_example] https://github.com/pybind/cmake_example
-
-pybind11_add_module
--------------------
-
-To ease the creation of Python extension modules, pybind11 provides a CMake
-function with the following signature:
-
-.. code-block:: cmake
-
- pybind11_add_module(<name> [MODULE | SHARED] [EXCLUDE_FROM_ALL]
- [NO_EXTRAS] [THIN_LTO] source1 [source2 ...])
-
-This function behaves very much like CMake's builtin ``add_library`` (in fact,
-it's a wrapper function around that command). It will add a library target
-called ``<name>`` to be built from the listed source files. In addition, it
-will take care of all the Python-specific compiler and linker flags as well
-as the OS- and Python-version-specific file extension. The produced target
-``<name>`` can be further manipulated with regular CMake commands.
-
-``MODULE`` or ``SHARED`` may be given to specify the type of library. If no
-type is given, ``MODULE`` is used by default which ensures the creation of a
-Python-exclusive module. Specifying ``SHARED`` will create a more traditional
-dynamic library which can also be linked from elsewhere. ``EXCLUDE_FROM_ALL``
-removes this target from the default build (see CMake docs for details).
-
-Since pybind11 is a template library, ``pybind11_add_module`` adds compiler
-flags to ensure high quality code generation without bloat arising from long
-symbol names and duplication of code in different translation units. The
-additional flags enable LTO (Link Time Optimization), set default visibility
-to *hidden* and strip unneeded symbols. See the :ref:`FAQ entry <faq:symhidden>`
-for a more detailed explanation. These optimizations are never applied in
-``Debug`` mode. If ``NO_EXTRAS`` is given, they will always be disabled, even
-in ``Release`` mode. However, this will result in code bloat and is generally
-not recommended.
-
-As stated above, LTO is enabled by default. Some newer compilers also support
-different flavors of LTO such as `ThinLTO`_. Setting ``THIN_LTO`` will cause
-the function to prefer this flavor if available. The function falls back to
-regular LTO if ``-flto=thin`` is not available.
-
-.. _ThinLTO: http://clang.llvm.org/docs/ThinLTO.html
-
-Configuration variables
------------------------
-
-By default, pybind11 will compile modules with the latest C++ standard
-available on the target compiler. To override this, the standard flag can
-be given explicitly in ``PYBIND11_CPP_STANDARD``:
-
-.. code-block:: cmake
-
- set(PYBIND11_CPP_STANDARD -std=c++11)
- add_subdirectory(pybind11) # or find_package(pybind11)
-
-Note that this and all other configuration variables must be set **before** the
-call to ``add_subdiretory`` or ``find_package``. The variables can also be set
-when calling CMake from the command line using the ``-D<variable>=<value>`` flag.
-
-The target Python version can be selected by setting ``PYBIND11_PYTHON_VERSION``
-or an exact Python installation can be specified with ``PYTHON_EXECUTABLE``.
-For example:
-
-.. code-block:: bash
-
- cmake -DPYBIND11_PYTHON_VERSION=3.6 ..
- # or
- cmake -DPYTHON_EXECUTABLE=path/to/python ..
-
-find_package vs. add_subdirectory
----------------------------------
-
-For CMake-based projects that don't include the pybind11 repository internally,
-an external installation can be detected through ``find_package(pybind11)``.
-See the `Config file`_ docstring for details of relevant CMake variables.
-
-.. code-block:: cmake
-
- cmake_minimum_required(VERSION 2.8.12)
- project(example)
-
- find_package(pybind11 REQUIRED)
- pybind11_add_module(example example.cpp)
-
-Once detected, the aforementioned ``pybind11_add_module`` can be employed as
-before. The function usage and configuration variables are identical no matter
-if pybind11 is added as a subdirectory or found as an installed package. You
-can refer to the same [cmake_example]_ repository for a full sample project
--- just swap out ``add_subdirectory`` for ``find_package``.
-
-.. _Config file: https://github.com/pybind/pybind11/blob/master/tools/pybind11Config.cmake.in
-
-Advanced: interface library target
-----------------------------------
-
-When using a version of CMake greater than 3.0, pybind11 can additionally
-be used as a special *interface library* . The target ``pybind11::module``
-is available with pybind11 headers, Python headers and libraries as needed,
-and C++ compile definitions attached. This target is suitable for linking
-to an independently constructed (through ``add_library``, not
-``pybind11_add_module``) target in the consuming project.
-
-.. code-block:: cmake
-
- cmake_minimum_required(VERSION 3.0)
- project(example)
-
- find_package(pybind11 REQUIRED) # or add_subdirectory(pybind11)
-
- add_library(example MODULE main.cpp)
- target_link_libraries(example PRIVATE pybind11::module)
- set_target_properties(example PROPERTIES PREFIX "${PYTHON_MODULE_PREFIX}"
- SUFFIX "${PYTHON_MODULE_EXTENSION}")
-
-.. warning::
-
- Since pybind11 is a metatemplate library, it is crucial that certain
- compiler flags are provided to ensure high quality code generation. In
- contrast to the ``pybind11_add_module()`` command, the CMake interface
- library only provides the *minimal* set of parameters to ensure that the
- code using pybind11 compiles, but it does **not** pass these extra compiler
- flags (i.e. this is up to you).
-
- These include Link Time Optimization (``-flto`` on GCC/Clang/ICPC, ``/GL``
- and ``/LTCG`` on Visual Studio). Default-hidden symbols on GCC/Clang/ICPC
- (``-fvisibility=hidden``) and .OBJ files with many sections on Visual Studio
- (``/bigobj``). The :ref:`FAQ <faq:symhidden>` contains an
- explanation on why these are needed.
-
-Generating binding code automatically
-=====================================
-
-The ``Binder`` project is a tool for automatic generation of pybind11 binding
-code by introspecting existing C++ codebases using LLVM/Clang. See the
-[binder]_ documentation for details.
-
-.. [binder] http://cppbinder.readthedocs.io/en/latest/about.html
diff --git a/thirdparty/pybind11/pybind11/docs/conf.py b/thirdparty/pybind11/pybind11/docs/conf.py
deleted file mode 100644
index 09604cfeb6956c79a0d5f95e10e077c19c9b0dce..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/conf.py
+++ /dev/null
@@ -1,332 +0,0 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-#
-# pybind11 documentation build configuration file, created by
-# sphinx-quickstart on Sun Oct 11 19:23:48 2015.
-#
-# This file is execfile()d with the current directory set to its
-# containing dir.
-#
-# Note that not all possible configuration values are present in this
-# autogenerated file.
-#
-# All configuration values have a default; values that are commented out
-# serve to show the default.
-
-import sys
-import os
-import shlex
-import subprocess
-
-# If extensions (or modules to document with autodoc) are in another directory,
-# add these directories to sys.path here. If the directory is relative to the
-# documentation root, use os.path.abspath to make it absolute, like shown here.
-#sys.path.insert(0, os.path.abspath('.'))
-
-# -- General configuration ------------------------------------------------
-
-# If your documentation needs a minimal Sphinx version, state it here.
-#needs_sphinx = '1.0'
-
-# Add any Sphinx extension module names here, as strings. They can be
-# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
-# ones.
-extensions = ['breathe']
-
-breathe_projects = {'pybind11': '.build/doxygenxml/'}
-breathe_default_project = 'pybind11'
-breathe_domain_by_extension = {'h': 'cpp'}
-
-# Add any paths that contain templates here, relative to this directory.
-templates_path = ['.templates']
-
-# The suffix(es) of source filenames.
-# You can specify multiple suffix as a list of string:
-# source_suffix = ['.rst', '.md']
-source_suffix = '.rst'
-
-# The encoding of source files.
-#source_encoding = 'utf-8-sig'
-
-# The master toctree document.
-master_doc = 'index'
-
-# General information about the project.
-project = 'pybind11'
-copyright = '2016, Wenzel Jakob'
-author = 'Wenzel Jakob'
-
-# The version info for the project you're documenting, acts as replacement for
-# |version| and |release|, also used in various other places throughout the
-# built documents.
-#
-# The short X.Y version.
-version = '2.1'
-# The full version, including alpha/beta/rc tags.
-release = '2.1.1'
-
-# The language for content autogenerated by Sphinx. Refer to documentation
-# for a list of supported languages.
-#
-# This is also used if you do content translation via gettext catalogs.
-# Usually you set "language" from the command line for these cases.
-language = None
-
-# There are two options for replacing |today|: either, you set today to some
-# non-false value, then it is used:
-#today = ''
-# Else, today_fmt is used as the format for a strftime call.
-#today_fmt = '%B %d, %Y'
-
-# List of patterns, relative to source directory, that match files and
-# directories to ignore when looking for source files.
-exclude_patterns = ['.build', 'release.rst']
-
-# The reST default role (used for this markup: `text`) to use for all
-# documents.
-default_role = 'any'
-
-# If true, '()' will be appended to :func: etc. cross-reference text.
-#add_function_parentheses = True
-
-# If true, the current module name will be prepended to all description
-# unit titles (such as .. function::).
-#add_module_names = True
-
-# If true, sectionauthor and moduleauthor directives will be shown in the
-# output. They are ignored by default.
-#show_authors = False
-
-# The name of the Pygments (syntax highlighting) style to use.
-#pygments_style = 'monokai'
-
-# A list of ignored prefixes for module index sorting.
-#modindex_common_prefix = []
-
-# If true, keep warnings as "system message" paragraphs in the built documents.
-#keep_warnings = False
-
-# If true, `todo` and `todoList` produce output, else they produce nothing.
-todo_include_todos = False
-
-
-# -- Options for HTML output ----------------------------------------------
-
-# The theme to use for HTML and HTML Help pages. See the documentation for
-# a list of builtin themes.
-
-on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
-
-if not on_rtd: # only import and set the theme if we're building docs locally
- import sphinx_rtd_theme
- html_theme = 'sphinx_rtd_theme'
- html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
-
- html_context = {
- 'css_files': [
- '_static/theme_overrides.css'
- ]
- }
-else:
- html_context = {
- 'css_files': [
- '//media.readthedocs.org/css/sphinx_rtd_theme.css',
- '//media.readthedocs.org/css/readthedocs-doc-embed.css',
- '_static/theme_overrides.css'
- ]
- }
-
-# Theme options are theme-specific and customize the look and feel of a theme
-# further. For a list of options available for each theme, see the
-# documentation.
-#html_theme_options = {}
-
-# Add any paths that contain custom themes here, relative to this directory.
-#html_theme_path = []
-
-# The name for this set of Sphinx documents. If None, it defaults to
-# "<project> v<release> documentation".
-#html_title = None
-
-# A shorter title for the navigation bar. Default is the same as html_title.
-#html_short_title = None
-
-# The name of an image file (relative to this directory) to place at the top
-# of the sidebar.
-#html_logo = None
-
-# The name of an image file (within the static path) to use as favicon of the
-# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
-# pixels large.
-#html_favicon = None
-
-# Add any paths that contain custom static files (such as style sheets) here,
-# relative to this directory. They are copied after the builtin static files,
-# so a file named "default.css" will overwrite the builtin "default.css".
-html_static_path = ['_static']
-
-# Add any extra paths that contain custom files (such as robots.txt or
-# .htaccess) here, relative to this directory. These files are copied
-# directly to the root of the documentation.
-#html_extra_path = []
-
-# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
-# using the given strftime format.
-#html_last_updated_fmt = '%b %d, %Y'
-
-# If true, SmartyPants will be used to convert quotes and dashes to
-# typographically correct entities.
-#html_use_smartypants = True
-
-# Custom sidebar templates, maps document names to template names.
-#html_sidebars = {}
-
-# Additional templates that should be rendered to pages, maps page names to
-# template names.
-#html_additional_pages = {}
-
-# If false, no module index is generated.
-#html_domain_indices = True
-
-# If false, no index is generated.
-#html_use_index = True
-
-# If true, the index is split into individual pages for each letter.
-#html_split_index = False
-
-# If true, links to the reST sources are added to the pages.
-#html_show_sourcelink = True
-
-# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
-#html_show_sphinx = True
-
-# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
-#html_show_copyright = True
-
-# If true, an OpenSearch description file will be output, and all pages will
-# contain a <link> tag referring to it. The value of this option must be the
-# base URL from which the finished HTML is served.
-#html_use_opensearch = ''
-
-# This is the file name suffix for HTML files (e.g. ".xhtml").
-#html_file_suffix = None
-
-# Language to be used for generating the HTML full-text search index.
-# Sphinx supports the following languages:
-# 'da', 'de', 'en', 'es', 'fi', 'fr', 'h', 'it', 'ja'
-# 'nl', 'no', 'pt', 'ro', 'r', 'sv', 'tr'
-#html_search_language = 'en'
-
-# A dictionary with options for the search language support, empty by default.
-# Now only 'ja' uses this config value
-#html_search_options = {'type': 'default'}
-
-# The name of a javascript file (relative to the configuration directory) that
-# implements a search results scorer. If empty, the default will be used.
-#html_search_scorer = 'scorer.js'
-
-# Output file base name for HTML help builder.
-htmlhelp_basename = 'pybind11doc'
-
-# -- Options for LaTeX output ---------------------------------------------
-
-latex_elements = {
-# The paper size ('letterpaper' or 'a4paper').
-#'papersize': 'letterpaper',
-
-# The font size ('10pt', '11pt' or '12pt').
-#'pointsize': '10pt',
-
-# Additional stuff for the LaTeX preamble.
-'preamble': '\DeclareUnicodeCharacter{00A0}{}',
-
-# Latex figure (float) alignment
-#'figure_align': 'htbp',
-}
-
-# Grouping the document tree into LaTeX files. List of tuples
-# (source start file, target name, title,
-# author, documentclass [howto, manual, or own class]).
-latex_documents = [
- (master_doc, 'pybind11.tex', 'pybind11 Documentation',
- 'Wenzel Jakob', 'manual'),
-]
-
-# The name of an image file (relative to this directory) to place at the top of
-# the title page.
-# latex_logo = 'pybind11-logo.png'
-
-# For "manual" documents, if this is true, then toplevel headings are parts,
-# not chapters.
-#latex_use_parts = False
-
-# If true, show page references after internal links.
-#latex_show_pagerefs = False
-
-# If true, show URL addresses after external links.
-#latex_show_urls = False
-
-# Documents to append as an appendix to all manuals.
-#latex_appendices = []
-
-# If false, no module index is generated.
-#latex_domain_indices = True
-
-
-# -- Options for manual page output ---------------------------------------
-
-# One entry per manual page. List of tuples
-# (source start file, name, description, authors, manual section).
-man_pages = [
- (master_doc, 'pybind11', 'pybind11 Documentation',
- [author], 1)
-]
-
-# If true, show URL addresses after external links.
-#man_show_urls = False
-
-
-# -- Options for Texinfo output -------------------------------------------
-
-# Grouping the document tree into Texinfo files. List of tuples
-# (source start file, target name, title, author,
-# dir menu entry, description, category)
-texinfo_documents = [
- (master_doc, 'pybind11', 'pybind11 Documentation',
- author, 'pybind11', 'One line description of project.',
- 'Miscellaneous'),
-]
-
-# Documents to append as an appendix to all manuals.
-#texinfo_appendices = []
-
-# If false, no module index is generated.
-#texinfo_domain_indices = True
-
-# How to display URL addresses: 'footnote', 'no', or 'inline'.
-#texinfo_show_urls = 'footnote'
-
-# If true, do not generate a @detailmenu in the "Top" node's menu.
-#texinfo_no_detailmenu = False
-
-primary_domain = 'cpp'
-highlight_language = 'cpp'
-
-
-def generate_doxygen_xml(app):
- build_dir = '.build'
- if not os.path.exists(build_dir):
- os.mkdir(build_dir)
-
- try:
- subprocess.call(['doxygen', '--version'])
- retcode = subprocess.call(['doxygen'])
- if retcode < 0:
- sys.stderr.write("doxygen error code: {}\n".format(-retcode))
- except OSError as e:
- sys.stderr.write("doxygen execution failed: {}\n".format(e))
-
-
-def setup(app):
- """Add hook for building doxygen xml when needed"""
- app.connect("builder-inited", generate_doxygen_xml)
diff --git a/thirdparty/pybind11/pybind11/docs/faq.rst b/thirdparty/pybind11/pybind11/docs/faq.rst
deleted file mode 100644
index 34002b42dc68d755c335851d83c1cd59d9b1c484..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/faq.rst
+++ /dev/null
@@ -1,253 +0,0 @@
-Frequently asked questions
-##########################
-
-"ImportError: dynamic module does not define init function"
-===========================================================
-
-1. Make sure that the name specified in ``pybind::module`` and
- ``PYBIND11_PLUGIN`` is consistent and identical to the filename of the
- extension library. The latter should not contain any extra prefixes (e.g.
- ``test.so`` instead of ``libtest.so``).
-
-2. If the above did not fix your issue, then you are likely using an
- incompatible version of Python (for instance, the extension library was
- compiled against Python 2, while the interpreter is running on top of some
- version of Python 3, or vice versa)
-
-"Symbol not found: ``__Py_ZeroStruct`` / ``_PyInstanceMethod_Type``"
-========================================================================
-
-See item 2 of the first answer.
-
-"SystemError: dynamic module not initialized properly"
-======================================================
-
-See item 2 of the first answer.
-
-The Python interpreter immediately crashes when importing my module
-===================================================================
-
-See item 2 of the first answer.
-
-CMake doesn't detect the right Python version
-=============================================
-
-The CMake-based build system will try to automatically detect the installed
-version of Python and link against that. When this fails, or when there are
-multiple versions of Python and it finds the wrong one, delete
-``CMakeCache.txt`` and then invoke CMake as follows:
-
-.. code-block:: bash
-
- cmake -DPYTHON_EXECUTABLE:FILEPATH=<path-to-python-executable> .
-
-Limitations involving reference arguments
-=========================================
-
-In C++, it's fairly common to pass arguments using mutable references or
-mutable pointers, which allows both read and write access to the value
-supplied by the caller. This is sometimes done for efficiency reasons, or to
-realize functions that have multiple return values. Here are two very basic
-examples:
-
-.. code-block:: cpp
-
- void increment(int &i) { i++; }
- void increment_ptr(int *i) { (*i)++; }
-
-In Python, all arguments are passed by reference, so there is no general
-issue in binding such code from Python.
-
-However, certain basic Python types (like ``str``, ``int``, ``bool``,
-``float``, etc.) are **immutable**. This means that the following attempt
-to port the function to Python doesn't have the same effect on the value
-provided by the caller -- in fact, it does nothing at all.
-
-.. code-block:: python
-
- def increment(i):
- i += 1 # nope..
-
-pybind11 is also affected by such language-level conventions, which means that
-binding ``increment`` or ``increment_ptr`` will also create Python functions
-that don't modify their arguments.
-
-Although inconvenient, one workaround is to encapsulate the immutable types in
-a custom type that does allow modifications.
-
-An other alternative involves binding a small wrapper lambda function that
-returns a tuple with all output arguments (see the remainder of the
-documentation for examples on binding lambda functions). An example:
-
-.. code-block:: cpp
-
- int foo(int &i) { i++; return 123; }
-
-and the binding code
-
-.. code-block:: cpp
-
- m.def("foo", [](int i) { int rv = foo(i); return std::make_tuple(rv, i); });
-
-
-How can I reduce the build time?
-================================
-
-It's good practice to split binding code over multiple files, as in the
-following example:
-
-:file:`example.cpp`:
-
-.. code-block:: cpp
-
- void init_ex1(py::module &);
- void init_ex2(py::module &);
- /* ... */
-
- PYBIND11_PLUGIN(example) {
- py::module m("example", "pybind example plugin");
-
- init_ex1(m);
- init_ex2(m);
- /* ... */
-
- return m.ptr();
- }
-
-:file:`ex1.cpp`:
-
-.. code-block:: cpp
-
- void init_ex1(py::module &m) {
- m.def("add", [](int a, int b) { return a + b; });
- }
-
-:file:`ex2.cpp`:
-
-.. code-block:: cpp
-
- void init_ex1(py::module &m) {
- m.def("sub", [](int a, int b) { return a - b; });
- }
-
-:command:`python`:
-
-.. code-block:: pycon
-
- >>> import example
- >>> example.add(1, 2)
- 3
- >>> example.sub(1, 1)
- 0
-
-As shown above, the various ``init_ex`` functions should be contained in
-separate files that can be compiled independently from one another, and then
-linked together into the same final shared object. Following this approach
-will:
-
-1. reduce memory requirements per compilation unit.
-
-2. enable parallel builds (if desired).
-
-3. allow for faster incremental builds. For instance, when a single class
- definition is changed, only a subset of the binding code will generally need
- to be recompiled.
-
-"recursive template instantiation exceeded maximum depth of 256"
-================================================================
-
-If you receive an error about excessive recursive template evaluation, try
-specifying a larger value, e.g. ``-ftemplate-depth=1024`` on GCC/Clang. The
-culprit is generally the generation of function signatures at compile time
-using C++14 template metaprogramming.
-
-
-.. _`faq:symhidden`:
-
-How can I create smaller binaries?
-==================================
-
-To do its job, pybind11 extensively relies on a programming technique known as
-*template metaprogramming*, which is a way of performing computation at compile
-time using type information. Template metaprogamming usually instantiates code
-involving significant numbers of deeply nested types that are either completely
-removed or reduced to just a few instructions during the compiler's optimization
-phase. However, due to the nested nature of these types, the resulting symbol
-names in the compiled extension library can be extremely long. For instance,
-the included test suite contains the following symbol:
-
-.. only:: html
-
- .. code-block:: none
-
- _​_​Z​N​8​p​y​b​i​n​d​1​1​1​2​c​p​p​_​f​u​n​c​t​i​o​n​C​1​I​v​8​E​x​a​m​p​l​e​2​J​R​N​S​t​3​_​_​1​6​v​e​c​t​o​r​I​N​S​3​_​1​2​b​a​s​i​c​_​s​t​r​i​n​g​I​w​N​S​3​_​1​1​c​h​a​r​_​t​r​a​i​t​s​I​w​E​E​N​S​3​_​9​a​l​l​o​c​a​t​o​r​I​w​E​E​E​E​N​S​8​_​I​S​A​_​E​E​E​E​E​J​N​S​_​4​n​a​m​e​E​N​S​_​7​s​i​b​l​i​n​g​E​N​S​_​9​i​s​_​m​e​t​h​o​d​E​A​2​8​_​c​E​E​E​M​T​0​_​F​T​_​D​p​T​1​_​E​D​p​R​K​T​2​_
-
-.. only:: not html
-
- .. code-block:: cpp
-
- __ZN8pybind1112cpp_functionC1Iv8Example2JRNSt3__16vectorINS3_12basic_stringIwNS3_11char_traitsIwEENS3_9allocatorIwEEEENS8_ISA_EEEEEJNS_4nameENS_7siblingENS_9is_methodEA28_cEEEMT0_FT_DpT1_EDpRKT2_
-
-which is the mangled form of the following function type:
-
-.. code-block:: cpp
-
- pybind11::cpp_function::cpp_function<void, Example2, std::__1::vector<std::__1::basic_string<wchar_t, std::__1::char_traits<wchar_t>, std::__1::allocator<wchar_t> >, std::__1::allocator<std::__1::basic_string<wchar_t, std::__1::char_traits<wchar_t>, std::__1::allocator<wchar_t> > > >&, pybind11::name, pybind11::sibling, pybind11::is_method, char [28]>(void (Example2::*)(std::__1::vector<std::__1::basic_string<wchar_t, std::__1::char_traits<wchar_t>, std::__1::allocator<wchar_t> >, std::__1::allocator<std::__1::basic_string<wchar_t, std::__1::char_traits<wchar_t>, std::__1::allocator<wchar_t> > > >&), pybind11::name const&, pybind11::sibling const&, pybind11::is_method const&, char const (&) [28])
-
-The memory needed to store just the mangled name of this function (196 bytes)
-is larger than the actual piece of code (111 bytes) it represents! On the other
-hand, it's silly to even give this function a name -- after all, it's just a
-tiny cog in a bigger piece of machinery that is not exposed to the outside
-world. So we'll generally only want to export symbols for those functions which
-are actually called from the outside.
-
-This can be achieved by specifying the parameter ``-fvisibility=hidden`` to GCC
-and Clang, which sets the default symbol visibility to *hidden*. It's best to
-do this only for release builds, since the symbol names can be helpful in
-debugging sessions. On Visual Studio, symbols are already hidden by default, so
-nothing needs to be done there. Needless to say, this has a tremendous impact
-on the final binary size of the resulting extension library.
-
-Another aspect that can require a fair bit of code are function signature
-descriptions. pybind11 automatically generates human-readable function
-signatures for docstrings, e.g.:
-
-.. code-block:: none
-
- | __init__(...)
- | __init__(*args, **kwargs)
- | Overloaded function.
- |
- | 1. __init__(example.Example1) -> NoneType
- |
- | Docstring for overload #1 goes here
- |
- | 2. __init__(example.Example1, int) -> NoneType
- |
- | Docstring for overload #2 goes here
- |
- | 3. __init__(example.Example1, example.Example1) -> NoneType
- |
- | Docstring for overload #3 goes here
-
-
-In C++11 mode, these are generated at run time using string concatenation,
-which can amount to 10-20% of the size of the resulting binary. If you can,
-enable C++14 language features (using ``-std=c++14`` for GCC/Clang), in which
-case signatures are efficiently pre-generated at compile time. Unfortunately,
-Visual Studio's C++14 support (``constexpr``) is not good enough as of April
-2016, so it always uses the more expensive run-time approach.
-
-Working with ancient Visual Studio 2009 builds on Windows
-=========================================================
-
-The official Windows distributions of Python are compiled using truly
-ancient versions of Visual Studio that lack good C++11 support. Some users
-implicitly assume that it would be impossible to load a plugin built with
-Visual Studio 2015 into a Python distribution that was compiled using Visual
-Studio 2009. However, no such issue exists: it's perfectly legitimate to
-interface DLLs that are built with different compilers and/or C libraries.
-Common gotchas to watch out for involve not ``free()``-ing memory region
-that that were ``malloc()``-ed in another shared library, using data
-structures with incompatible ABIs, and so on. pybind11 is very careful not
-to make these types of mistakes.
diff --git a/thirdparty/pybind11/pybind11/docs/index.rst b/thirdparty/pybind11/pybind11/docs/index.rst
deleted file mode 100644
index cedf65209da3eef89196750eb938f636b6da5165..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/index.rst
+++ /dev/null
@@ -1,45 +0,0 @@
-.. only: not latex
-
- .. image:: pybind11-logo.png
-
-pybind11 --- Seamless operability between C++11 and Python
-==========================================================
-
-.. only: not latex
-
- Contents:
-
-.. toctree::
- :maxdepth: 1
-
- intro
- changelog
-
-.. toctree::
- :caption: The Basics
- :maxdepth: 2
-
- basics
- classes
- compiling
-
-.. toctree::
- :caption: Advanced Topics
- :maxdepth: 2
-
- advanced/functions
- advanced/classes
- advanced/exceptions
- advanced/smart_ptrs
- advanced/cast/index
- advanced/pycpp/index
- advanced/misc
-
-.. toctree::
- :caption: Extra Information
- :maxdepth: 1
-
- faq
- benchmark
- limitations
- reference
diff --git a/thirdparty/pybind11/pybind11/docs/intro.rst b/thirdparty/pybind11/pybind11/docs/intro.rst
deleted file mode 100644
index 2149c18db88212a8a4489c6c0214c5b4c986a66b..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/intro.rst
+++ /dev/null
@@ -1,95 +0,0 @@
-.. image:: pybind11-logo.png
-
-About this project
-==================
-**pybind11** is a lightweight header-only library that exposes C++ types in Python
-and vice versa, mainly to create Python bindings of existing C++ code. Its
-goals and syntax are similar to the excellent `Boost.Python`_ library by David
-Abrahams: to minimize boilerplate code in traditional extension modules by
-inferring type information using compile-time introspection.
-
-.. _Boost.Python: http://www.boost.org/doc/libs/release/libs/python/doc/index.html
-
-The main issue with Boost.Python—and the reason for creating such a similar
-project—is Boost. Boost is an enormously large and complex suite of utility
-libraries that works with almost every C++ compiler in existence. This
-compatibility has its cost: arcane template tricks and workarounds are
-necessary to support the oldest and buggiest of compiler specimens. Now that
-C++11-compatible compilers are widely available, this heavy machinery has
-become an excessively large and unnecessary dependency.
-Think of this library as a tiny self-contained version of Boost.Python with
-everything stripped away that isn't relevant for binding generation. Without
-comments, the core header files only require ~4K lines of code and depend on
-Python (2.7 or 3.x, or PyPy2.7 >= 5.7) and the C++ standard library. This
-compact implementation was possible thanks to some of the new C++11 language
-features (specifically: tuples, lambda functions and variadic templates). Since
-its creation, this library has grown beyond Boost.Python in many ways, leading
-to dramatically simpler binding code in many common situations.
-
-Core features
-*************
-The following core C++ features can be mapped to Python
-
-- Functions accepting and returning custom data structures per value, reference, or pointer
-- Instance methods and static methods
-- Overloaded functions
-- Instance attributes and static attributes
-- Arbitrary exception types
-- Enumerations
-- Callbacks
-- Iterators and ranges
-- Custom operators
-- Single and multiple inheritance
-- STL data structures
-- Iterators and ranges
-- Smart pointers with reference counting like ``std::shared_ptr``
-- Internal references with correct reference counting
-- C++ classes with virtual (and pure virtual) methods can be extended in Python
-
-Goodies
-*******
-In addition to the core functionality, pybind11 provides some extra goodies:
-
-- Python 2.7, 3.x, and PyPy (PyPy2.7 >= 5.7) are supported with an
- implementation-agnostic interface.
-
-- It is possible to bind C++11 lambda functions with captured variables. The
- lambda capture data is stored inside the resulting Python function object.
-
-- pybind11 uses C++11 move constructors and move assignment operators whenever
- possible to efficiently transfer custom data types.
-
-- It's easy to expose the internal storage of custom data types through
- Pythons' buffer protocols. This is handy e.g. for fast conversion between
- C++ matrix classes like Eigen and NumPy without expensive copy operations.
-
-- pybind11 can automatically vectorize functions so that they are transparently
- applied to all entries of one or more NumPy array arguments.
-
-- Python's slice-based access and assignment operations can be supported with
- just a few lines of code.
-
-- Everything is contained in just a few header files; there is no need to link
- against any additional libraries.
-
-- Binaries are generally smaller by a factor of at least 2 compared to
- equivalent bindings generated by Boost.Python. A recent pybind11 conversion
- of `PyRosetta`_, an enormous Boost.Python binding project, reported a binary
- size reduction of **5.4x** and compile time reduction by **5.8x**.
-
-- When supported by the compiler, two new C++14 features (relaxed constexpr and
- return value deduction) are used to precompute function signatures at compile
- time, leading to smaller binaries.
-
-- With little extra effort, C++ types can be pickled and unpickled similar to
- regular Python objects.
-
-.. _PyRosetta: http://graylab.jhu.edu/RosettaCon2016/PyRosetta-4.pdf
-
-Supported compilers
-*******************
-
-1. Clang/LLVM (any non-ancient version with C++11 support)
-2. GCC 4.8 or newer
-3. Microsoft Visual Studio 2015 or newer
-4. Intel C++ compiler v15 or newer
diff --git a/thirdparty/pybind11/pybind11/docs/limitations.rst b/thirdparty/pybind11/pybind11/docs/limitations.rst
deleted file mode 100644
index a1a4f1affa2c9b993fe8749a102088171daa6e22..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/limitations.rst
+++ /dev/null
@@ -1,20 +0,0 @@
-Limitations
-###########
-
-pybind11 strives to be a general solution to binding generation, but it also has
-certain limitations:
-
-- pybind11 casts away ``const``-ness in function arguments and return values.
- This is in line with the Python language, which has no concept of ``const``
- values. This means that some additional care is needed to avoid bugs that
- would be caught by the type checker in a traditional C++ program.
-
-- The NumPy interface ``pybind11::array`` greatly simplifies accessing
- numerical data from C++ (and vice versa), but it's not a full-blown array
- class like ``Eigen::Array`` or ``boost.multi_array``.
-
-These features could be implemented but would lead to a significant increase in
-complexity. I've decided to draw the line here to keep this project simple and
-compact. Users who absolutely require these features are encouraged to fork
-pybind11.
-
diff --git a/thirdparty/pybind11/pybind11/docs/pybind11-logo.png b/thirdparty/pybind11/pybind11/docs/pybind11-logo.png
deleted file mode 100644
index 4cbad54f797d3ced04d4048f282df5e4336d4af4..0000000000000000000000000000000000000000
Binary files a/thirdparty/pybind11/pybind11/docs/pybind11-logo.png and /dev/null differ
diff --git a/thirdparty/pybind11/pybind11/docs/pybind11_vs_boost_python1.png b/thirdparty/pybind11/pybind11/docs/pybind11_vs_boost_python1.png
deleted file mode 100644
index 833231f240809884fb6eb4079db528b9b3c0a9ac..0000000000000000000000000000000000000000
Binary files a/thirdparty/pybind11/pybind11/docs/pybind11_vs_boost_python1.png and /dev/null differ
diff --git a/thirdparty/pybind11/pybind11/docs/pybind11_vs_boost_python1.svg b/thirdparty/pybind11/pybind11/docs/pybind11_vs_boost_python1.svg
deleted file mode 100644
index 5bf950e6fdc81676d9a9774926a623b4f6a2e2a8..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/pybind11_vs_boost_python1.svg
+++ /dev/null
@@ -1,427 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="468pt" height="252pt" viewBox="0 0 468 252" version="1.1">
-<defs>
-<g>
-<symbol overflow="visible" id="glyph0-0">
-<path style="stroke:none;" d=""/>
-</symbol>
-<symbol overflow="visible" id="glyph0-1">
-<path style="stroke:none;" d="M 3.726562 0 L 2.847656 0 L 2.847656 -5.601562 C 2.636719 -5.398438 2.359375 -5.195312 2.015625 -4.996094 C 1.671875 -4.792969 1.363281 -4.640625 1.089844 -4.539062 L 1.089844 -5.390625 C 1.582031 -5.621094 2.011719 -5.902344 2.378906 -6.230469 C 2.746094 -6.558594 3.007812 -6.878906 3.160156 -7.1875 L 3.726562 -7.1875 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-2">
-<path style="stroke:none;" d="M 0.414062 -3.53125 C 0.414062 -4.375 0.503906 -5.058594 0.675781 -5.574219 C 0.851562 -6.089844 1.109375 -6.488281 1.453125 -6.765625 C 1.796875 -7.046875 2.226562 -7.1875 2.75 -7.1875 C 3.132812 -7.1875 3.46875 -7.109375 3.757812 -6.957031 C 4.046875 -6.800781 4.289062 -6.578125 4.476562 -6.285156 C 4.664062 -5.996094 4.8125 -5.640625 4.921875 -5.222656 C 5.03125 -4.804688 5.082031 -4.238281 5.082031 -3.53125 C 5.082031 -2.691406 4.996094 -2.011719 4.824219 -1.496094 C 4.652344 -0.980469 4.394531 -0.582031 4.050781 -0.300781 C 3.707031 -0.0195312 3.273438 0.121094 2.75 0.121094 C 2.058594 0.121094 1.515625 -0.125 1.125 -0.621094 C 0.652344 -1.214844 0.414062 -2.1875 0.414062 -3.53125 Z M 1.320312 -3.53125 C 1.320312 -2.355469 1.457031 -1.574219 1.730469 -1.183594 C 2.007812 -0.796875 2.34375 -0.601562 2.75 -0.601562 C 3.152344 -0.601562 3.492188 -0.796875 3.765625 -1.1875 C 4.042969 -1.578125 4.179688 -2.359375 4.179688 -3.53125 C 4.179688 -4.710938 4.042969 -5.492188 3.765625 -5.878906 C 3.492188 -6.265625 3.148438 -6.460938 2.738281 -6.460938 C 2.335938 -6.460938 2.011719 -6.289062 1.773438 -5.945312 C 1.46875 -5.511719 1.320312 -4.707031 1.320312 -3.53125 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-3">
-<path style="stroke:none;" d="M 5.035156 -0.84375 L 5.035156 0 L 0.304688 0 C 0.296875 -0.210938 0.332031 -0.414062 0.40625 -0.609375 C 0.527344 -0.933594 0.71875 -1.25 0.984375 -1.5625 C 1.25 -1.875 1.632812 -2.234375 2.132812 -2.648438 C 2.910156 -3.285156 3.4375 -3.789062 3.710938 -4.164062 C 3.984375 -4.535156 4.121094 -4.886719 4.121094 -5.21875 C 4.121094 -5.566406 3.996094 -5.863281 3.746094 -6.101562 C 3.5 -6.339844 3.171875 -6.460938 2.773438 -6.460938 C 2.351562 -6.460938 2.011719 -6.332031 1.757812 -6.078125 C 1.503906 -5.824219 1.375 -5.472656 1.371094 -5.023438 L 0.46875 -5.117188 C 0.53125 -5.789062 0.761719 -6.304688 1.167969 -6.65625 C 1.570312 -7.011719 2.113281 -7.1875 2.792969 -7.1875 C 3.480469 -7.1875 4.023438 -6.996094 4.421875 -6.617188 C 4.824219 -6.234375 5.023438 -5.761719 5.023438 -5.199219 C 5.023438 -4.914062 4.964844 -4.632812 4.847656 -4.355469 C 4.730469 -4.078125 4.535156 -3.789062 4.265625 -3.480469 C 3.992188 -3.175781 3.542969 -2.753906 2.910156 -2.222656 C 2.382812 -1.78125 2.042969 -1.480469 1.894531 -1.320312 C 1.746094 -1.164062 1.621094 -1.003906 1.523438 -0.84375 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-4">
-<path style="stroke:none;" d="M 0.414062 -1.875 L 1.335938 -1.953125 C 1.40625 -1.503906 1.566406 -1.167969 1.8125 -0.941406 C 2.0625 -0.714844 2.363281 -0.601562 2.714844 -0.601562 C 3.136719 -0.601562 3.496094 -0.761719 3.789062 -1.078125 C 4.082031 -1.398438 4.226562 -1.820312 4.226562 -2.347656 C 4.226562 -2.851562 4.085938 -3.246094 3.804688 -3.535156 C 3.523438 -3.824219 3.15625 -3.96875 2.699219 -3.96875 C 2.417969 -3.96875 2.160156 -3.90625 1.933594 -3.777344 C 1.707031 -3.648438 1.527344 -3.480469 1.398438 -3.277344 L 0.570312 -3.382812 L 1.265625 -7.0625 L 4.824219 -7.0625 L 4.824219 -6.21875 L 1.96875 -6.21875 L 1.582031 -4.296875 C 2.011719 -4.597656 2.460938 -4.746094 2.933594 -4.746094 C 3.558594 -4.746094 4.085938 -4.53125 4.515625 -4.097656 C 4.945312 -3.664062 5.160156 -3.105469 5.160156 -2.425781 C 5.160156 -1.777344 4.972656 -1.21875 4.59375 -0.746094 C 4.136719 -0.167969 3.507812 0.121094 2.714844 0.121094 C 2.0625 0.121094 1.53125 -0.0585938 1.121094 -0.425781 C 0.710938 -0.789062 0.472656 -1.273438 0.414062 -1.875 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-5">
-<path style="stroke:none;" d="M 0.820312 0 L 0.820312 -7.15625 L 5.648438 -7.15625 L 5.648438 -6.3125 L 1.765625 -6.3125 L 1.765625 -4.097656 L 5.125 -4.097656 L 5.125 -3.25 L 1.765625 -3.25 L 1.765625 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-6">
-<path style="stroke:none;" d="M 4.058594 0 L 4.058594 -0.761719 C 3.65625 -0.175781 3.105469 0.117188 2.414062 0.117188 C 2.105469 0.117188 1.820312 0.0585938 1.554688 -0.0585938 C 1.289062 -0.175781 1.09375 -0.324219 0.964844 -0.5 C 0.835938 -0.679688 0.746094 -0.894531 0.695312 -1.152344 C 0.65625 -1.324219 0.640625 -1.597656 0.640625 -1.972656 L 0.640625 -5.1875 L 1.519531 -5.1875 L 1.519531 -2.308594 C 1.519531 -1.851562 1.535156 -1.542969 1.570312 -1.382812 C 1.625 -1.152344 1.746094 -0.96875 1.921875 -0.835938 C 2.101562 -0.703125 2.324219 -0.640625 2.585938 -0.640625 C 2.851562 -0.640625 3.097656 -0.707031 3.328125 -0.84375 C 3.5625 -0.976562 3.726562 -1.160156 3.820312 -1.394531 C 3.917969 -1.625 3.964844 -1.964844 3.964844 -2.40625 L 3.964844 -5.1875 L 4.84375 -5.1875 L 4.84375 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-7">
-<path style="stroke:none;" d="M 0.660156 0 L 0.660156 -5.1875 L 1.449219 -5.1875 L 1.449219 -4.449219 C 1.832031 -5.019531 2.382812 -5.304688 3.101562 -5.304688 C 3.414062 -5.304688 3.699219 -5.246094 3.960938 -5.132812 C 4.222656 -5.023438 4.421875 -4.875 4.550781 -4.691406 C 4.679688 -4.507812 4.773438 -4.292969 4.824219 -4.042969 C 4.855469 -3.878906 4.875 -3.59375 4.875 -3.1875 L 4.875 0 L 3.992188 0 L 3.992188 -3.15625 C 3.992188 -3.511719 3.960938 -3.78125 3.890625 -3.957031 C 3.824219 -4.132812 3.703125 -4.277344 3.527344 -4.382812 C 3.351562 -4.488281 3.148438 -4.539062 2.914062 -4.539062 C 2.539062 -4.539062 2.21875 -4.421875 1.945312 -4.183594 C 1.671875 -3.945312 1.539062 -3.496094 1.539062 -2.832031 L 1.539062 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-8">
-<path style="stroke:none;" d="M 4.042969 -1.898438 L 4.90625 -1.789062 C 4.8125 -1.191406 4.570312 -0.726562 4.183594 -0.386719 C 3.792969 -0.0507812 3.316406 0.117188 2.75 0.117188 C 2.039062 0.117188 1.46875 -0.113281 1.039062 -0.578125 C 0.605469 -1.042969 0.390625 -1.707031 0.390625 -2.574219 C 0.390625 -3.132812 0.484375 -3.625 0.667969 -4.042969 C 0.855469 -4.460938 1.136719 -4.777344 1.515625 -4.988281 C 1.894531 -5.199219 2.308594 -5.304688 2.753906 -5.304688 C 3.316406 -5.304688 3.777344 -5.160156 4.136719 -4.875 C 4.492188 -4.589844 4.722656 -4.1875 4.824219 -3.664062 L 3.96875 -3.53125 C 3.886719 -3.878906 3.746094 -4.140625 3.539062 -4.316406 C 3.332031 -4.492188 3.082031 -4.578125 2.789062 -4.578125 C 2.34375 -4.578125 1.984375 -4.421875 1.710938 -4.105469 C 1.433594 -3.789062 1.292969 -3.285156 1.292969 -2.597656 C 1.292969 -1.902344 1.425781 -1.394531 1.695312 -1.078125 C 1.960938 -0.761719 2.308594 -0.605469 2.738281 -0.605469 C 3.085938 -0.605469 3.371094 -0.710938 3.601562 -0.921875 C 3.835938 -1.132812 3.980469 -1.460938 4.042969 -1.898438 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-9">
-<path style="stroke:none;" d="M 2.578125 -0.785156 L 2.703125 -0.0078125 C 2.457031 0.0429688 2.234375 0.0703125 2.039062 0.0703125 C 1.722656 0.0703125 1.476562 0.0195312 1.296875 -0.0820312 C 1.121094 -0.183594 1 -0.316406 0.929688 -0.480469 C 0.855469 -0.644531 0.820312 -0.992188 0.820312 -1.519531 L 0.820312 -4.5 L 0.175781 -4.5 L 0.175781 -5.1875 L 0.820312 -5.1875 L 0.820312 -6.46875 L 1.695312 -6.996094 L 1.695312 -5.1875 L 2.578125 -5.1875 L 2.578125 -4.5 L 1.695312 -4.5 L 1.695312 -1.46875 C 1.695312 -1.21875 1.710938 -1.058594 1.742188 -0.984375 C 1.773438 -0.914062 1.820312 -0.859375 1.890625 -0.816406 C 1.960938 -0.773438 2.0625 -0.75 2.191406 -0.75 C 2.289062 -0.75 2.417969 -0.761719 2.578125 -0.785156 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-10">
-<path style="stroke:none;" d="M 0.664062 -6.148438 L 0.664062 -7.15625 L 1.542969 -7.15625 L 1.542969 -6.148438 Z M 0.664062 0 L 0.664062 -5.1875 L 1.542969 -5.1875 L 1.542969 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-11">
-<path style="stroke:none;" d="M 0.332031 -2.59375 C 0.332031 -3.554688 0.597656 -4.265625 1.132812 -4.726562 C 1.578125 -5.109375 2.121094 -5.304688 2.765625 -5.304688 C 3.476562 -5.304688 4.058594 -5.070312 4.511719 -4.601562 C 4.964844 -4.132812 5.191406 -3.488281 5.191406 -2.664062 C 5.191406 -2 5.089844 -1.472656 4.890625 -1.089844 C 4.691406 -0.707031 4.398438 -0.410156 4.015625 -0.199219 C 3.632812 0.0117188 3.214844 0.117188 2.765625 0.117188 C 2.039062 0.117188 1.449219 -0.117188 1.003906 -0.582031 C 0.554688 -1.046875 0.332031 -1.71875 0.332031 -2.59375 Z M 1.234375 -2.59375 C 1.234375 -1.929688 1.378906 -1.429688 1.671875 -1.101562 C 1.960938 -0.769531 2.324219 -0.605469 2.765625 -0.605469 C 3.199219 -0.605469 3.5625 -0.773438 3.851562 -1.101562 C 4.140625 -1.433594 4.289062 -1.941406 4.289062 -2.621094 C 4.289062 -3.261719 4.140625 -3.75 3.851562 -4.078125 C 3.558594 -4.410156 3.195312 -4.574219 2.765625 -4.574219 C 2.324219 -4.574219 1.960938 -4.410156 1.671875 -4.082031 C 1.382812 -3.753906 1.234375 -3.257812 1.234375 -2.59375 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-12">
-<path style="stroke:none;" d="M 0.308594 -1.546875 L 1.175781 -1.683594 C 1.226562 -1.335938 1.363281 -1.070312 1.585938 -0.882812 C 1.808594 -0.699219 2.117188 -0.605469 2.519531 -0.605469 C 2.921875 -0.605469 3.222656 -0.6875 3.417969 -0.851562 C 3.613281 -1.015625 3.710938 -1.210938 3.710938 -1.429688 C 3.710938 -1.628906 3.625 -1.785156 3.453125 -1.898438 C 3.332031 -1.976562 3.03125 -2.078125 2.554688 -2.195312 C 1.910156 -2.359375 1.460938 -2.5 1.214844 -2.621094 C 0.964844 -2.738281 0.777344 -2.902344 0.648438 -3.113281 C 0.519531 -3.324219 0.453125 -3.554688 0.453125 -3.808594 C 0.453125 -4.039062 0.507812 -4.253906 0.613281 -4.449219 C 0.71875 -4.648438 0.863281 -4.8125 1.046875 -4.941406 C 1.183594 -5.042969 1.367188 -5.128906 1.605469 -5.199219 C 1.839844 -5.269531 2.09375 -5.304688 2.363281 -5.304688 C 2.769531 -5.304688 3.128906 -5.242188 3.433594 -5.125 C 3.742188 -5.007812 3.96875 -4.851562 4.117188 -4.652344 C 4.261719 -4.453125 4.363281 -4.183594 4.417969 -3.847656 L 3.558594 -3.730469 C 3.519531 -3.996094 3.40625 -4.207031 3.21875 -4.355469 C 3.03125 -4.503906 2.769531 -4.578125 2.425781 -4.578125 C 2.023438 -4.578125 1.734375 -4.511719 1.5625 -4.378906 C 1.390625 -4.246094 1.304688 -4.089844 1.304688 -3.910156 C 1.304688 -3.796875 1.339844 -3.695312 1.410156 -3.601562 C 1.484375 -3.507812 1.59375 -3.429688 1.75 -3.367188 C 1.835938 -3.335938 2.09375 -3.261719 2.523438 -3.144531 C 3.144531 -2.976562 3.578125 -2.84375 3.824219 -2.738281 C 4.070312 -2.632812 4.265625 -2.476562 4.40625 -2.273438 C 4.546875 -2.074219 4.613281 -1.824219 4.613281 -1.523438 C 4.613281 -1.230469 4.527344 -0.953125 4.359375 -0.695312 C 4.1875 -0.4375 3.941406 -0.238281 3.617188 -0.09375 C 3.296875 0.046875 2.929688 0.117188 2.523438 0.117188 C 1.851562 0.117188 1.335938 -0.0234375 0.984375 -0.304688 C 0.632812 -0.582031 0.40625 -0.996094 0.308594 -1.546875 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph1-0">
-<path style="stroke:none;" d=""/>
-</symbol>
-<symbol overflow="visible" id="glyph1-1">
-<path style="stroke:none;" d="M -2.300781 -0.449219 L -2.378906 -1.34375 C -2.019531 -1.386719 -1.726562 -1.484375 -1.496094 -1.636719 C -1.265625 -1.792969 -1.082031 -2.03125 -0.941406 -2.359375 C -0.796875 -2.683594 -0.726562 -3.050781 -0.726562 -3.457031 C -0.726562 -3.820312 -0.78125 -4.136719 -0.890625 -4.414062 C -0.996094 -4.691406 -1.144531 -4.898438 -1.332031 -5.03125 C -1.519531 -5.167969 -1.722656 -5.234375 -1.945312 -5.234375 C -2.167969 -5.234375 -2.363281 -5.167969 -2.53125 -5.039062 C -2.699219 -4.910156 -2.839844 -4.695312 -2.953125 -4.394531 C -3.027344 -4.203125 -3.144531 -3.777344 -3.304688 -3.121094 C -3.460938 -2.460938 -3.609375 -2 -3.75 -1.738281 C -3.929688 -1.398438 -4.152344 -1.140625 -4.417969 -0.972656 C -4.683594 -0.804688 -4.980469 -0.722656 -5.308594 -0.722656 C -5.667969 -0.722656 -6.007812 -0.824219 -6.320312 -1.03125 C -6.632812 -1.234375 -6.875 -1.535156 -7.035156 -1.929688 C -7.199219 -2.324219 -7.28125 -2.761719 -7.28125 -3.242188 C -7.28125 -3.773438 -7.195312 -4.242188 -7.023438 -4.644531 C -6.851562 -5.050781 -6.601562 -5.363281 -6.269531 -5.582031 C -5.9375 -5.800781 -5.5625 -5.917969 -5.140625 -5.933594 L -5.074219 -5.023438 C -5.527344 -4.976562 -5.867188 -4.808594 -6.097656 -4.527344 C -6.328125 -4.246094 -6.445312 -3.832031 -6.445312 -3.28125 C -6.445312 -2.707031 -6.339844 -2.289062 -6.128906 -2.027344 C -5.921875 -1.765625 -5.667969 -1.636719 -5.371094 -1.636719 C -5.113281 -1.636719 -4.902344 -1.726562 -4.734375 -1.914062 C -4.570312 -2.097656 -4.398438 -2.574219 -4.226562 -3.34375 C -4.050781 -4.113281 -3.898438 -4.640625 -3.769531 -4.925781 C -3.578125 -5.34375 -3.335938 -5.652344 -3.039062 -5.851562 C -2.746094 -6.046875 -2.40625 -6.148438 -2.023438 -6.148438 C -1.640625 -6.148438 -1.28125 -6.039062 -0.945312 -5.820312 C -0.609375 -5.601562 -0.347656 -5.289062 -0.160156 -4.878906 C 0.0273438 -4.472656 0.121094 -4.011719 0.121094 -3.5 C 0.121094 -2.851562 0.0273438 -2.308594 -0.160156 -1.871094 C -0.351562 -1.433594 -0.632812 -1.089844 -1.011719 -0.84375 C -1.390625 -0.59375 -1.820312 -0.460938 -2.300781 -0.449219 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph1-2">
-<path style="stroke:none;" d="M -1.671875 -4.210938 L -1.558594 -5.117188 C -1.027344 -4.972656 -0.617188 -4.707031 -0.320312 -4.320312 C -0.0273438 -3.933594 0.117188 -3.4375 0.117188 -2.835938 C 0.117188 -2.078125 -0.117188 -1.476562 -0.582031 -1.03125 C -1.050781 -0.585938 -1.707031 -0.367188 -2.546875 -0.367188 C -3.421875 -0.367188 -4.097656 -0.589844 -4.578125 -1.039062 C -5.0625 -1.488281 -5.304688 -2.070312 -5.304688 -2.789062 C -5.304688 -3.480469 -5.066406 -4.046875 -4.59375 -4.488281 C -4.121094 -4.925781 -3.457031 -5.148438 -2.601562 -5.148438 C -2.550781 -5.148438 -2.472656 -5.144531 -2.367188 -5.140625 L -2.367188 -1.273438 C -1.796875 -1.304688 -1.363281 -1.46875 -1.058594 -1.757812 C -0.757812 -2.046875 -0.605469 -2.410156 -0.605469 -2.84375 C -0.605469 -3.164062 -0.691406 -3.4375 -0.859375 -3.667969 C -1.027344 -3.894531 -1.296875 -4.074219 -1.671875 -4.210938 Z M -3.089844 -1.324219 L -3.089844 -4.21875 C -3.527344 -4.179688 -3.855469 -4.070312 -4.070312 -3.886719 C -4.410156 -3.605469 -4.578125 -3.242188 -4.578125 -2.796875 C -4.578125 -2.394531 -4.445312 -2.054688 -4.175781 -1.78125 C -3.90625 -1.503906 -3.542969 -1.351562 -3.089844 -1.324219 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph1-3">
-<path style="stroke:none;" d="M -1.898438 -4.042969 L -1.789062 -4.90625 C -1.191406 -4.8125 -0.726562 -4.570312 -0.386719 -4.183594 C -0.0507812 -3.792969 0.117188 -3.316406 0.117188 -2.75 C 0.117188 -2.039062 -0.113281 -1.46875 -0.578125 -1.039062 C -1.042969 -0.605469 -1.707031 -0.390625 -2.574219 -0.390625 C -3.132812 -0.390625 -3.625 -0.484375 -4.042969 -0.667969 C -4.460938 -0.855469 -4.777344 -1.136719 -4.988281 -1.515625 C -5.199219 -1.894531 -5.304688 -2.308594 -5.304688 -2.753906 C -5.304688 -3.316406 -5.160156 -3.777344 -4.875 -4.136719 C -4.589844 -4.492188 -4.1875 -4.722656 -3.664062 -4.824219 L -3.53125 -3.96875 C -3.878906 -3.886719 -4.140625 -3.746094 -4.316406 -3.539062 C -4.492188 -3.332031 -4.578125 -3.082031 -4.578125 -2.789062 C -4.578125 -2.34375 -4.421875 -1.984375 -4.105469 -1.710938 C -3.789062 -1.433594 -3.285156 -1.292969 -2.597656 -1.292969 C -1.902344 -1.292969 -1.394531 -1.425781 -1.078125 -1.695312 C -0.761719 -1.960938 -0.605469 -2.308594 -0.605469 -2.738281 C -0.605469 -3.085938 -0.710938 -3.371094 -0.921875 -3.601562 C -1.132812 -3.835938 -1.460938 -3.980469 -1.898438 -4.042969 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph1-4">
-<path style="stroke:none;" d="M -2.59375 -0.332031 C -3.554688 -0.332031 -4.265625 -0.597656 -4.726562 -1.132812 C -5.109375 -1.578125 -5.304688 -2.121094 -5.304688 -2.765625 C -5.304688 -3.476562 -5.070312 -4.058594 -4.601562 -4.511719 C -4.132812 -4.964844 -3.488281 -5.191406 -2.664062 -5.191406 C -2 -5.191406 -1.472656 -5.089844 -1.089844 -4.890625 C -0.707031 -4.691406 -0.410156 -4.398438 -0.199219 -4.015625 C 0.0117188 -3.632812 0.117188 -3.214844 0.117188 -2.765625 C 0.117188 -2.039062 -0.117188 -1.449219 -0.582031 -1.003906 C -1.046875 -0.554688 -1.71875 -0.332031 -2.59375 -0.332031 Z M -2.59375 -1.234375 C -1.929688 -1.234375 -1.429688 -1.378906 -1.101562 -1.671875 C -0.769531 -1.960938 -0.605469 -2.324219 -0.605469 -2.765625 C -0.605469 -3.199219 -0.773438 -3.5625 -1.101562 -3.851562 C -1.433594 -4.140625 -1.941406 -4.289062 -2.621094 -4.289062 C -3.261719 -4.289062 -3.75 -4.140625 -4.078125 -3.851562 C -4.410156 -3.558594 -4.574219 -3.195312 -4.574219 -2.765625 C -4.574219 -2.324219 -4.410156 -1.960938 -4.082031 -1.671875 C -3.753906 -1.382812 -3.257812 -1.234375 -2.59375 -1.234375 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph1-5">
-<path style="stroke:none;" d="M 0 -0.660156 L -5.1875 -0.660156 L -5.1875 -1.449219 L -4.449219 -1.449219 C -5.019531 -1.832031 -5.304688 -2.382812 -5.304688 -3.101562 C -5.304688 -3.414062 -5.246094 -3.699219 -5.132812 -3.960938 C -5.023438 -4.222656 -4.875 -4.421875 -4.691406 -4.550781 C -4.507812 -4.679688 -4.292969 -4.773438 -4.042969 -4.824219 C -3.878906 -4.855469 -3.59375 -4.875 -3.1875 -4.875 L 0 -4.875 L 0 -3.992188 L -3.15625 -3.992188 C -3.511719 -3.992188 -3.78125 -3.960938 -3.957031 -3.890625 C -4.132812 -3.824219 -4.277344 -3.703125 -4.382812 -3.527344 C -4.488281 -3.351562 -4.539062 -3.148438 -4.539062 -2.914062 C -4.539062 -2.539062 -4.421875 -2.21875 -4.183594 -1.945312 C -3.945312 -1.671875 -3.496094 -1.539062 -2.832031 -1.539062 L 0 -1.539062 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph1-6">
-<path style="stroke:none;" d="M 0 -4.023438 L -0.65625 -4.023438 C -0.140625 -3.695312 0.117188 -3.210938 0.117188 -2.574219 C 0.117188 -2.160156 0.00390625 -1.78125 -0.226562 -1.433594 C -0.453125 -1.085938 -0.769531 -0.816406 -1.179688 -0.628906 C -1.585938 -0.4375 -2.058594 -0.34375 -2.585938 -0.34375 C -3.105469 -0.34375 -3.574219 -0.429688 -3.996094 -0.601562 C -4.417969 -0.773438 -4.742188 -1.03125 -4.964844 -1.375 C -5.191406 -1.722656 -5.304688 -2.109375 -5.304688 -2.535156 C -5.304688 -2.847656 -5.238281 -3.125 -5.105469 -3.367188 C -4.972656 -3.613281 -4.800781 -3.8125 -4.589844 -3.964844 L -7.15625 -3.964844 L -7.15625 -4.839844 L 0 -4.839844 Z M -2.585938 -1.246094 C -1.921875 -1.246094 -1.425781 -1.386719 -1.097656 -1.664062 C -0.769531 -1.945312 -0.605469 -2.273438 -0.605469 -2.65625 C -0.605469 -3.039062 -0.761719 -3.367188 -1.078125 -3.636719 C -1.390625 -3.90625 -1.871094 -4.039062 -2.515625 -4.039062 C -3.226562 -4.039062 -3.746094 -3.902344 -4.078125 -3.628906 C -4.410156 -3.355469 -4.574219 -3.015625 -4.574219 -2.617188 C -4.574219 -2.226562 -4.414062 -1.898438 -4.097656 -1.636719 C -3.777344 -1.375 -3.273438 -1.246094 -2.585938 -1.246094 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph1-7">
-<path style="stroke:none;" d="M -1.546875 -0.308594 L -1.683594 -1.175781 C -1.335938 -1.226562 -1.070312 -1.363281 -0.882812 -1.585938 C -0.699219 -1.808594 -0.605469 -2.117188 -0.605469 -2.519531 C -0.605469 -2.921875 -0.6875 -3.222656 -0.851562 -3.417969 C -1.015625 -3.613281 -1.210938 -3.710938 -1.429688 -3.710938 C -1.628906 -3.710938 -1.785156 -3.625 -1.898438 -3.453125 C -1.976562 -3.332031 -2.078125 -3.03125 -2.195312 -2.554688 C -2.359375 -1.910156 -2.5 -1.460938 -2.621094 -1.214844 C -2.738281 -0.964844 -2.902344 -0.777344 -3.113281 -0.648438 C -3.324219 -0.519531 -3.554688 -0.453125 -3.808594 -0.453125 C -4.039062 -0.453125 -4.253906 -0.507812 -4.449219 -0.613281 C -4.648438 -0.71875 -4.8125 -0.863281 -4.941406 -1.046875 C -5.042969 -1.183594 -5.128906 -1.367188 -5.199219 -1.605469 C -5.269531 -1.839844 -5.304688 -2.09375 -5.304688 -2.363281 C -5.304688 -2.769531 -5.242188 -3.128906 -5.125 -3.433594 C -5.007812 -3.742188 -4.851562 -3.96875 -4.652344 -4.117188 C -4.453125 -4.261719 -4.183594 -4.363281 -3.847656 -4.417969 L -3.730469 -3.558594 C -3.996094 -3.519531 -4.207031 -3.40625 -4.355469 -3.21875 C -4.503906 -3.03125 -4.578125 -2.769531 -4.578125 -2.425781 C -4.578125 -2.023438 -4.511719 -1.734375 -4.378906 -1.5625 C -4.246094 -1.390625 -4.089844 -1.304688 -3.910156 -1.304688 C -3.796875 -1.304688 -3.695312 -1.339844 -3.601562 -1.410156 C -3.507812 -1.484375 -3.429688 -1.59375 -3.367188 -1.75 C -3.335938 -1.835938 -3.261719 -2.09375 -3.144531 -2.523438 C -2.976562 -3.144531 -2.84375 -3.578125 -2.738281 -3.824219 C -2.632812 -4.070312 -2.476562 -4.265625 -2.273438 -4.40625 C -2.074219 -4.546875 -1.824219 -4.613281 -1.523438 -4.613281 C -1.230469 -4.613281 -0.953125 -4.527344 -0.695312 -4.359375 C -0.4375 -4.1875 -0.238281 -3.941406 -0.09375 -3.617188 C 0.046875 -3.296875 0.117188 -2.929688 0.117188 -2.523438 C 0.117188 -1.851562 -0.0234375 -1.335938 -0.304688 -0.984375 C -0.582031 -0.632812 -0.996094 -0.40625 -1.546875 -0.308594 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-0">
-<path style="stroke:none;" d=""/>
-</symbol>
-<symbol overflow="visible" id="glyph2-1">
-<path style="stroke:none;" d="M 7.054688 -3.011719 L 8.191406 -2.726562 C 7.953125 -1.792969 7.523438 -1.078125 6.90625 -0.589844 C 6.285156 -0.0976562 5.53125 0.148438 4.632812 0.148438 C 3.707031 0.148438 2.957031 -0.0429688 2.375 -0.417969 C 1.796875 -0.796875 1.355469 -1.34375 1.050781 -2.054688 C 0.75 -2.769531 0.597656 -3.539062 0.597656 -4.359375 C 0.597656 -5.253906 0.769531 -6.035156 1.109375 -6.699219 C 1.453125 -7.367188 1.9375 -7.871094 2.570312 -8.21875 C 3.199219 -8.5625 3.894531 -8.734375 4.652344 -8.734375 C 5.511719 -8.734375 6.234375 -8.515625 6.820312 -8.078125 C 7.40625 -7.640625 7.8125 -7.027344 8.046875 -6.234375 L 6.925781 -5.96875 C 6.726562 -6.59375 6.4375 -7.050781 6.058594 -7.335938 C 5.679688 -7.621094 5.203125 -7.765625 4.628906 -7.765625 C 3.96875 -7.765625 3.417969 -7.605469 2.972656 -7.289062 C 2.53125 -6.972656 2.21875 -6.546875 2.039062 -6.015625 C 1.859375 -5.480469 1.769531 -4.929688 1.769531 -4.367188 C 1.769531 -3.636719 1.875 -2.996094 2.089844 -2.453125 C 2.300781 -1.90625 2.632812 -1.5 3.082031 -1.230469 C 3.53125 -0.960938 4.015625 -0.828125 4.539062 -0.828125 C 5.175781 -0.828125 5.71875 -1.007812 6.15625 -1.375 C 6.597656 -1.742188 6.898438 -2.289062 7.054688 -3.011719 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-2">
-<path style="stroke:none;" d="M 0.398438 -3.109375 C 0.398438 -4.261719 0.71875 -5.117188 1.359375 -5.671875 C 1.894531 -6.132812 2.546875 -6.363281 3.316406 -6.363281 C 4.171875 -6.363281 4.871094 -6.082031 5.414062 -5.523438 C 5.957031 -4.960938 6.226562 -4.1875 6.226562 -3.199219 C 6.226562 -2.398438 6.109375 -1.769531 5.867188 -1.308594 C 5.628906 -0.851562 5.277344 -0.492188 4.820312 -0.242188 C 4.359375 0.0117188 3.859375 0.140625 3.316406 0.140625 C 2.445312 0.140625 1.742188 -0.140625 1.203125 -0.695312 C 0.667969 -1.253906 0.398438 -2.0625 0.398438 -3.109375 Z M 1.484375 -3.109375 C 1.484375 -2.3125 1.65625 -1.71875 2.003906 -1.320312 C 2.351562 -0.925781 2.789062 -0.726562 3.316406 -0.726562 C 3.839844 -0.726562 4.273438 -0.925781 4.625 -1.324219 C 4.972656 -1.722656 5.144531 -2.328125 5.144531 -3.148438 C 5.144531 -3.917969 4.96875 -4.5 4.621094 -4.894531 C 4.269531 -5.292969 3.835938 -5.492188 3.316406 -5.492188 C 2.789062 -5.492188 2.351562 -5.292969 2.003906 -4.898438 C 1.65625 -4.503906 1.484375 -3.90625 1.484375 -3.109375 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-3">
-<path style="stroke:none;" d="M 0.789062 0 L 0.789062 -6.222656 L 1.734375 -6.222656 L 1.734375 -5.351562 C 1.929688 -5.65625 2.1875 -5.898438 2.515625 -6.085938 C 2.839844 -6.269531 3.207031 -6.363281 3.621094 -6.363281 C 4.082031 -6.363281 4.460938 -6.265625 4.753906 -6.078125 C 5.050781 -5.886719 5.257812 -5.617188 5.378906 -5.273438 C 5.871094 -6 6.511719 -6.363281 7.300781 -6.363281 C 7.917969 -6.363281 8.390625 -6.191406 8.726562 -5.851562 C 9.058594 -5.507812 9.222656 -4.984375 9.222656 -4.273438 L 9.222656 0 L 8.171875 0 L 8.171875 -3.921875 C 8.171875 -4.34375 8.140625 -4.644531 8.070312 -4.832031 C 8.003906 -5.015625 7.878906 -5.164062 7.699219 -5.28125 C 7.519531 -5.394531 7.308594 -5.449219 7.066406 -5.449219 C 6.628906 -5.449219 6.265625 -5.304688 5.976562 -5.011719 C 5.6875 -4.722656 5.542969 -4.257812 5.542969 -3.617188 L 5.542969 0 L 4.488281 0 L 4.488281 -4.042969 C 4.488281 -4.511719 4.402344 -4.863281 4.230469 -5.097656 C 4.058594 -5.332031 3.777344 -5.449219 3.386719 -5.449219 C 3.089844 -5.449219 2.816406 -5.371094 2.5625 -5.214844 C 2.3125 -5.058594 2.128906 -4.828125 2.015625 -4.53125 C 1.902344 -4.230469 1.84375 -3.796875 1.84375 -3.226562 L 1.84375 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-4">
-<path style="stroke:none;" d="M 0.789062 2.382812 L 0.789062 -6.222656 L 1.75 -6.222656 L 1.75 -5.414062 C 1.976562 -5.730469 2.234375 -5.96875 2.519531 -6.125 C 2.804688 -6.285156 3.148438 -6.363281 3.554688 -6.363281 C 4.085938 -6.363281 4.554688 -6.226562 4.960938 -5.953125 C 5.367188 -5.679688 5.675781 -5.292969 5.882812 -4.796875 C 6.089844 -4.296875 6.195312 -3.75 6.195312 -3.15625 C 6.195312 -2.519531 6.078125 -1.949219 5.851562 -1.4375 C 5.621094 -0.929688 5.289062 -0.539062 4.855469 -0.265625 C 4.417969 0.00390625 3.960938 0.140625 3.480469 0.140625 C 3.128906 0.140625 2.8125 0.0664062 2.535156 -0.0820312 C 2.253906 -0.230469 2.023438 -0.417969 1.84375 -0.644531 L 1.84375 2.382812 Z M 1.746094 -3.078125 C 1.746094 -2.277344 1.90625 -1.683594 2.234375 -1.300781 C 2.558594 -0.917969 2.949219 -0.726562 3.410156 -0.726562 C 3.878906 -0.726562 4.28125 -0.925781 4.613281 -1.320312 C 4.949219 -1.71875 5.117188 -2.332031 5.117188 -3.164062 C 5.117188 -3.957031 4.953125 -4.550781 4.625 -4.945312 C 4.300781 -5.339844 3.910156 -5.539062 3.457031 -5.539062 C 3.007812 -5.539062 2.609375 -5.328125 2.265625 -4.90625 C 1.917969 -4.488281 1.746094 -3.875 1.746094 -3.078125 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-5">
-<path style="stroke:none;" d="M 0.796875 -7.375 L 0.796875 -8.589844 L 1.851562 -8.589844 L 1.851562 -7.375 Z M 0.796875 0 L 0.796875 -6.222656 L 1.851562 -6.222656 L 1.851562 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-6">
-<path style="stroke:none;" d="M 0.765625 0 L 0.765625 -8.589844 L 1.820312 -8.589844 L 1.820312 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-7">
-<path style="stroke:none;" d="M 4.851562 -0.765625 C 4.460938 -0.433594 4.085938 -0.203125 3.722656 -0.0625 C 3.363281 0.0742188 2.976562 0.140625 2.5625 0.140625 C 1.878906 0.140625 1.351562 -0.0273438 0.984375 -0.359375 C 0.617188 -0.695312 0.433594 -1.121094 0.433594 -1.640625 C 0.433594 -1.945312 0.503906 -2.222656 0.640625 -2.476562 C 0.78125 -2.726562 0.960938 -2.929688 1.1875 -3.082031 C 1.410156 -3.234375 1.664062 -3.351562 1.945312 -3.429688 C 2.152344 -3.484375 2.464844 -3.535156 2.882812 -3.585938 C 3.734375 -3.6875 4.359375 -3.808594 4.765625 -3.949219 C 4.769531 -4.09375 4.769531 -4.1875 4.769531 -4.226562 C 4.769531 -4.65625 4.671875 -4.957031 4.46875 -5.132812 C 4.199219 -5.371094 3.800781 -5.492188 3.269531 -5.492188 C 2.773438 -5.492188 2.40625 -5.402344 2.171875 -5.230469 C 1.933594 -5.054688 1.757812 -4.75 1.648438 -4.304688 L 0.617188 -4.445312 C 0.710938 -4.886719 0.863281 -5.246094 1.078125 -5.515625 C 1.292969 -5.789062 1.601562 -5.996094 2.007812 -6.144531 C 2.414062 -6.289062 2.886719 -6.363281 3.421875 -6.363281 C 3.953125 -6.363281 4.382812 -6.300781 4.71875 -6.175781 C 5.050781 -6.050781 5.292969 -5.894531 5.449219 -5.703125 C 5.605469 -5.515625 5.714844 -5.273438 5.777344 -4.984375 C 5.8125 -4.804688 5.828125 -4.484375 5.828125 -4.015625 L 5.828125 -2.609375 C 5.828125 -1.628906 5.851562 -1.007812 5.898438 -0.746094 C 5.941406 -0.488281 6.03125 -0.238281 6.164062 0 L 5.0625 0 C 4.953125 -0.21875 4.882812 -0.476562 4.851562 -0.765625 Z M 4.765625 -3.125 C 4.382812 -2.96875 3.804688 -2.835938 3.039062 -2.726562 C 2.605469 -2.664062 2.300781 -2.59375 2.121094 -2.515625 C 1.941406 -2.4375 1.804688 -2.320312 1.703125 -2.171875 C 1.605469 -2.019531 1.558594 -1.851562 1.558594 -1.671875 C 1.558594 -1.390625 1.664062 -1.15625 1.878906 -0.96875 C 2.089844 -0.78125 2.402344 -0.6875 2.8125 -0.6875 C 3.21875 -0.6875 3.578125 -0.773438 3.898438 -0.953125 C 4.214844 -1.128906 4.445312 -1.375 4.59375 -1.679688 C 4.707031 -1.917969 4.765625 -2.273438 4.765625 -2.734375 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-8">
-<path style="stroke:none;" d="M 3.09375 -0.945312 L 3.246094 -0.0117188 C 2.949219 0.0507812 2.683594 0.0820312 2.449219 0.0820312 C 2.066406 0.0820312 1.769531 0.0234375 1.558594 -0.101562 C 1.347656 -0.222656 1.199219 -0.378906 1.113281 -0.578125 C 1.027344 -0.773438 0.984375 -1.1875 0.984375 -1.820312 L 0.984375 -5.402344 L 0.210938 -5.402344 L 0.210938 -6.222656 L 0.984375 -6.222656 L 0.984375 -7.765625 L 2.03125 -8.398438 L 2.03125 -6.222656 L 3.09375 -6.222656 L 3.09375 -5.402344 L 2.03125 -5.402344 L 2.03125 -1.765625 C 2.03125 -1.464844 2.050781 -1.269531 2.089844 -1.183594 C 2.125 -1.097656 2.1875 -1.03125 2.269531 -0.976562 C 2.355469 -0.925781 2.476562 -0.902344 2.632812 -0.902344 C 2.75 -0.902344 2.902344 -0.914062 3.09375 -0.945312 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-9">
-<path style="stroke:none;" d="M 0.789062 0 L 0.789062 -6.222656 L 1.742188 -6.222656 L 1.742188 -5.335938 C 2.199219 -6.019531 2.859375 -6.363281 3.71875 -6.363281 C 4.09375 -6.363281 4.441406 -6.296875 4.753906 -6.160156 C 5.070312 -6.027344 5.304688 -5.851562 5.460938 -5.632812 C 5.617188 -5.414062 5.726562 -5.152344 5.789062 -4.851562 C 5.828125 -4.65625 5.847656 -4.3125 5.847656 -3.828125 L 5.847656 0 L 4.792969 0 L 4.792969 -3.785156 C 4.792969 -4.214844 4.75 -4.535156 4.671875 -4.75 C 4.589844 -4.960938 4.441406 -5.132812 4.234375 -5.257812 C 4.023438 -5.386719 3.78125 -5.449219 3.5 -5.449219 C 3.050781 -5.449219 2.660156 -5.304688 2.335938 -5.023438 C 2.007812 -4.738281 1.84375 -4.195312 1.84375 -3.398438 L 1.84375 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-10">
-<path style="stroke:none;" d="M 5.050781 -2.003906 L 6.140625 -1.867188 C 5.96875 -1.230469 5.648438 -0.738281 5.1875 -0.386719 C 4.722656 -0.0351562 4.125 0.140625 3.40625 0.140625 C 2.496094 0.140625 1.773438 -0.140625 1.238281 -0.699219 C 0.707031 -1.261719 0.4375 -2.046875 0.4375 -3.058594 C 0.4375 -4.105469 0.710938 -4.917969 1.25 -5.496094 C 1.789062 -6.074219 2.484375 -6.363281 3.34375 -6.363281 C 4.175781 -6.363281 4.859375 -6.078125 5.382812 -5.515625 C 5.910156 -4.949219 6.175781 -4.148438 6.175781 -3.125 C 6.175781 -3.0625 6.171875 -2.96875 6.171875 -2.84375 L 1.53125 -2.84375 C 1.570312 -2.160156 1.761719 -1.632812 2.109375 -1.273438 C 2.457031 -0.910156 2.890625 -0.726562 3.410156 -0.726562 C 3.796875 -0.726562 4.125 -0.828125 4.398438 -1.03125 C 4.671875 -1.234375 4.890625 -1.558594 5.050781 -2.003906 Z M 1.585938 -3.710938 L 5.0625 -3.710938 C 5.015625 -4.234375 4.882812 -4.625 4.664062 -4.886719 C 4.328125 -5.292969 3.890625 -5.496094 3.359375 -5.496094 C 2.875 -5.496094 2.464844 -5.335938 2.136719 -5.007812 C 1.804688 -4.683594 1.625 -4.25 1.585938 -3.710938 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-11">
-<path style="stroke:none;" d="M 1.042969 0 L 1.042969 -5.402344 L 0.109375 -5.402344 L 0.109375 -6.222656 L 1.042969 -6.222656 L 1.042969 -6.882812 C 1.042969 -7.300781 1.078125 -7.613281 1.15625 -7.816406 C 1.257812 -8.089844 1.433594 -8.3125 1.691406 -8.480469 C 1.945312 -8.652344 2.304688 -8.734375 2.765625 -8.734375 C 3.0625 -8.734375 3.390625 -8.703125 3.75 -8.632812 L 3.59375 -7.710938 C 3.375 -7.75 3.164062 -7.769531 2.96875 -7.769531 C 2.648438 -7.769531 2.421875 -7.703125 2.289062 -7.5625 C 2.15625 -7.425781 2.09375 -7.171875 2.09375 -6.796875 L 2.09375 -6.222656 L 3.304688 -6.222656 L 3.304688 -5.402344 L 2.09375 -5.402344 L 2.09375 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-12">
-<path style="stroke:none;" d="M 4.828125 0 L 4.828125 -0.785156 C 4.433594 -0.167969 3.851562 0.140625 3.085938 0.140625 C 2.589844 0.140625 2.136719 0.00390625 1.71875 -0.269531 C 1.304688 -0.542969 0.980469 -0.925781 0.753906 -1.414062 C 0.523438 -1.90625 0.410156 -2.46875 0.410156 -3.105469 C 0.410156 -3.726562 0.515625 -4.289062 0.71875 -4.796875 C 0.925781 -5.300781 1.238281 -5.6875 1.652344 -5.960938 C 2.066406 -6.230469 2.53125 -6.363281 3.039062 -6.363281 C 3.414062 -6.363281 3.75 -6.285156 4.042969 -6.125 C 4.335938 -5.96875 4.574219 -5.761719 4.757812 -5.507812 L 4.757812 -8.589844 L 5.804688 -8.589844 L 5.804688 0 Z M 1.492188 -3.105469 C 1.492188 -2.308594 1.664062 -1.710938 2 -1.320312 C 2.335938 -0.925781 2.730469 -0.726562 3.1875 -0.726562 C 3.648438 -0.726562 4.039062 -0.914062 4.363281 -1.292969 C 4.683594 -1.667969 4.84375 -2.242188 4.84375 -3.015625 C 4.84375 -3.867188 4.679688 -4.492188 4.351562 -4.890625 C 4.023438 -5.289062 3.621094 -5.492188 3.140625 -5.492188 C 2.671875 -5.492188 2.28125 -5.296875 1.964844 -4.914062 C 1.652344 -4.53125 1.492188 -3.929688 1.492188 -3.105469 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-13">
-<path style="stroke:none;" d="M 4.867188 0 L 4.867188 -0.914062 C 4.382812 -0.210938 3.726562 0.140625 2.894531 0.140625 C 2.527344 0.140625 2.183594 0.0703125 1.867188 -0.0703125 C 1.546875 -0.210938 1.3125 -0.386719 1.15625 -0.601562 C 1.003906 -0.8125 0.894531 -1.074219 0.832031 -1.382812 C 0.789062 -1.589844 0.765625 -1.917969 0.765625 -2.367188 L 0.765625 -6.222656 L 1.820312 -6.222656 L 1.820312 -2.773438 C 1.820312 -2.222656 1.84375 -1.851562 1.886719 -1.65625 C 1.953125 -1.378906 2.09375 -1.164062 2.308594 -1.003906 C 2.523438 -0.847656 2.789062 -0.765625 3.105469 -0.765625 C 3.421875 -0.765625 3.71875 -0.847656 3.996094 -1.011719 C 4.273438 -1.171875 4.46875 -1.394531 4.585938 -1.671875 C 4.699219 -1.953125 4.757812 -2.359375 4.757812 -2.890625 L 4.757812 -6.222656 L 5.8125 -6.222656 L 5.8125 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-0">
-<path style="stroke:none;" d=""/>
-</symbol>
-<symbol overflow="visible" id="glyph3-1">
-<path style="stroke:none;" d="M 0.953125 0 L 0.953125 -9.304688 L 4.445312 -9.304688 C 5.15625 -9.304688 5.722656 -9.210938 6.152344 -9.023438 C 6.582031 -8.835938 6.921875 -8.546875 7.164062 -8.152344 C 7.40625 -7.761719 7.527344 -7.351562 7.527344 -6.925781 C 7.527344 -6.527344 7.421875 -6.152344 7.203125 -5.800781 C 6.988281 -5.449219 6.664062 -5.167969 6.226562 -4.953125 C 6.789062 -4.785156 7.222656 -4.503906 7.523438 -4.105469 C 7.828125 -3.707031 7.980469 -3.238281 7.980469 -2.699219 C 7.980469 -2.261719 7.886719 -1.855469 7.703125 -1.480469 C 7.519531 -1.105469 7.292969 -0.820312 7.019531 -0.617188 C 6.75 -0.414062 6.410156 -0.257812 6 -0.15625 C 5.59375 -0.0507812 5.09375 0 4.5 0 Z M 2.183594 -5.394531 L 4.195312 -5.394531 C 4.742188 -5.394531 5.132812 -5.429688 5.371094 -5.503906 C 5.683594 -5.597656 5.917969 -5.75 6.078125 -5.96875 C 6.238281 -6.183594 6.316406 -6.453125 6.316406 -6.78125 C 6.316406 -7.089844 6.242188 -7.359375 6.09375 -7.59375 C 5.945312 -7.828125 5.734375 -7.992188 5.460938 -8.078125 C 5.183594 -8.164062 4.710938 -8.207031 4.042969 -8.207031 L 2.183594 -8.207031 Z M 2.183594 -1.097656 L 4.5 -1.097656 C 4.898438 -1.097656 5.175781 -1.113281 5.339844 -1.140625 C 5.621094 -1.191406 5.859375 -1.277344 6.050781 -1.398438 C 6.242188 -1.515625 6.394531 -1.6875 6.519531 -1.914062 C 6.640625 -2.140625 6.703125 -2.402344 6.703125 -2.699219 C 6.703125 -3.046875 6.613281 -3.347656 6.4375 -3.601562 C 6.257812 -3.859375 6.011719 -4.039062 5.695312 -4.140625 C 5.382812 -4.246094 4.929688 -4.296875 4.335938 -4.296875 L 2.183594 -4.296875 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-2">
-<path style="stroke:none;" d="M 0.429688 -3.371094 C 0.429688 -4.617188 0.777344 -5.542969 1.472656 -6.144531 C 2.050781 -6.644531 2.757812 -6.894531 3.59375 -6.894531 C 4.519531 -6.894531 5.277344 -6.589844 5.867188 -5.984375 C 6.453125 -5.375 6.746094 -4.535156 6.746094 -3.464844 C 6.746094 -2.597656 6.617188 -1.914062 6.355469 -1.417969 C 6.097656 -0.921875 5.71875 -0.535156 5.222656 -0.261719 C 4.722656 0.015625 4.179688 0.152344 3.59375 0.152344 C 2.648438 0.152344 1.886719 -0.148438 1.304688 -0.753906 C 0.722656 -1.359375 0.429688 -2.230469 0.429688 -3.371094 Z M 1.605469 -3.371094 C 1.605469 -2.507812 1.792969 -1.859375 2.171875 -1.429688 C 2.546875 -1 3.023438 -0.789062 3.59375 -0.789062 C 4.160156 -0.789062 4.632812 -1.003906 5.007812 -1.433594 C 5.382812 -1.867188 5.574219 -2.523438 5.574219 -3.410156 C 5.574219 -4.242188 5.382812 -4.875 5.003906 -5.304688 C 4.625 -5.734375 4.15625 -5.949219 3.59375 -5.949219 C 3.023438 -5.949219 2.546875 -5.734375 2.171875 -5.304688 C 1.792969 -4.878906 1.605469 -4.234375 1.605469 -3.371094 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-3">
-<path style="stroke:none;" d="M 0.398438 -2.011719 L 1.53125 -2.191406 C 1.59375 -1.738281 1.769531 -1.390625 2.058594 -1.148438 C 2.347656 -0.90625 2.753906 -0.789062 3.273438 -0.789062 C 3.800781 -0.789062 4.1875 -0.894531 4.445312 -1.109375 C 4.699219 -1.320312 4.824219 -1.570312 4.824219 -1.859375 C 4.824219 -2.117188 4.710938 -2.320312 4.488281 -2.46875 C 4.332031 -2.570312 3.941406 -2.699219 3.320312 -2.855469 C 2.480469 -3.066406 1.902344 -3.25 1.578125 -3.40625 C 1.253906 -3.558594 1.007812 -3.773438 0.839844 -4.046875 C 0.671875 -4.320312 0.589844 -4.621094 0.589844 -4.953125 C 0.589844 -5.253906 0.660156 -5.53125 0.796875 -5.785156 C 0.933594 -6.042969 1.121094 -6.253906 1.359375 -6.421875 C 1.535156 -6.554688 1.777344 -6.667969 2.085938 -6.757812 C 2.390625 -6.847656 2.722656 -6.894531 3.070312 -6.894531 C 3.601562 -6.894531 4.066406 -6.816406 4.464844 -6.664062 C 4.867188 -6.511719 5.160156 -6.304688 5.351562 -6.046875 C 5.542969 -5.785156 5.671875 -5.4375 5.746094 -5 L 4.628906 -4.851562 C 4.578125 -5.195312 4.429688 -5.46875 4.1875 -5.664062 C 3.945312 -5.859375 3.597656 -5.953125 3.15625 -5.953125 C 2.628906 -5.953125 2.253906 -5.867188 2.03125 -5.695312 C 1.808594 -5.519531 1.695312 -5.316406 1.695312 -5.085938 C 1.695312 -4.9375 1.742188 -4.804688 1.835938 -4.683594 C 1.929688 -4.5625 2.074219 -4.460938 2.273438 -4.378906 C 2.386719 -4.335938 2.722656 -4.242188 3.28125 -4.085938 C 4.089844 -3.871094 4.652344 -3.695312 4.972656 -3.558594 C 5.292969 -3.421875 5.542969 -3.21875 5.726562 -2.957031 C 5.90625 -2.695312 6 -2.371094 6 -1.980469 C 6 -1.601562 5.886719 -1.242188 5.664062 -0.90625 C 5.441406 -0.570312 5.121094 -0.308594 4.703125 -0.125 C 4.285156 0.0585938 3.8125 0.152344 3.28125 0.152344 C 2.40625 0.152344 1.738281 -0.03125 1.277344 -0.394531 C 0.820312 -0.757812 0.527344 -1.296875 0.398438 -2.011719 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-4">
-<path style="stroke:none;" d="M 3.351562 -1.023438 L 3.515625 -0.0117188 C 3.195312 0.0546875 2.90625 0.0898438 2.652344 0.0898438 C 2.238281 0.0898438 1.917969 0.0234375 1.6875 -0.109375 C 1.460938 -0.238281 1.300781 -0.410156 1.207031 -0.625 C 1.113281 -0.839844 1.066406 -1.289062 1.066406 -1.972656 L 1.066406 -5.851562 L 0.226562 -5.851562 L 0.226562 -6.742188 L 1.066406 -6.742188 L 1.066406 -8.410156 L 2.203125 -9.097656 L 2.203125 -6.742188 L 3.351562 -6.742188 L 3.351562 -5.851562 L 2.203125 -5.851562 L 2.203125 -1.910156 C 2.203125 -1.585938 2.222656 -1.375 2.261719 -1.28125 C 2.304688 -1.1875 2.367188 -1.113281 2.460938 -1.058594 C 2.550781 -1.003906 2.679688 -0.976562 2.851562 -0.976562 C 2.976562 -0.976562 3.144531 -0.992188 3.351562 -1.023438 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-5">
-<path style="stroke:none;" d="M 1.179688 0 L 1.179688 -1.300781 L 2.480469 -1.300781 L 2.480469 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-6">
-<path style="stroke:none;" d="M 1.003906 0 L 1.003906 -9.304688 L 4.511719 -9.304688 C 5.128906 -9.304688 5.601562 -9.277344 5.929688 -9.21875 C 6.386719 -9.140625 6.769531 -8.996094 7.078125 -8.78125 C 7.386719 -8.566406 7.636719 -8.269531 7.824219 -7.882812 C 8.011719 -7.5 8.105469 -7.074219 8.105469 -6.613281 C 8.105469 -5.824219 7.855469 -5.152344 7.351562 -4.605469 C 6.847656 -4.058594 5.9375 -3.78125 4.621094 -3.78125 L 2.234375 -3.78125 L 2.234375 0 Z M 2.234375 -4.882812 L 4.640625 -4.882812 C 5.4375 -4.882812 6 -5.03125 6.335938 -5.324219 C 6.667969 -5.621094 6.835938 -6.039062 6.835938 -6.578125 C 6.835938 -6.964844 6.738281 -7.296875 6.542969 -7.574219 C 6.34375 -7.851562 6.085938 -8.035156 5.765625 -8.125 C 5.558594 -8.179688 5.171875 -8.207031 4.613281 -8.207031 L 2.234375 -8.207031 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-7">
-<path style="stroke:none;" d="M 0.804688 2.597656 L 0.679688 1.523438 C 0.929688 1.589844 1.148438 1.625 1.332031 1.625 C 1.585938 1.625 1.789062 1.582031 1.941406 1.5 C 2.09375 1.414062 2.21875 1.296875 2.316406 1.140625 C 2.390625 1.027344 2.503906 0.746094 2.664062 0.292969 C 2.6875 0.230469 2.722656 0.136719 2.765625 0.0117188 L 0.210938 -6.742188 L 1.441406 -6.742188 L 2.84375 -2.835938 C 3.027344 -2.34375 3.1875 -1.820312 3.332031 -1.277344 C 3.464844 -1.800781 3.621094 -2.3125 3.800781 -2.8125 L 5.242188 -6.742188 L 6.386719 -6.742188 L 3.820312 0.113281 C 3.546875 0.855469 3.332031 1.363281 3.179688 1.644531 C 2.976562 2.019531 2.746094 2.296875 2.480469 2.472656 C 2.21875 2.648438 1.90625 2.734375 1.542969 2.734375 C 1.324219 2.734375 1.078125 2.6875 0.804688 2.597656 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-8">
-<path style="stroke:none;" d="M 0.855469 0 L 0.855469 -9.304688 L 2 -9.304688 L 2 -5.96875 C 2.53125 -6.585938 3.207031 -6.894531 4.019531 -6.894531 C 4.519531 -6.894531 4.953125 -6.796875 5.320312 -6.597656 C 5.6875 -6.402344 5.949219 -6.128906 6.109375 -5.78125 C 6.269531 -5.433594 6.347656 -4.933594 6.347656 -4.273438 L 6.347656 0 L 5.203125 0 L 5.203125 -4.273438 C 5.203125 -4.84375 5.082031 -5.257812 4.832031 -5.519531 C 4.585938 -5.78125 4.234375 -5.910156 3.78125 -5.910156 C 3.445312 -5.910156 3.125 -5.820312 2.828125 -5.644531 C 2.53125 -5.46875 2.316406 -5.234375 2.191406 -4.933594 C 2.0625 -4.632812 2 -4.21875 2 -3.6875 L 2 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-9">
-<path style="stroke:none;" d="M 0.855469 0 L 0.855469 -6.742188 L 1.886719 -6.742188 L 1.886719 -5.78125 C 2.382812 -6.523438 3.09375 -6.894531 4.03125 -6.894531 C 4.4375 -6.894531 4.808594 -6.820312 5.152344 -6.675781 C 5.492188 -6.527344 5.746094 -6.335938 5.914062 -6.101562 C 6.085938 -5.863281 6.203125 -5.582031 6.273438 -5.257812 C 6.3125 -5.046875 6.335938 -4.675781 6.335938 -4.144531 L 6.335938 0 L 5.191406 0 L 5.191406 -4.101562 C 5.191406 -4.566406 5.148438 -4.914062 5.058594 -5.144531 C 4.96875 -5.375 4.8125 -5.558594 4.585938 -5.695312 C 4.359375 -5.835938 4.09375 -5.902344 3.789062 -5.902344 C 3.304688 -5.902344 2.882812 -5.75 2.53125 -5.441406 C 2.175781 -5.132812 2 -4.546875 2 -3.679688 L 2 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-10">
-<path style="stroke:none;" d="M 0.855469 2.582031 L 0.855469 -6.742188 L 1.898438 -6.742188 L 1.898438 -5.867188 C 2.144531 -6.207031 2.421875 -6.464844 2.730469 -6.636719 C 3.039062 -6.808594 3.414062 -6.894531 3.851562 -6.894531 C 4.429688 -6.894531 4.9375 -6.746094 5.375 -6.449219 C 5.816406 -6.152344 6.148438 -5.734375 6.375 -5.195312 C 6.597656 -4.65625 6.710938 -4.066406 6.710938 -3.421875 C 6.710938 -2.730469 6.585938 -2.109375 6.339844 -1.558594 C 6.089844 -1.007812 5.730469 -0.582031 5.257812 -0.289062 C 4.785156 0.00390625 4.289062 0.152344 3.769531 0.152344 C 3.390625 0.152344 3.046875 0.0703125 2.746094 -0.0898438 C 2.441406 -0.25 2.195312 -0.453125 2 -0.699219 L 2 2.582031 Z M 1.890625 -3.332031 C 1.890625 -2.464844 2.066406 -1.824219 2.417969 -1.410156 C 2.769531 -0.996094 3.195312 -0.789062 3.695312 -0.789062 C 4.203125 -0.789062 4.636719 -1 5 -1.429688 C 5.359375 -1.859375 5.542969 -2.527344 5.542969 -3.429688 C 5.542969 -4.289062 5.363281 -4.929688 5.011719 -5.359375 C 4.65625 -5.785156 4.234375 -6 3.746094 -6 C 3.257812 -6 2.828125 -5.769531 2.453125 -5.316406 C 2.078125 -4.859375 1.890625 -4.199219 1.890625 -3.332031 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-11">
-<path style="stroke:none;" d="M 1.910156 0 L 0.851562 0 L 0.851562 -9.304688 L 1.992188 -9.304688 L 1.992188 -5.984375 C 2.476562 -6.589844 3.089844 -6.894531 3.839844 -6.894531 C 4.253906 -6.894531 4.648438 -6.808594 5.019531 -6.644531 C 5.390625 -6.476562 5.691406 -6.242188 5.933594 -5.9375 C 6.171875 -5.636719 6.359375 -5.269531 6.492188 -4.84375 C 6.628906 -4.414062 6.695312 -3.957031 6.695312 -3.472656 C 6.695312 -2.316406 6.410156 -1.425781 5.839844 -0.792969 C 5.269531 -0.164062 4.582031 0.152344 3.78125 0.152344 C 2.988281 0.152344 2.363281 -0.179688 1.910156 -0.84375 Z M 1.898438 -3.421875 C 1.898438 -2.613281 2.007812 -2.027344 2.226562 -1.667969 C 2.585938 -1.082031 3.074219 -0.789062 3.6875 -0.789062 C 4.1875 -0.789062 4.617188 -1.003906 4.984375 -1.4375 C 5.347656 -1.871094 5.527344 -2.519531 5.527344 -3.375 C 5.527344 -4.257812 5.355469 -4.90625 5.003906 -5.324219 C 4.65625 -5.742188 4.234375 -5.953125 3.738281 -5.953125 C 3.238281 -5.953125 2.808594 -5.738281 2.445312 -5.304688 C 2.082031 -4.871094 1.898438 -4.242188 1.898438 -3.421875 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-12">
-<path style="stroke:none;" d="M 0.863281 -7.992188 L 0.863281 -9.304688 L 2.007812 -9.304688 L 2.007812 -7.992188 Z M 0.863281 0 L 0.863281 -6.742188 L 2.007812 -6.742188 L 2.007812 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-13">
-<path style="stroke:none;" d="M 5.230469 0 L 5.230469 -0.851562 C 4.804688 -0.183594 4.175781 0.152344 3.34375 0.152344 C 2.808594 0.152344 2.3125 0.00390625 1.863281 -0.292969 C 1.414062 -0.589844 1.0625 -1 0.816406 -1.53125 C 0.570312 -2.0625 0.445312 -2.675781 0.445312 -3.363281 C 0.445312 -4.035156 0.554688 -4.648438 0.78125 -5.195312 C 1.003906 -5.742188 1.339844 -6.164062 1.789062 -6.457031 C 2.238281 -6.75 2.738281 -6.894531 3.292969 -6.894531 C 3.699219 -6.894531 4.0625 -6.808594 4.378906 -6.636719 C 4.695312 -6.464844 4.957031 -6.242188 5.15625 -5.96875 L 5.15625 -9.304688 L 6.289062 -9.304688 L 6.289062 0 Z M 1.617188 -3.363281 C 1.617188 -2.5 1.800781 -1.855469 2.164062 -1.429688 C 2.527344 -1 2.957031 -0.789062 3.453125 -0.789062 C 3.953125 -0.789062 4.375 -0.992188 4.726562 -1.398438 C 5.074219 -1.808594 5.25 -2.429688 5.25 -3.269531 C 5.25 -4.191406 5.070312 -4.867188 4.714844 -5.300781 C 4.359375 -5.730469 3.921875 -5.949219 3.402344 -5.949219 C 2.894531 -5.949219 2.46875 -5.742188 2.128906 -5.324219 C 1.789062 -4.910156 1.617188 -4.257812 1.617188 -3.363281 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-14">
-<path style="stroke:none;" d="M 4.84375 0 L 3.699219 0 L 3.699219 -7.28125 C 3.425781 -7.019531 3.066406 -6.757812 2.617188 -6.492188 C 2.171875 -6.230469 1.769531 -6.035156 1.414062 -5.902344 L 1.414062 -7.007812 C 2.054688 -7.308594 2.613281 -7.671875 3.089844 -8.101562 C 3.570312 -8.527344 3.90625 -8.941406 4.105469 -9.34375 L 4.84375 -9.34375 Z "/>
-</symbol>
-</g>
-<clipPath id="clip1">
- <path d="M 89 21 L 91 21 L 91 221 L 89 221 Z "/>
-</clipPath>
-<clipPath id="clip2">
- <path d="M 201 21 L 203 21 L 203 221 L 201 221 Z "/>
-</clipPath>
-<clipPath id="clip3">
- <path d="M 313 21 L 315 21 L 315 221 L 313 221 Z "/>
-</clipPath>
-<clipPath id="clip4">
- <path d="M 33 180 L 355 180 L 355 182 L 33 182 Z "/>
-</clipPath>
-<clipPath id="clip5">
- <path d="M 33 146 L 355 146 L 355 148 L 33 148 Z "/>
-</clipPath>
-<clipPath id="clip6">
- <path d="M 33 120 L 355 120 L 355 122 L 33 122 Z "/>
-</clipPath>
-<clipPath id="clip7">
- <path d="M 33 95 L 355 95 L 355 97 L 33 97 Z "/>
-</clipPath>
-<clipPath id="clip8">
- <path d="M 33 61 L 355 61 L 355 63 L 33 63 Z "/>
-</clipPath>
-</defs>
-<g id="surface11">
-<g clip-path="url(#clip1)" clip-rule="nonzero">
-<path style="fill:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:0.5;stroke-dasharray:1,2;stroke-miterlimit:3.25;" d="M 90.226562 220.007812 L 90.226562 21 "/>
-</g>
-<g clip-path="url(#clip2)" clip-rule="nonzero">
-<path style="fill:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:0.5;stroke-dasharray:1,2;stroke-miterlimit:3.25;" d="M 201.996094 220.007812 L 201.996094 21 "/>
-</g>
-<g clip-path="url(#clip3)" clip-rule="nonzero">
-<path style="fill:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:0.5;stroke-dasharray:1,2;stroke-miterlimit:3.25;" d="M 313.761719 220.007812 L 313.761719 21 "/>
-</g>
-<g clip-path="url(#clip4)" clip-rule="nonzero">
-<path style="fill:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:0.5;stroke-dasharray:1,2;stroke-miterlimit:3.25;" d="M 33 180.734375 L 355 180.734375 "/>
-</g>
-<g clip-path="url(#clip5)" clip-rule="nonzero">
-<path style="fill:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:0.5;stroke-dasharray:1,2;stroke-miterlimit:3.25;" d="M 33 146.960938 L 355 146.960938 "/>
-</g>
-<g clip-path="url(#clip6)" clip-rule="nonzero">
-<path style="fill:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:0.5;stroke-dasharray:1,2;stroke-miterlimit:3.25;" d="M 33 121.410156 L 355 121.410156 "/>
-</g>
-<g clip-path="url(#clip7)" clip-rule="nonzero">
-<path style="fill:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:0.5;stroke-dasharray:1,2;stroke-miterlimit:3.25;" d="M 33 95.859375 L 355 95.859375 "/>
-</g>
-<g clip-path="url(#clip8)" clip-rule="nonzero">
-<path style="fill:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:0.5;stroke-dasharray:1,2;stroke-miterlimit:3.25;" d="M 33 62.082031 L 355 62.082031 "/>
-</g>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 49.128906 169 C 49.128906 168.167969 48.800781 167.375 48.214844 166.785156 C 47.625 166.199219 46.832031 165.871094 46 165.871094 C 45.167969 165.871094 44.375 166.199219 43.785156 166.785156 C 43.199219 167.375 42.871094 168.167969 42.871094 169 C 42.871094 169.832031 43.199219 170.625 43.785156 171.214844 C 44.375 171.800781 45.167969 172.128906 46 172.128906 C 46.832031 172.128906 47.625 171.800781 48.214844 171.214844 C 48.800781 170.625 49.128906 169.832031 49.128906 169 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 82.128906 169 C 82.128906 168.167969 81.800781 167.375 81.214844 166.785156 C 80.625 166.199219 79.832031 165.871094 79 165.871094 C 78.167969 165.871094 77.375 166.199219 76.785156 166.785156 C 76.199219 167.375 75.871094 168.167969 75.871094 169 C 75.871094 169.832031 76.199219 170.625 76.785156 171.214844 C 77.375 171.800781 78.167969 172.128906 79 172.128906 C 79.832031 172.128906 80.625 171.800781 81.214844 171.214844 C 81.800781 170.625 82.128906 169.832031 82.128906 169 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 116.128906 167 C 116.128906 166.167969 115.800781 165.375 115.214844 164.785156 C 114.625 164.199219 113.832031 163.871094 113 163.871094 C 112.167969 163.871094 111.375 164.199219 110.785156 164.785156 C 110.199219 165.375 109.871094 166.167969 109.871094 167 C 109.871094 167.832031 110.199219 168.625 110.785156 169.214844 C 111.375 169.800781 112.167969 170.128906 113 170.128906 C 113.832031 170.128906 114.625 169.800781 115.214844 169.214844 C 115.800781 168.625 116.128906 167.832031 116.128906 167 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 150.128906 159 C 150.128906 158.167969 149.800781 157.375 149.214844 156.785156 C 148.625 156.199219 147.832031 155.871094 147 155.871094 C 146.167969 155.871094 145.375 156.199219 144.785156 156.785156 C 144.199219 157.375 143.871094 158.167969 143.871094 159 C 143.871094 159.832031 144.199219 160.625 144.785156 161.214844 C 145.375 161.800781 146.167969 162.128906 147 162.128906 C 147.832031 162.128906 148.625 161.800781 149.214844 161.214844 C 149.800781 160.625 150.128906 159.832031 150.128906 159 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 183.128906 146 C 183.128906 145.167969 182.800781 144.375 182.214844 143.785156 C 181.625 143.199219 180.832031 142.871094 180 142.871094 C 179.167969 142.871094 178.375 143.199219 177.785156 143.785156 C 177.199219 144.375 176.871094 145.167969 176.871094 146 C 176.871094 146.832031 177.199219 147.625 177.785156 148.214844 C 178.375 148.800781 179.167969 149.128906 180 149.128906 C 180.832031 149.128906 181.625 148.800781 182.214844 148.214844 C 182.800781 147.625 183.128906 146.832031 183.128906 146 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 217.128906 128 C 217.128906 127.167969 216.800781 126.375 216.214844 125.785156 C 215.625 125.199219 214.832031 124.871094 214 124.871094 C 213.167969 124.871094 212.375 125.199219 211.785156 125.785156 C 211.199219 126.375 210.871094 127.167969 210.871094 128 C 210.871094 128.832031 211.199219 129.625 211.785156 130.214844 C 212.375 130.800781 213.167969 131.128906 214 131.128906 C 214.832031 131.128906 215.625 130.800781 216.214844 130.214844 C 216.800781 129.625 217.128906 128.832031 217.128906 128 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 251.128906 108 C 251.128906 107.167969 250.800781 106.375 250.214844 105.785156 C 249.625 105.199219 248.832031 104.871094 248 104.871094 C 247.167969 104.871094 246.375 105.199219 245.785156 105.785156 C 245.199219 106.375 244.871094 107.167969 244.871094 108 C 244.871094 108.832031 245.199219 109.625 245.785156 110.214844 C 246.375 110.800781 247.167969 111.128906 248 111.128906 C 248.832031 111.128906 249.625 110.800781 250.214844 110.214844 C 250.800781 109.625 251.128906 108.832031 251.128906 108 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 284.128906 85 C 284.128906 84.167969 283.800781 83.375 283.214844 82.785156 C 282.625 82.199219 281.832031 81.871094 281 81.871094 C 280.167969 81.871094 279.375 82.199219 278.785156 82.785156 C 278.199219 83.375 277.871094 84.167969 277.871094 85 C 277.871094 85.832031 278.199219 86.625 278.785156 87.214844 C 279.375 87.800781 280.167969 88.128906 281 88.128906 C 281.832031 88.128906 282.625 87.800781 283.214844 87.214844 C 283.800781 86.625 284.128906 85.832031 284.128906 85 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 318.128906 59 C 318.128906 58.167969 317.800781 57.375 317.214844 56.785156 C 316.625 56.199219 315.832031 55.871094 315 55.871094 C 314.167969 55.871094 313.375 56.199219 312.785156 56.785156 C 312.199219 57.375 311.871094 58.167969 311.871094 59 C 311.871094 59.832031 312.199219 60.625 312.785156 61.214844 C 313.375 61.800781 314.167969 62.128906 315 62.128906 C 315.832031 62.128906 316.625 61.800781 317.214844 61.214844 C 317.800781 60.625 318.128906 59.832031 318.128906 59 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 352.128906 31 C 352.128906 30.167969 351.800781 29.375 351.214844 28.785156 C 350.625 28.199219 349.832031 27.871094 349 27.871094 C 348.167969 27.871094 347.375 28.199219 346.785156 28.785156 C 346.199219 29.375 345.871094 30.167969 345.871094 31 C 345.871094 31.832031 346.199219 32.625 346.785156 33.214844 C 347.375 33.800781 348.167969 34.128906 349 34.128906 C 349.832031 34.128906 350.625 33.800781 351.214844 33.214844 C 351.800781 32.625 352.128906 31.832031 352.128906 31 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 49.128906 205 C 49.128906 204.167969 48.800781 203.375 48.214844 202.785156 C 47.625 202.199219 46.832031 201.871094 46 201.871094 C 45.167969 201.871094 44.375 202.199219 43.785156 202.785156 C 43.199219 203.375 42.871094 204.167969 42.871094 205 C 42.871094 205.832031 43.199219 206.625 43.785156 207.214844 C 44.375 207.800781 45.167969 208.128906 46 208.128906 C 46.832031 208.128906 47.625 207.800781 48.214844 207.214844 C 48.800781 206.625 49.128906 205.832031 49.128906 205 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 82.128906 199 C 82.128906 198.167969 81.800781 197.375 81.214844 196.785156 C 80.625 196.199219 79.832031 195.871094 79 195.871094 C 78.167969 195.871094 77.375 196.199219 76.785156 196.785156 C 76.199219 197.375 75.871094 198.167969 75.871094 199 C 75.871094 199.832031 76.199219 200.625 76.785156 201.214844 C 77.375 201.800781 78.167969 202.128906 79 202.128906 C 79.832031 202.128906 80.625 201.800781 81.214844 201.214844 C 81.800781 200.625 82.128906 199.832031 82.128906 199 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 116.128906 190 C 116.128906 189.167969 115.800781 188.375 115.214844 187.785156 C 114.625 187.199219 113.832031 186.871094 113 186.871094 C 112.167969 186.871094 111.375 187.199219 110.785156 187.785156 C 110.199219 188.375 109.871094 189.167969 109.871094 190 C 109.871094 190.832031 110.199219 191.625 110.785156 192.214844 C 111.375 192.800781 112.167969 193.128906 113 193.128906 C 113.832031 193.128906 114.625 192.800781 115.214844 192.214844 C 115.800781 191.625 116.128906 190.832031 116.128906 190 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 150.128906 177 C 150.128906 176.167969 149.800781 175.375 149.214844 174.785156 C 148.625 174.199219 147.832031 173.871094 147 173.871094 C 146.167969 173.871094 145.375 174.199219 144.785156 174.785156 C 144.199219 175.375 143.871094 176.167969 143.871094 177 C 143.871094 177.832031 144.199219 178.625 144.785156 179.214844 C 145.375 179.800781 146.167969 180.128906 147 180.128906 C 147.832031 180.128906 148.625 179.800781 149.214844 179.214844 C 149.800781 178.625 150.128906 177.832031 150.128906 177 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 183.128906 159 C 183.128906 158.167969 182.800781 157.375 182.214844 156.785156 C 181.625 156.199219 180.832031 155.871094 180 155.871094 C 179.167969 155.871094 178.375 156.199219 177.785156 156.785156 C 177.199219 157.375 176.871094 158.167969 176.871094 159 C 176.871094 159.832031 177.199219 160.625 177.785156 161.214844 C 178.375 161.800781 179.167969 162.128906 180 162.128906 C 180.832031 162.128906 181.625 161.800781 182.214844 161.214844 C 182.800781 160.625 183.128906 159.832031 183.128906 159 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 217.128906 138 C 217.128906 137.167969 216.800781 136.375 216.214844 135.785156 C 215.625 135.199219 214.832031 134.871094 214 134.871094 C 213.167969 134.871094 212.375 135.199219 211.785156 135.785156 C 211.199219 136.375 210.871094 137.167969 210.871094 138 C 210.871094 138.832031 211.199219 139.625 211.785156 140.214844 C 212.375 140.800781 213.167969 141.128906 214 141.128906 C 214.832031 141.128906 215.625 140.800781 216.214844 140.214844 C 216.800781 139.625 217.128906 138.832031 217.128906 138 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 251.128906 115 C 251.128906 114.167969 250.800781 113.375 250.214844 112.785156 C 249.625 112.199219 248.832031 111.871094 248 111.871094 C 247.167969 111.871094 246.375 112.199219 245.785156 112.785156 C 245.199219 113.375 244.871094 114.167969 244.871094 115 C 244.871094 115.832031 245.199219 116.625 245.785156 117.214844 C 246.375 117.800781 247.167969 118.128906 248 118.128906 C 248.832031 118.128906 249.625 117.800781 250.214844 117.214844 C 250.800781 116.625 251.128906 115.832031 251.128906 115 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 284.128906 91 C 284.128906 90.167969 283.800781 89.375 283.214844 88.785156 C 282.625 88.199219 281.832031 87.871094 281 87.871094 C 280.167969 87.871094 279.375 88.199219 278.785156 88.785156 C 278.199219 89.375 277.871094 90.167969 277.871094 91 C 277.871094 91.832031 278.199219 92.625 278.785156 93.214844 C 279.375 93.800781 280.167969 94.128906 281 94.128906 C 281.832031 94.128906 282.625 93.800781 283.214844 93.214844 C 283.800781 92.625 284.128906 91.832031 284.128906 91 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 318.128906 65 C 318.128906 64.167969 317.800781 63.375 317.214844 62.785156 C 316.625 62.199219 315.832031 61.871094 315 61.871094 C 314.167969 61.871094 313.375 62.199219 312.785156 62.785156 C 312.199219 63.375 311.871094 64.167969 311.871094 65 C 311.871094 65.832031 312.199219 66.625 312.785156 67.214844 C 313.375 67.800781 314.167969 68.128906 315 68.128906 C 315.832031 68.128906 316.625 67.800781 317.214844 67.214844 C 317.800781 66.625 318.128906 65.832031 318.128906 65 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 352.128906 38 C 352.128906 37.167969 351.800781 36.375 351.214844 35.785156 C 350.625 35.199219 349.832031 34.871094 349 34.871094 C 348.167969 34.871094 347.375 35.199219 346.785156 35.785156 C 346.199219 36.375 345.871094 37.167969 345.871094 38 C 345.871094 38.832031 346.199219 39.625 346.785156 40.214844 C 347.375 40.800781 348.167969 41.128906 349 41.128906 C 349.832031 41.128906 350.625 40.800781 351.214844 40.214844 C 351.800781 39.625 352.128906 38.832031 352.128906 38 Z "/>
-<path style="fill:none;stroke-width:0.5;stroke-linecap:square;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 220.007812 L 33 220.007812 "/>
-<path style="fill:none;stroke-width:0.5;stroke-linecap:square;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 220.007812 L 33 21 "/>
-<path style="fill:none;stroke-width:0.5;stroke-linecap:square;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 21 L 355 21 "/>
-<path style="fill:none;stroke-width:0.5;stroke-linecap:square;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 21 L 355 220.007812 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 90.226562 220.007812 L 90.226562 216.785156 "/>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph0-1" x="84.725786" y="232.006944"/>
- <use xlink:href="#glyph0-2" x="90.28731" y="232.006944"/>
-</g>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 201.996094 220.007812 L 201.996094 216.785156 "/>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph0-1" x="193.49443" y="232.006944"/>
- <use xlink:href="#glyph0-2" x="199.055953" y="232.006944"/>
- <use xlink:href="#glyph0-2" x="204.617477" y="232.006944"/>
-</g>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 313.761719 220.007812 L 313.761719 216.785156 "/>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph0-1" x="302.763074" y="232.006944"/>
- <use xlink:href="#glyph0-2" x="308.324597" y="232.006944"/>
- <use xlink:href="#glyph0-2" x="313.88612" y="232.006944"/>
- <use xlink:href="#glyph0-2" x="319.447644" y="232.006944"/>
-</g>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 45.75 220.007812 L 45.75 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 56.578125 220.007812 L 56.578125 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 65.429688 220.007812 L 65.429688 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 72.914062 220.007812 L 72.914062 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 79.394531 220.007812 L 79.394531 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 85.113281 220.007812 L 85.113281 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 123.871094 220.007812 L 123.871094 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 143.554688 220.007812 L 143.554688 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 157.515625 220.007812 L 157.515625 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 168.347656 220.007812 L 168.347656 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 177.199219 220.007812 L 177.199219 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 184.679688 220.007812 L 184.679688 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 191.164062 220.007812 L 191.164062 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 196.878906 220.007812 L 196.878906 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 235.640625 220.007812 L 235.640625 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 255.320312 220.007812 L 255.320312 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 269.285156 220.007812 L 269.285156 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 280.117188 220.007812 L 280.117188 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 288.96875 220.007812 L 288.96875 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 296.449219 220.007812 L 296.449219 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 302.929688 220.007812 L 302.929688 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 308.648438 220.007812 L 308.648438 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 347.410156 220.007812 L 347.410156 218.398438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 180.734375 L 36.21875 180.734375 "/>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph0-3" x="24" y="183.235493"/>
-</g>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 146.960938 L 36.21875 146.960938 "/>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph0-4" x="24" y="149.45964"/>
-</g>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 121.410156 L 36.21875 121.410156 "/>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph0-1" x="19" y="123.909193"/>
- <use xlink:href="#glyph0-2" x="24.561523" y="123.909193"/>
-</g>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 95.859375 L 36.21875 95.859375 "/>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph0-3" x="19" y="98.358747"/>
- <use xlink:href="#glyph0-2" x="24.561523" y="98.358747"/>
-</g>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 62.082031 L 36.21875 62.082031 "/>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph0-4" x="19" y="64.582894"/>
- <use xlink:href="#glyph0-2" x="24.561523" y="64.582894"/>
-</g>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 206.285156 L 34.609375 206.285156 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 165.789062 L 34.609375 165.789062 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 155.183594 L 34.609375 155.183594 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 140.238281 L 34.609375 140.238281 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 134.558594 L 34.609375 134.558594 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 129.632812 L 34.609375 129.632812 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 125.292969 L 34.609375 125.292969 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 80.914062 L 34.609375 80.914062 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 70.308594 L 34.609375 70.308594 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 33 36.53125 L 34.609375 36.53125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 90.226562 21 L 90.226562 24.21875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 201.996094 21 L 201.996094 24.21875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 313.761719 21 L 313.761719 24.21875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 45.75 21 L 45.75 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 56.578125 21 L 56.578125 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 65.429688 21 L 65.429688 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 72.914062 21 L 72.914062 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 79.394531 21 L 79.394531 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 85.113281 21 L 85.113281 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 123.871094 21 L 123.871094 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 143.554688 21 L 143.554688 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 157.515625 21 L 157.515625 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 168.347656 21 L 168.347656 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 177.199219 21 L 177.199219 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 184.679688 21 L 184.679688 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 191.164062 21 L 191.164062 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 196.878906 21 L 196.878906 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 235.640625 21 L 235.640625 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 255.320312 21 L 255.320312 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 269.285156 21 L 269.285156 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 280.117188 21 L 280.117188 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 288.96875 21 L 288.96875 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 296.449219 21 L 296.449219 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 302.929688 21 L 302.929688 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 308.648438 21 L 308.648438 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 347.410156 21 L 347.410156 22.609375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 180.734375 L 351.78125 180.734375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 146.960938 L 351.78125 146.960938 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 121.410156 L 351.78125 121.410156 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 95.859375 L 351.78125 95.859375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 62.082031 L 351.78125 62.082031 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 206.285156 L 353.390625 206.285156 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 165.789062 L 353.390625 165.789062 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 155.183594 L 353.390625 155.183594 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 140.238281 L 353.390625 140.238281 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 134.558594 L 353.390625 134.558594 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 129.632812 L 353.390625 129.632812 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 125.292969 L 353.390625 125.292969 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 80.914062 L 353.390625 80.914062 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 70.308594 L 353.390625 70.308594 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 36.53125 L 353.390625 36.53125 "/>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph0-5" x="172.5" y="251.006944"/>
- <use xlink:href="#glyph0-6" x="178.608398" y="251.006944"/>
- <use xlink:href="#glyph0-7" x="184.169922" y="251.006944"/>
- <use xlink:href="#glyph0-8" x="189.731445" y="251.006944"/>
- <use xlink:href="#glyph0-9" x="194.731445" y="251.006944"/>
- <use xlink:href="#glyph0-10" x="197.509766" y="251.006944"/>
- <use xlink:href="#glyph0-11" x="199.731445" y="251.006944"/>
- <use xlink:href="#glyph0-7" x="205.292969" y="251.006944"/>
- <use xlink:href="#glyph0-12" x="210.854492" y="251.006944"/>
-</g>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph1-1" x="9" y="140.003472"/>
- <use xlink:href="#glyph1-2" x="9" y="133.33355"/>
- <use xlink:href="#glyph1-3" x="9" y="127.772027"/>
- <use xlink:href="#glyph1-4" x="9" y="122.772027"/>
- <use xlink:href="#glyph1-5" x="9" y="117.210503"/>
- <use xlink:href="#glyph1-6" x="9" y="111.64898"/>
- <use xlink:href="#glyph1-7" x="9" y="106.087457"/>
-</g>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph2-1" x="122" y="12"/>
- <use xlink:href="#glyph2-2" x="130.666016" y="12"/>
- <use xlink:href="#glyph2-3" x="137.339844" y="12"/>
- <use xlink:href="#glyph2-4" x="147.335938" y="12"/>
- <use xlink:href="#glyph2-5" x="154.009766" y="12"/>
- <use xlink:href="#glyph2-6" x="156.675781" y="12"/>
- <use xlink:href="#glyph2-7" x="159.341797" y="12"/>
- <use xlink:href="#glyph2-8" x="166.015625" y="12"/>
- <use xlink:href="#glyph2-5" x="169.349609" y="12"/>
- <use xlink:href="#glyph2-2" x="172.015625" y="12"/>
- <use xlink:href="#glyph2-9" x="178.689453" y="12"/>
-</g>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph2-8" x="188" y="12"/>
- <use xlink:href="#glyph2-5" x="191.333984" y="12"/>
- <use xlink:href="#glyph2-3" x="194" y="12"/>
- <use xlink:href="#glyph2-10" x="203.996094" y="12"/>
-</g>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph2-2" x="214" y="12"/>
- <use xlink:href="#glyph2-11" x="220.673828" y="12"/>
-</g>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph2-3" x="227" y="12"/>
- <use xlink:href="#glyph2-2" x="236.996094" y="12"/>
- <use xlink:href="#glyph2-12" x="243.669922" y="12"/>
- <use xlink:href="#glyph2-13" x="250.34375" y="12"/>
- <use xlink:href="#glyph2-6" x="257.017578" y="12"/>
- <use xlink:href="#glyph2-10" x="259.683594" y="12"/>
-</g>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 382.148438 116 C 382.148438 115.164062 381.816406 114.363281 381.226562 113.773438 C 380.636719 113.183594 379.835938 112.851562 379 112.851562 C 378.164062 112.851562 377.363281 113.183594 376.773438 113.773438 C 376.183594 114.363281 375.851562 115.164062 375.851562 116 C 375.851562 116.835938 376.183594 117.636719 376.773438 118.226562 C 377.363281 118.816406 378.164062 119.148438 379 119.148438 C 379.835938 119.148438 380.636719 118.816406 381.226562 118.226562 C 381.816406 117.636719 382.148438 116.835938 382.148438 116 Z "/>
-<g style="fill:rgb(0%,0%,0%);fill-opacity:1;">
- <use xlink:href="#glyph3-1" x="391" y="120.28418"/>
- <use xlink:href="#glyph3-2" x="399.670898" y="120.28418"/>
- <use xlink:href="#glyph3-2" x="406.901367" y="120.28418"/>
- <use xlink:href="#glyph3-3" x="414.131836" y="120.28418"/>
- <use xlink:href="#glyph3-4" x="420.631836" y="120.28418"/>
-</g>
-<g style="fill:rgb(0%,0%,0%);fill-opacity:1;">
- <use xlink:href="#glyph3-5" x="424" y="120.28418"/>
-</g>
-<g style="fill:rgb(0%,0%,0%);fill-opacity:1;">
- <use xlink:href="#glyph3-6" x="428" y="120.28418"/>
- <use xlink:href="#glyph3-7" x="436.670898" y="120.28418"/>
- <use xlink:href="#glyph3-4" x="443.170898" y="120.28418"/>
- <use xlink:href="#glyph3-8" x="446.783203" y="120.28418"/>
- <use xlink:href="#glyph3-2" x="454.013672" y="120.28418"/>
- <use xlink:href="#glyph3-9" x="461.244141" y="120.28418"/>
-</g>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 382.148438 139 C 382.148438 138.164062 381.816406 137.363281 381.226562 136.773438 C 380.636719 136.183594 379.835938 135.851562 379 135.851562 C 378.164062 135.851562 377.363281 136.183594 376.773438 136.773438 C 376.183594 137.363281 375.851562 138.164062 375.851562 139 C 375.851562 139.835938 376.183594 140.636719 376.773438 141.226562 C 377.363281 141.816406 378.164062 142.148438 379 142.148438 C 379.835938 142.148438 380.636719 141.816406 381.226562 141.226562 C 381.816406 140.636719 382.148438 139.835938 382.148438 139 Z "/>
-<g style="fill:rgb(0%,0%,0%);fill-opacity:1;">
- <use xlink:href="#glyph3-10" x="391" y="143.28418"/>
- <use xlink:href="#glyph3-7" x="398.230469" y="143.28418"/>
- <use xlink:href="#glyph3-11" x="404.730469" y="143.28418"/>
- <use xlink:href="#glyph3-12" x="411.960938" y="143.28418"/>
- <use xlink:href="#glyph3-9" x="414.849609" y="143.28418"/>
- <use xlink:href="#glyph3-13" x="422.080078" y="143.28418"/>
- <use xlink:href="#glyph3-14" x="429.310547" y="143.28418"/>
- <use xlink:href="#glyph3-14" x="436.541016" y="143.28418"/>
-</g>
-</g>
-</svg>
diff --git a/thirdparty/pybind11/pybind11/docs/pybind11_vs_boost_python2.png b/thirdparty/pybind11/pybind11/docs/pybind11_vs_boost_python2.png
deleted file mode 100644
index 9f17272c50663957d6ae6d8e23fdd5a15757e71f..0000000000000000000000000000000000000000
Binary files a/thirdparty/pybind11/pybind11/docs/pybind11_vs_boost_python2.png and /dev/null differ
diff --git a/thirdparty/pybind11/pybind11/docs/pybind11_vs_boost_python2.svg b/thirdparty/pybind11/pybind11/docs/pybind11_vs_boost_python2.svg
deleted file mode 100644
index 5ed6530ca112cbe643d5dd6d6fde385c4edea6b5..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/pybind11_vs_boost_python2.svg
+++ /dev/null
@@ -1,427 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="468pt" height="246pt" viewBox="0 0 468 246" version="1.1">
-<defs>
-<g>
-<symbol overflow="visible" id="glyph0-0">
-<path style="stroke:none;" d=""/>
-</symbol>
-<symbol overflow="visible" id="glyph0-1">
-<path style="stroke:none;" d="M 3.726562 0 L 2.847656 0 L 2.847656 -5.601562 C 2.636719 -5.398438 2.359375 -5.195312 2.015625 -4.996094 C 1.671875 -4.792969 1.363281 -4.640625 1.089844 -4.539062 L 1.089844 -5.390625 C 1.582031 -5.621094 2.011719 -5.902344 2.378906 -6.230469 C 2.746094 -6.558594 3.007812 -6.878906 3.160156 -7.1875 L 3.726562 -7.1875 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-2">
-<path style="stroke:none;" d="M 0.414062 -3.53125 C 0.414062 -4.375 0.503906 -5.058594 0.675781 -5.574219 C 0.851562 -6.089844 1.109375 -6.488281 1.453125 -6.765625 C 1.796875 -7.046875 2.226562 -7.1875 2.75 -7.1875 C 3.132812 -7.1875 3.46875 -7.109375 3.757812 -6.957031 C 4.046875 -6.800781 4.289062 -6.578125 4.476562 -6.285156 C 4.664062 -5.996094 4.8125 -5.640625 4.921875 -5.222656 C 5.03125 -4.804688 5.082031 -4.238281 5.082031 -3.53125 C 5.082031 -2.691406 4.996094 -2.011719 4.824219 -1.496094 C 4.652344 -0.980469 4.394531 -0.582031 4.050781 -0.300781 C 3.707031 -0.0195312 3.273438 0.121094 2.75 0.121094 C 2.058594 0.121094 1.515625 -0.125 1.125 -0.621094 C 0.652344 -1.214844 0.414062 -2.1875 0.414062 -3.53125 Z M 1.320312 -3.53125 C 1.320312 -2.355469 1.457031 -1.574219 1.730469 -1.183594 C 2.007812 -0.796875 2.34375 -0.601562 2.75 -0.601562 C 3.152344 -0.601562 3.492188 -0.796875 3.765625 -1.1875 C 4.042969 -1.578125 4.179688 -2.359375 4.179688 -3.53125 C 4.179688 -4.710938 4.042969 -5.492188 3.765625 -5.878906 C 3.492188 -6.265625 3.148438 -6.460938 2.738281 -6.460938 C 2.335938 -6.460938 2.011719 -6.289062 1.773438 -5.945312 C 1.46875 -5.511719 1.320312 -4.707031 1.320312 -3.53125 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-3">
-<path style="stroke:none;" d="M 0.820312 0 L 0.820312 -7.15625 L 5.648438 -7.15625 L 5.648438 -6.3125 L 1.765625 -6.3125 L 1.765625 -4.097656 L 5.125 -4.097656 L 5.125 -3.25 L 1.765625 -3.25 L 1.765625 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-4">
-<path style="stroke:none;" d="M 4.058594 0 L 4.058594 -0.761719 C 3.65625 -0.175781 3.105469 0.117188 2.414062 0.117188 C 2.105469 0.117188 1.820312 0.0585938 1.554688 -0.0585938 C 1.289062 -0.175781 1.09375 -0.324219 0.964844 -0.5 C 0.835938 -0.679688 0.746094 -0.894531 0.695312 -1.152344 C 0.65625 -1.324219 0.640625 -1.597656 0.640625 -1.972656 L 0.640625 -5.1875 L 1.519531 -5.1875 L 1.519531 -2.308594 C 1.519531 -1.851562 1.535156 -1.542969 1.570312 -1.382812 C 1.625 -1.152344 1.746094 -0.96875 1.921875 -0.835938 C 2.101562 -0.703125 2.324219 -0.640625 2.585938 -0.640625 C 2.851562 -0.640625 3.097656 -0.707031 3.328125 -0.84375 C 3.5625 -0.976562 3.726562 -1.160156 3.820312 -1.394531 C 3.917969 -1.625 3.964844 -1.964844 3.964844 -2.40625 L 3.964844 -5.1875 L 4.84375 -5.1875 L 4.84375 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-5">
-<path style="stroke:none;" d="M 0.660156 0 L 0.660156 -5.1875 L 1.449219 -5.1875 L 1.449219 -4.449219 C 1.832031 -5.019531 2.382812 -5.304688 3.101562 -5.304688 C 3.414062 -5.304688 3.699219 -5.246094 3.960938 -5.132812 C 4.222656 -5.023438 4.421875 -4.875 4.550781 -4.691406 C 4.679688 -4.507812 4.773438 -4.292969 4.824219 -4.042969 C 4.855469 -3.878906 4.875 -3.59375 4.875 -3.1875 L 4.875 0 L 3.992188 0 L 3.992188 -3.15625 C 3.992188 -3.511719 3.960938 -3.78125 3.890625 -3.957031 C 3.824219 -4.132812 3.703125 -4.277344 3.527344 -4.382812 C 3.351562 -4.488281 3.148438 -4.539062 2.914062 -4.539062 C 2.539062 -4.539062 2.21875 -4.421875 1.945312 -4.183594 C 1.671875 -3.945312 1.539062 -3.496094 1.539062 -2.832031 L 1.539062 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-6">
-<path style="stroke:none;" d="M 4.042969 -1.898438 L 4.90625 -1.789062 C 4.8125 -1.191406 4.570312 -0.726562 4.183594 -0.386719 C 3.792969 -0.0507812 3.316406 0.117188 2.75 0.117188 C 2.039062 0.117188 1.46875 -0.113281 1.039062 -0.578125 C 0.605469 -1.042969 0.390625 -1.707031 0.390625 -2.574219 C 0.390625 -3.132812 0.484375 -3.625 0.667969 -4.042969 C 0.855469 -4.460938 1.136719 -4.777344 1.515625 -4.988281 C 1.894531 -5.199219 2.308594 -5.304688 2.753906 -5.304688 C 3.316406 -5.304688 3.777344 -5.160156 4.136719 -4.875 C 4.492188 -4.589844 4.722656 -4.1875 4.824219 -3.664062 L 3.96875 -3.53125 C 3.886719 -3.878906 3.746094 -4.140625 3.539062 -4.316406 C 3.332031 -4.492188 3.082031 -4.578125 2.789062 -4.578125 C 2.34375 -4.578125 1.984375 -4.421875 1.710938 -4.105469 C 1.433594 -3.789062 1.292969 -3.285156 1.292969 -2.597656 C 1.292969 -1.902344 1.425781 -1.394531 1.695312 -1.078125 C 1.960938 -0.761719 2.308594 -0.605469 2.738281 -0.605469 C 3.085938 -0.605469 3.371094 -0.710938 3.601562 -0.921875 C 3.835938 -1.132812 3.980469 -1.460938 4.042969 -1.898438 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-7">
-<path style="stroke:none;" d="M 2.578125 -0.785156 L 2.703125 -0.0078125 C 2.457031 0.0429688 2.234375 0.0703125 2.039062 0.0703125 C 1.722656 0.0703125 1.476562 0.0195312 1.296875 -0.0820312 C 1.121094 -0.183594 1 -0.316406 0.929688 -0.480469 C 0.855469 -0.644531 0.820312 -0.992188 0.820312 -1.519531 L 0.820312 -4.5 L 0.175781 -4.5 L 0.175781 -5.1875 L 0.820312 -5.1875 L 0.820312 -6.46875 L 1.695312 -6.996094 L 1.695312 -5.1875 L 2.578125 -5.1875 L 2.578125 -4.5 L 1.695312 -4.5 L 1.695312 -1.46875 C 1.695312 -1.21875 1.710938 -1.058594 1.742188 -0.984375 C 1.773438 -0.914062 1.820312 -0.859375 1.890625 -0.816406 C 1.960938 -0.773438 2.0625 -0.75 2.191406 -0.75 C 2.289062 -0.75 2.417969 -0.761719 2.578125 -0.785156 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-8">
-<path style="stroke:none;" d="M 0.664062 -6.148438 L 0.664062 -7.15625 L 1.542969 -7.15625 L 1.542969 -6.148438 Z M 0.664062 0 L 0.664062 -5.1875 L 1.542969 -5.1875 L 1.542969 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-9">
-<path style="stroke:none;" d="M 0.332031 -2.59375 C 0.332031 -3.554688 0.597656 -4.265625 1.132812 -4.726562 C 1.578125 -5.109375 2.121094 -5.304688 2.765625 -5.304688 C 3.476562 -5.304688 4.058594 -5.070312 4.511719 -4.601562 C 4.964844 -4.132812 5.191406 -3.488281 5.191406 -2.664062 C 5.191406 -2 5.089844 -1.472656 4.890625 -1.089844 C 4.691406 -0.707031 4.398438 -0.410156 4.015625 -0.199219 C 3.632812 0.0117188 3.214844 0.117188 2.765625 0.117188 C 2.039062 0.117188 1.449219 -0.117188 1.003906 -0.582031 C 0.554688 -1.046875 0.332031 -1.71875 0.332031 -2.59375 Z M 1.234375 -2.59375 C 1.234375 -1.929688 1.378906 -1.429688 1.671875 -1.101562 C 1.960938 -0.769531 2.324219 -0.605469 2.765625 -0.605469 C 3.199219 -0.605469 3.5625 -0.773438 3.851562 -1.101562 C 4.140625 -1.433594 4.289062 -1.941406 4.289062 -2.621094 C 4.289062 -3.261719 4.140625 -3.75 3.851562 -4.078125 C 3.558594 -4.410156 3.195312 -4.574219 2.765625 -4.574219 C 2.324219 -4.574219 1.960938 -4.410156 1.671875 -4.082031 C 1.382812 -3.753906 1.234375 -3.257812 1.234375 -2.59375 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph0-10">
-<path style="stroke:none;" d="M 0.308594 -1.546875 L 1.175781 -1.683594 C 1.226562 -1.335938 1.363281 -1.070312 1.585938 -0.882812 C 1.808594 -0.699219 2.117188 -0.605469 2.519531 -0.605469 C 2.921875 -0.605469 3.222656 -0.6875 3.417969 -0.851562 C 3.613281 -1.015625 3.710938 -1.210938 3.710938 -1.429688 C 3.710938 -1.628906 3.625 -1.785156 3.453125 -1.898438 C 3.332031 -1.976562 3.03125 -2.078125 2.554688 -2.195312 C 1.910156 -2.359375 1.460938 -2.5 1.214844 -2.621094 C 0.964844 -2.738281 0.777344 -2.902344 0.648438 -3.113281 C 0.519531 -3.324219 0.453125 -3.554688 0.453125 -3.808594 C 0.453125 -4.039062 0.507812 -4.253906 0.613281 -4.449219 C 0.71875 -4.648438 0.863281 -4.8125 1.046875 -4.941406 C 1.183594 -5.042969 1.367188 -5.128906 1.605469 -5.199219 C 1.839844 -5.269531 2.09375 -5.304688 2.363281 -5.304688 C 2.769531 -5.304688 3.128906 -5.242188 3.433594 -5.125 C 3.742188 -5.007812 3.96875 -4.851562 4.117188 -4.652344 C 4.261719 -4.453125 4.363281 -4.183594 4.417969 -3.847656 L 3.558594 -3.730469 C 3.519531 -3.996094 3.40625 -4.207031 3.21875 -4.355469 C 3.03125 -4.503906 2.769531 -4.578125 2.425781 -4.578125 C 2.023438 -4.578125 1.734375 -4.511719 1.5625 -4.378906 C 1.390625 -4.246094 1.304688 -4.089844 1.304688 -3.910156 C 1.304688 -3.796875 1.339844 -3.695312 1.410156 -3.601562 C 1.484375 -3.507812 1.59375 -3.429688 1.75 -3.367188 C 1.835938 -3.335938 2.09375 -3.261719 2.523438 -3.144531 C 3.144531 -2.976562 3.578125 -2.84375 3.824219 -2.738281 C 4.070312 -2.632812 4.265625 -2.476562 4.40625 -2.273438 C 4.546875 -2.074219 4.613281 -1.824219 4.613281 -1.523438 C 4.613281 -1.230469 4.527344 -0.953125 4.359375 -0.695312 C 4.1875 -0.4375 3.941406 -0.238281 3.617188 -0.09375 C 3.296875 0.046875 2.929688 0.117188 2.523438 0.117188 C 1.851562 0.117188 1.335938 -0.0234375 0.984375 -0.304688 C 0.632812 -0.582031 0.40625 -0.996094 0.308594 -1.546875 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph1-0">
-<path style="stroke:none;" d=""/>
-</symbol>
-<symbol overflow="visible" id="glyph1-1">
-<path style="stroke:none;" d="M 0.375 -1.6875 L 1.203125 -1.757812 C 1.265625 -1.351562 1.410156 -1.050781 1.632812 -0.847656 C 1.855469 -0.644531 2.125 -0.539062 2.445312 -0.539062 C 2.824219 -0.539062 3.148438 -0.683594 3.410156 -0.972656 C 3.671875 -1.257812 3.804688 -1.640625 3.804688 -2.113281 C 3.804688 -2.566406 3.679688 -2.921875 3.425781 -3.179688 C 3.171875 -3.441406 2.839844 -3.574219 2.429688 -3.574219 C 2.175781 -3.574219 1.945312 -3.515625 1.742188 -3.398438 C 1.535156 -3.28125 1.375 -3.132812 1.257812 -2.949219 L 0.515625 -3.046875 L 1.136719 -6.355469 L 4.34375 -6.355469 L 4.34375 -5.597656 L 1.769531 -5.597656 L 1.421875 -3.867188 C 1.808594 -4.136719 2.214844 -4.273438 2.640625 -4.273438 C 3.203125 -4.273438 3.679688 -4.078125 4.066406 -3.6875 C 4.453125 -3.296875 4.644531 -2.796875 4.644531 -2.183594 C 4.644531 -1.601562 4.476562 -1.097656 4.136719 -0.671875 C 3.722656 -0.152344 3.15625 0.109375 2.445312 0.109375 C 1.859375 0.109375 1.378906 -0.0546875 1.007812 -0.382812 C 0.636719 -0.710938 0.425781 -1.144531 0.375 -1.6875 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph1-2">
-<path style="stroke:none;" d="M 4.476562 -4.863281 L 3.691406 -4.804688 C 3.621094 -5.113281 3.523438 -5.339844 3.390625 -5.480469 C 3.179688 -5.707031 2.914062 -5.820312 2.601562 -5.820312 C 2.351562 -5.820312 2.128906 -5.75 1.9375 -5.609375 C 1.6875 -5.425781 1.492188 -5.160156 1.347656 -4.8125 C 1.203125 -4.464844 1.132812 -3.96875 1.125 -3.320312 C 1.316406 -3.613281 1.546875 -3.828125 1.824219 -3.96875 C 2.097656 -4.109375 2.386719 -4.179688 2.6875 -4.179688 C 3.214844 -4.179688 3.664062 -3.984375 4.035156 -3.597656 C 4.40625 -3.210938 4.59375 -2.707031 4.59375 -2.09375 C 4.59375 -1.6875 4.503906 -1.3125 4.332031 -0.964844 C 4.15625 -0.617188 3.917969 -0.351562 3.613281 -0.167969 C 3.308594 0.015625 2.960938 0.109375 2.574219 0.109375 C 1.914062 0.109375 1.378906 -0.132812 0.960938 -0.617188 C 0.546875 -1.101562 0.339844 -1.902344 0.339844 -3.015625 C 0.339844 -4.261719 0.570312 -5.164062 1.027344 -5.730469 C 1.429688 -6.222656 1.96875 -6.46875 2.648438 -6.46875 C 3.15625 -6.46875 3.570312 -6.328125 3.894531 -6.042969 C 4.21875 -5.757812 4.414062 -5.367188 4.476562 -4.863281 Z M 1.25 -2.085938 C 1.25 -1.8125 1.304688 -1.554688 1.421875 -1.304688 C 1.539062 -1.054688 1.699219 -0.867188 1.90625 -0.734375 C 2.113281 -0.605469 2.332031 -0.539062 2.5625 -0.539062 C 2.894531 -0.539062 3.183594 -0.675781 3.421875 -0.945312 C 3.664062 -1.214844 3.785156 -1.582031 3.785156 -2.042969 C 3.785156 -2.488281 3.664062 -2.839844 3.429688 -3.097656 C 3.191406 -3.351562 2.890625 -3.480469 2.53125 -3.480469 C 2.171875 -3.480469 1.871094 -3.351562 1.621094 -3.097656 C 1.371094 -2.839844 1.25 -2.503906 1.25 -2.085938 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph1-3">
-<path style="stroke:none;" d="M 0.425781 -5.597656 L 0.425781 -6.359375 L 4.597656 -6.359375 L 4.597656 -5.742188 C 4.1875 -5.304688 3.78125 -4.726562 3.378906 -4.003906 C 2.976562 -3.28125 2.664062 -2.535156 2.445312 -1.769531 C 2.285156 -1.230469 2.183594 -0.640625 2.140625 0 L 1.328125 0 C 1.335938 -0.507812 1.4375 -1.117188 1.625 -1.835938 C 1.816406 -2.554688 2.089844 -3.246094 2.445312 -3.914062 C 2.800781 -4.578125 3.179688 -5.140625 3.582031 -5.597656 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-0">
-<path style="stroke:none;" d=""/>
-</symbol>
-<symbol overflow="visible" id="glyph2-1">
-<path style="stroke:none;" d="M 0 -0.734375 L -7.15625 -0.734375 L -7.15625 -3.417969 C -7.15625 -3.964844 -7.085938 -4.402344 -6.941406 -4.734375 C -6.796875 -5.0625 -6.574219 -5.324219 -6.273438 -5.511719 C -5.972656 -5.699219 -5.65625 -5.789062 -5.328125 -5.789062 C -5.023438 -5.789062 -4.734375 -5.707031 -4.460938 -5.542969 C -4.191406 -5.375 -3.976562 -5.125 -3.808594 -4.789062 C -3.679688 -5.222656 -3.464844 -5.554688 -3.160156 -5.789062 C -2.851562 -6.023438 -2.492188 -6.136719 -2.074219 -6.136719 C -1.738281 -6.136719 -1.429688 -6.066406 -1.140625 -5.925781 C -0.851562 -5.785156 -0.628906 -5.609375 -0.472656 -5.398438 C -0.316406 -5.191406 -0.199219 -4.929688 -0.121094 -4.617188 C -0.0390625 -4.304688 0 -3.917969 0 -3.460938 Z M -4.148438 -1.679688 L -4.148438 -3.226562 C -4.148438 -3.648438 -4.179688 -3.949219 -4.234375 -4.132812 C -4.304688 -4.371094 -4.421875 -4.554688 -4.589844 -4.675781 C -4.757812 -4.796875 -4.964844 -4.859375 -5.214844 -4.859375 C -5.453125 -4.859375 -5.660156 -4.800781 -5.84375 -4.6875 C -6.023438 -4.574219 -6.148438 -4.410156 -6.214844 -4.199219 C -6.28125 -3.988281 -6.3125 -3.625 -6.3125 -3.109375 L -6.3125 -1.679688 Z M -0.84375 -1.679688 L -0.84375 -3.460938 C -0.84375 -3.765625 -0.855469 -3.984375 -0.878906 -4.105469 C -0.917969 -4.324219 -0.984375 -4.507812 -1.074219 -4.652344 C -1.164062 -4.800781 -1.296875 -4.921875 -1.472656 -5.015625 C -1.648438 -5.109375 -1.847656 -5.15625 -2.074219 -5.15625 C -2.34375 -5.15625 -2.574219 -5.085938 -2.769531 -4.953125 C -2.96875 -4.816406 -3.105469 -4.625 -3.1875 -4.382812 C -3.265625 -4.140625 -3.304688 -3.789062 -3.304688 -3.335938 L -3.304688 -1.679688 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-2">
-<path style="stroke:none;" d="M 1.996094 -0.621094 L 1.171875 -0.523438 C 1.222656 -0.714844 1.25 -0.882812 1.25 -1.023438 C 1.25 -1.21875 1.21875 -1.375 1.152344 -1.492188 C 1.085938 -1.609375 0.996094 -1.707031 0.878906 -1.78125 C 0.789062 -1.835938 0.574219 -1.925781 0.226562 -2.050781 C 0.175781 -2.066406 0.105469 -2.09375 0.0078125 -2.128906 L -5.1875 -0.160156 L -5.1875 -1.109375 L -2.183594 -2.1875 C -1.800781 -2.328125 -1.402344 -2.453125 -0.980469 -2.5625 C -1.382812 -2.664062 -1.777344 -2.785156 -2.164062 -2.925781 L -5.1875 -4.03125 L -5.1875 -4.914062 L 0.0859375 -2.9375 C 0.65625 -2.726562 1.050781 -2.5625 1.265625 -2.445312 C 1.554688 -2.289062 1.765625 -2.109375 1.902344 -1.910156 C 2.039062 -1.707031 2.105469 -1.464844 2.105469 -1.1875 C 2.105469 -1.015625 2.070312 -0.828125 1.996094 -0.621094 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-3">
-<path style="stroke:none;" d="M -0.785156 -2.578125 L -0.0078125 -2.703125 C 0.0429688 -2.457031 0.0703125 -2.234375 0.0703125 -2.039062 C 0.0703125 -1.722656 0.0195312 -1.476562 -0.0820312 -1.296875 C -0.183594 -1.121094 -0.316406 -1 -0.480469 -0.929688 C -0.644531 -0.855469 -0.992188 -0.820312 -1.519531 -0.820312 L -4.5 -0.820312 L -4.5 -0.175781 L -5.1875 -0.175781 L -5.1875 -0.820312 L -6.46875 -0.820312 L -6.996094 -1.695312 L -5.1875 -1.695312 L -5.1875 -2.578125 L -4.5 -2.578125 L -4.5 -1.695312 L -1.46875 -1.695312 C -1.21875 -1.695312 -1.058594 -1.710938 -0.984375 -1.742188 C -0.914062 -1.773438 -0.859375 -1.820312 -0.816406 -1.890625 C -0.773438 -1.960938 -0.75 -2.0625 -0.75 -2.191406 C -0.75 -2.289062 -0.761719 -2.417969 -0.785156 -2.578125 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-4">
-<path style="stroke:none;" d="M -1.671875 -4.210938 L -1.558594 -5.117188 C -1.027344 -4.972656 -0.617188 -4.707031 -0.320312 -4.320312 C -0.0273438 -3.933594 0.117188 -3.4375 0.117188 -2.835938 C 0.117188 -2.078125 -0.117188 -1.476562 -0.582031 -1.03125 C -1.050781 -0.585938 -1.707031 -0.367188 -2.546875 -0.367188 C -3.421875 -0.367188 -4.097656 -0.589844 -4.578125 -1.039062 C -5.0625 -1.488281 -5.304688 -2.070312 -5.304688 -2.789062 C -5.304688 -3.480469 -5.066406 -4.046875 -4.59375 -4.488281 C -4.121094 -4.925781 -3.457031 -5.148438 -2.601562 -5.148438 C -2.550781 -5.148438 -2.472656 -5.144531 -2.367188 -5.140625 L -2.367188 -1.273438 C -1.796875 -1.304688 -1.363281 -1.46875 -1.058594 -1.757812 C -0.757812 -2.046875 -0.605469 -2.410156 -0.605469 -2.84375 C -0.605469 -3.164062 -0.691406 -3.4375 -0.859375 -3.667969 C -1.027344 -3.894531 -1.296875 -4.074219 -1.671875 -4.210938 Z M -3.089844 -1.324219 L -3.089844 -4.21875 C -3.527344 -4.179688 -3.855469 -4.070312 -4.070312 -3.886719 C -4.410156 -3.605469 -4.578125 -3.242188 -4.578125 -2.796875 C -4.578125 -2.394531 -4.445312 -2.054688 -4.175781 -1.78125 C -3.90625 -1.503906 -3.542969 -1.351562 -3.089844 -1.324219 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph2-5">
-<path style="stroke:none;" d="M -1.546875 -0.308594 L -1.683594 -1.175781 C -1.335938 -1.226562 -1.070312 -1.363281 -0.882812 -1.585938 C -0.699219 -1.808594 -0.605469 -2.117188 -0.605469 -2.519531 C -0.605469 -2.921875 -0.6875 -3.222656 -0.851562 -3.417969 C -1.015625 -3.613281 -1.210938 -3.710938 -1.429688 -3.710938 C -1.628906 -3.710938 -1.785156 -3.625 -1.898438 -3.453125 C -1.976562 -3.332031 -2.078125 -3.03125 -2.195312 -2.554688 C -2.359375 -1.910156 -2.5 -1.460938 -2.621094 -1.214844 C -2.738281 -0.964844 -2.902344 -0.777344 -3.113281 -0.648438 C -3.324219 -0.519531 -3.554688 -0.453125 -3.808594 -0.453125 C -4.039062 -0.453125 -4.253906 -0.507812 -4.449219 -0.613281 C -4.648438 -0.71875 -4.8125 -0.863281 -4.941406 -1.046875 C -5.042969 -1.183594 -5.128906 -1.367188 -5.199219 -1.605469 C -5.269531 -1.839844 -5.304688 -2.09375 -5.304688 -2.363281 C -5.304688 -2.769531 -5.242188 -3.128906 -5.125 -3.433594 C -5.007812 -3.742188 -4.851562 -3.96875 -4.652344 -4.117188 C -4.453125 -4.261719 -4.183594 -4.363281 -3.847656 -4.417969 L -3.730469 -3.558594 C -3.996094 -3.519531 -4.207031 -3.40625 -4.355469 -3.21875 C -4.503906 -3.03125 -4.578125 -2.769531 -4.578125 -2.425781 C -4.578125 -2.023438 -4.511719 -1.734375 -4.378906 -1.5625 C -4.246094 -1.390625 -4.089844 -1.304688 -3.910156 -1.304688 C -3.796875 -1.304688 -3.695312 -1.339844 -3.601562 -1.410156 C -3.507812 -1.484375 -3.429688 -1.59375 -3.367188 -1.75 C -3.335938 -1.835938 -3.261719 -2.09375 -3.144531 -2.523438 C -2.976562 -3.144531 -2.84375 -3.578125 -2.738281 -3.824219 C -2.632812 -4.070312 -2.476562 -4.265625 -2.273438 -4.40625 C -2.074219 -4.546875 -1.824219 -4.613281 -1.523438 -4.613281 C -1.230469 -4.613281 -0.953125 -4.527344 -0.695312 -4.359375 C -0.4375 -4.1875 -0.238281 -3.941406 -0.09375 -3.617188 C 0.046875 -3.296875 0.117188 -2.929688 0.117188 -2.523438 C 0.117188 -1.851562 -0.0234375 -1.335938 -0.304688 -0.984375 C -0.582031 -0.632812 -0.996094 -0.40625 -1.546875 -0.308594 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-0">
-<path style="stroke:none;" d=""/>
-</symbol>
-<symbol overflow="visible" id="glyph3-1">
-<path style="stroke:none;" d="M 0.984375 0 L 0.984375 -8.589844 L 6.78125 -8.589844 L 6.78125 -7.578125 L 2.121094 -7.578125 L 2.121094 -4.914062 L 6.152344 -4.914062 L 6.152344 -3.902344 L 2.121094 -3.902344 L 2.121094 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-2">
-<path style="stroke:none;" d="M 0.796875 -7.375 L 0.796875 -8.589844 L 1.851562 -8.589844 L 1.851562 -7.375 Z M 0.796875 0 L 0.796875 -6.222656 L 1.851562 -6.222656 L 1.851562 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-3">
-<path style="stroke:none;" d="M 0.765625 0 L 0.765625 -8.589844 L 1.820312 -8.589844 L 1.820312 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-4">
-<path style="stroke:none;" d="M 5.050781 -2.003906 L 6.140625 -1.867188 C 5.96875 -1.230469 5.648438 -0.738281 5.1875 -0.386719 C 4.722656 -0.0351562 4.125 0.140625 3.40625 0.140625 C 2.496094 0.140625 1.773438 -0.140625 1.238281 -0.699219 C 0.707031 -1.261719 0.4375 -2.046875 0.4375 -3.058594 C 0.4375 -4.105469 0.710938 -4.917969 1.25 -5.496094 C 1.789062 -6.074219 2.484375 -6.363281 3.34375 -6.363281 C 4.175781 -6.363281 4.859375 -6.078125 5.382812 -5.515625 C 5.910156 -4.949219 6.175781 -4.148438 6.175781 -3.125 C 6.175781 -3.0625 6.171875 -2.96875 6.171875 -2.84375 L 1.53125 -2.84375 C 1.570312 -2.160156 1.761719 -1.632812 2.109375 -1.273438 C 2.457031 -0.910156 2.890625 -0.726562 3.410156 -0.726562 C 3.796875 -0.726562 4.125 -0.828125 4.398438 -1.03125 C 4.671875 -1.234375 4.890625 -1.558594 5.050781 -2.003906 Z M 1.585938 -3.710938 L 5.0625 -3.710938 C 5.015625 -4.234375 4.882812 -4.625 4.664062 -4.886719 C 4.328125 -5.292969 3.890625 -5.496094 3.359375 -5.496094 C 2.875 -5.496094 2.464844 -5.335938 2.136719 -5.007812 C 1.804688 -4.683594 1.625 -4.25 1.585938 -3.710938 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-5">
-<path style="stroke:none;" d="M 0.367188 -1.859375 L 1.414062 -2.023438 C 1.472656 -1.605469 1.632812 -1.28125 1.902344 -1.0625 C 2.167969 -0.839844 2.542969 -0.726562 3.023438 -0.726562 C 3.507812 -0.726562 3.867188 -0.824219 4.101562 -1.023438 C 4.335938 -1.21875 4.453125 -1.453125 4.453125 -1.71875 C 4.453125 -1.957031 4.351562 -2.140625 4.140625 -2.28125 C 3.996094 -2.375 3.640625 -2.492188 3.0625 -2.636719 C 2.289062 -2.832031 1.753906 -3 1.457031 -3.144531 C 1.15625 -3.285156 0.929688 -3.484375 0.777344 -3.734375 C 0.621094 -3.988281 0.546875 -4.265625 0.546875 -4.570312 C 0.546875 -4.847656 0.609375 -5.105469 0.734375 -5.339844 C 0.863281 -5.578125 1.035156 -5.773438 1.253906 -5.929688 C 1.417969 -6.050781 1.640625 -6.152344 1.925781 -6.238281 C 2.207031 -6.320312 2.511719 -6.363281 2.835938 -6.363281 C 3.324219 -6.363281 3.753906 -6.292969 4.121094 -6.152344 C 4.492188 -6.011719 4.765625 -5.820312 4.9375 -5.582031 C 5.113281 -5.339844 5.234375 -5.019531 5.304688 -4.617188 L 4.273438 -4.476562 C 4.226562 -4.796875 4.089844 -5.046875 3.863281 -5.226562 C 3.640625 -5.40625 3.320312 -5.496094 2.914062 -5.496094 C 2.429688 -5.496094 2.082031 -5.414062 1.875 -5.257812 C 1.667969 -5.097656 1.5625 -4.90625 1.5625 -4.695312 C 1.5625 -4.558594 1.609375 -4.433594 1.695312 -4.324219 C 1.78125 -4.210938 1.914062 -4.117188 2.097656 -4.042969 C 2.203125 -4.003906 2.515625 -3.914062 3.03125 -3.773438 C 3.777344 -3.574219 4.296875 -3.410156 4.589844 -3.285156 C 4.886719 -3.15625 5.117188 -2.972656 5.285156 -2.730469 C 5.453125 -2.488281 5.539062 -2.1875 5.539062 -1.828125 C 5.539062 -1.476562 5.433594 -1.144531 5.230469 -0.835938 C 5.023438 -0.523438 4.726562 -0.285156 4.34375 -0.113281 C 3.957031 0.0546875 3.515625 0.140625 3.03125 0.140625 C 2.222656 0.140625 1.605469 -0.0273438 1.179688 -0.363281 C 0.757812 -0.699219 0.484375 -1.195312 0.367188 -1.859375 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-6">
-<path style="stroke:none;" d="M 0.234375 0 L 0.234375 -0.855469 L 4.195312 -5.402344 C 3.746094 -5.378906 3.351562 -5.367188 3.007812 -5.367188 L 0.46875 -5.367188 L 0.46875 -6.222656 L 5.554688 -6.222656 L 5.554688 -5.523438 L 2.1875 -1.578125 L 1.535156 -0.855469 C 2.007812 -0.890625 2.453125 -0.90625 2.867188 -0.90625 L 5.742188 -0.90625 L 5.742188 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-7">
-<path style="stroke:none;" d="M 0.398438 -3.109375 C 0.398438 -4.261719 0.71875 -5.117188 1.359375 -5.671875 C 1.894531 -6.132812 2.546875 -6.363281 3.316406 -6.363281 C 4.171875 -6.363281 4.871094 -6.082031 5.414062 -5.523438 C 5.957031 -4.960938 6.226562 -4.1875 6.226562 -3.199219 C 6.226562 -2.398438 6.109375 -1.769531 5.867188 -1.308594 C 5.628906 -0.851562 5.277344 -0.492188 4.820312 -0.242188 C 4.359375 0.0117188 3.859375 0.140625 3.316406 0.140625 C 2.445312 0.140625 1.742188 -0.140625 1.203125 -0.695312 C 0.667969 -1.253906 0.398438 -2.0625 0.398438 -3.109375 Z M 1.484375 -3.109375 C 1.484375 -2.3125 1.65625 -1.71875 2.003906 -1.320312 C 2.351562 -0.925781 2.789062 -0.726562 3.316406 -0.726562 C 3.839844 -0.726562 4.273438 -0.925781 4.625 -1.324219 C 4.972656 -1.722656 5.144531 -2.328125 5.144531 -3.148438 C 5.144531 -3.917969 4.96875 -4.5 4.621094 -4.894531 C 4.269531 -5.292969 3.835938 -5.492188 3.316406 -5.492188 C 2.789062 -5.492188 2.351562 -5.292969 2.003906 -4.898438 C 1.65625 -4.503906 1.484375 -3.90625 1.484375 -3.109375 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-8">
-<path style="stroke:none;" d="M 1.042969 0 L 1.042969 -5.402344 L 0.109375 -5.402344 L 0.109375 -6.222656 L 1.042969 -6.222656 L 1.042969 -6.882812 C 1.042969 -7.300781 1.078125 -7.613281 1.15625 -7.816406 C 1.257812 -8.089844 1.433594 -8.3125 1.691406 -8.480469 C 1.945312 -8.652344 2.304688 -8.734375 2.765625 -8.734375 C 3.0625 -8.734375 3.390625 -8.703125 3.75 -8.632812 L 3.59375 -7.710938 C 3.375 -7.75 3.164062 -7.769531 2.96875 -7.769531 C 2.648438 -7.769531 2.421875 -7.703125 2.289062 -7.5625 C 2.15625 -7.425781 2.09375 -7.171875 2.09375 -6.796875 L 2.09375 -6.222656 L 3.304688 -6.222656 L 3.304688 -5.402344 L 2.09375 -5.402344 L 2.09375 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-9">
-<path style="stroke:none;" d="M 0.789062 0 L 0.789062 -6.222656 L 1.734375 -6.222656 L 1.734375 -5.351562 C 1.929688 -5.65625 2.1875 -5.898438 2.515625 -6.085938 C 2.839844 -6.269531 3.207031 -6.363281 3.621094 -6.363281 C 4.082031 -6.363281 4.460938 -6.265625 4.753906 -6.078125 C 5.050781 -5.886719 5.257812 -5.617188 5.378906 -5.273438 C 5.871094 -6 6.511719 -6.363281 7.300781 -6.363281 C 7.917969 -6.363281 8.390625 -6.191406 8.726562 -5.851562 C 9.058594 -5.507812 9.222656 -4.984375 9.222656 -4.273438 L 9.222656 0 L 8.171875 0 L 8.171875 -3.921875 C 8.171875 -4.34375 8.140625 -4.644531 8.070312 -4.832031 C 8.003906 -5.015625 7.878906 -5.164062 7.699219 -5.28125 C 7.519531 -5.394531 7.308594 -5.449219 7.066406 -5.449219 C 6.628906 -5.449219 6.265625 -5.304688 5.976562 -5.011719 C 5.6875 -4.722656 5.542969 -4.257812 5.542969 -3.617188 L 5.542969 0 L 4.488281 0 L 4.488281 -4.042969 C 4.488281 -4.511719 4.402344 -4.863281 4.230469 -5.097656 C 4.058594 -5.332031 3.777344 -5.449219 3.386719 -5.449219 C 3.089844 -5.449219 2.816406 -5.371094 2.5625 -5.214844 C 2.3125 -5.058594 2.128906 -4.828125 2.015625 -4.53125 C 1.902344 -4.230469 1.84375 -3.796875 1.84375 -3.226562 L 1.84375 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-10">
-<path style="stroke:none;" d="M 4.828125 0 L 4.828125 -0.785156 C 4.433594 -0.167969 3.851562 0.140625 3.085938 0.140625 C 2.589844 0.140625 2.136719 0.00390625 1.71875 -0.269531 C 1.304688 -0.542969 0.980469 -0.925781 0.753906 -1.414062 C 0.523438 -1.90625 0.410156 -2.46875 0.410156 -3.105469 C 0.410156 -3.726562 0.515625 -4.289062 0.71875 -4.796875 C 0.925781 -5.300781 1.238281 -5.6875 1.652344 -5.960938 C 2.066406 -6.230469 2.53125 -6.363281 3.039062 -6.363281 C 3.414062 -6.363281 3.75 -6.285156 4.042969 -6.125 C 4.335938 -5.96875 4.574219 -5.761719 4.757812 -5.507812 L 4.757812 -8.589844 L 5.804688 -8.589844 L 5.804688 0 Z M 1.492188 -3.105469 C 1.492188 -2.308594 1.664062 -1.710938 2 -1.320312 C 2.335938 -0.925781 2.730469 -0.726562 3.1875 -0.726562 C 3.648438 -0.726562 4.039062 -0.914062 4.363281 -1.292969 C 4.683594 -1.667969 4.84375 -2.242188 4.84375 -3.015625 C 4.84375 -3.867188 4.679688 -4.492188 4.351562 -4.890625 C 4.023438 -5.289062 3.621094 -5.492188 3.140625 -5.492188 C 2.671875 -5.492188 2.28125 -5.296875 1.964844 -4.914062 C 1.652344 -4.53125 1.492188 -3.929688 1.492188 -3.105469 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph3-11">
-<path style="stroke:none;" d="M 4.867188 0 L 4.867188 -0.914062 C 4.382812 -0.210938 3.726562 0.140625 2.894531 0.140625 C 2.527344 0.140625 2.183594 0.0703125 1.867188 -0.0703125 C 1.546875 -0.210938 1.3125 -0.386719 1.15625 -0.601562 C 1.003906 -0.8125 0.894531 -1.074219 0.832031 -1.382812 C 0.789062 -1.589844 0.765625 -1.917969 0.765625 -2.367188 L 0.765625 -6.222656 L 1.820312 -6.222656 L 1.820312 -2.773438 C 1.820312 -2.222656 1.84375 -1.851562 1.886719 -1.65625 C 1.953125 -1.378906 2.09375 -1.164062 2.308594 -1.003906 C 2.523438 -0.847656 2.789062 -0.765625 3.105469 -0.765625 C 3.421875 -0.765625 3.71875 -0.847656 3.996094 -1.011719 C 4.273438 -1.171875 4.46875 -1.394531 4.585938 -1.671875 C 4.699219 -1.953125 4.757812 -2.359375 4.757812 -2.890625 L 4.757812 -6.222656 L 5.8125 -6.222656 L 5.8125 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph4-0">
-<path style="stroke:none;" d=""/>
-</symbol>
-<symbol overflow="visible" id="glyph4-1">
-<path style="stroke:none;" d="M 0.953125 0 L 0.953125 -9.304688 L 4.445312 -9.304688 C 5.15625 -9.304688 5.722656 -9.210938 6.152344 -9.023438 C 6.582031 -8.835938 6.921875 -8.546875 7.164062 -8.152344 C 7.40625 -7.761719 7.527344 -7.351562 7.527344 -6.925781 C 7.527344 -6.527344 7.421875 -6.152344 7.203125 -5.800781 C 6.988281 -5.449219 6.664062 -5.167969 6.226562 -4.953125 C 6.789062 -4.785156 7.222656 -4.503906 7.523438 -4.105469 C 7.828125 -3.707031 7.980469 -3.238281 7.980469 -2.699219 C 7.980469 -2.261719 7.886719 -1.855469 7.703125 -1.480469 C 7.519531 -1.105469 7.292969 -0.820312 7.019531 -0.617188 C 6.75 -0.414062 6.410156 -0.257812 6 -0.15625 C 5.59375 -0.0507812 5.09375 0 4.5 0 Z M 2.183594 -5.394531 L 4.195312 -5.394531 C 4.742188 -5.394531 5.132812 -5.429688 5.371094 -5.503906 C 5.683594 -5.597656 5.917969 -5.75 6.078125 -5.96875 C 6.238281 -6.183594 6.316406 -6.453125 6.316406 -6.78125 C 6.316406 -7.089844 6.242188 -7.359375 6.09375 -7.59375 C 5.945312 -7.828125 5.734375 -7.992188 5.460938 -8.078125 C 5.183594 -8.164062 4.710938 -8.207031 4.042969 -8.207031 L 2.183594 -8.207031 Z M 2.183594 -1.097656 L 4.5 -1.097656 C 4.898438 -1.097656 5.175781 -1.113281 5.339844 -1.140625 C 5.621094 -1.191406 5.859375 -1.277344 6.050781 -1.398438 C 6.242188 -1.515625 6.394531 -1.6875 6.519531 -1.914062 C 6.640625 -2.140625 6.703125 -2.402344 6.703125 -2.699219 C 6.703125 -3.046875 6.613281 -3.347656 6.4375 -3.601562 C 6.257812 -3.859375 6.011719 -4.039062 5.695312 -4.140625 C 5.382812 -4.246094 4.929688 -4.296875 4.335938 -4.296875 L 2.183594 -4.296875 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph4-2">
-<path style="stroke:none;" d="M 0.429688 -3.371094 C 0.429688 -4.617188 0.777344 -5.542969 1.472656 -6.144531 C 2.050781 -6.644531 2.757812 -6.894531 3.59375 -6.894531 C 4.519531 -6.894531 5.277344 -6.589844 5.867188 -5.984375 C 6.453125 -5.375 6.746094 -4.535156 6.746094 -3.464844 C 6.746094 -2.597656 6.617188 -1.914062 6.355469 -1.417969 C 6.097656 -0.921875 5.71875 -0.535156 5.222656 -0.261719 C 4.722656 0.015625 4.179688 0.152344 3.59375 0.152344 C 2.648438 0.152344 1.886719 -0.148438 1.304688 -0.753906 C 0.722656 -1.359375 0.429688 -2.230469 0.429688 -3.371094 Z M 1.605469 -3.371094 C 1.605469 -2.507812 1.792969 -1.859375 2.171875 -1.429688 C 2.546875 -1 3.023438 -0.789062 3.59375 -0.789062 C 4.160156 -0.789062 4.632812 -1.003906 5.007812 -1.433594 C 5.382812 -1.867188 5.574219 -2.523438 5.574219 -3.410156 C 5.574219 -4.242188 5.382812 -4.875 5.003906 -5.304688 C 4.625 -5.734375 4.15625 -5.949219 3.59375 -5.949219 C 3.023438 -5.949219 2.546875 -5.734375 2.171875 -5.304688 C 1.792969 -4.878906 1.605469 -4.234375 1.605469 -3.371094 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph4-3">
-<path style="stroke:none;" d="M 0.398438 -2.011719 L 1.53125 -2.191406 C 1.59375 -1.738281 1.769531 -1.390625 2.058594 -1.148438 C 2.347656 -0.90625 2.753906 -0.789062 3.273438 -0.789062 C 3.800781 -0.789062 4.1875 -0.894531 4.445312 -1.109375 C 4.699219 -1.320312 4.824219 -1.570312 4.824219 -1.859375 C 4.824219 -2.117188 4.710938 -2.320312 4.488281 -2.46875 C 4.332031 -2.570312 3.941406 -2.699219 3.320312 -2.855469 C 2.480469 -3.066406 1.902344 -3.25 1.578125 -3.40625 C 1.253906 -3.558594 1.007812 -3.773438 0.839844 -4.046875 C 0.671875 -4.320312 0.589844 -4.621094 0.589844 -4.953125 C 0.589844 -5.253906 0.660156 -5.53125 0.796875 -5.785156 C 0.933594 -6.042969 1.121094 -6.253906 1.359375 -6.421875 C 1.535156 -6.554688 1.777344 -6.667969 2.085938 -6.757812 C 2.390625 -6.847656 2.722656 -6.894531 3.070312 -6.894531 C 3.601562 -6.894531 4.066406 -6.816406 4.464844 -6.664062 C 4.867188 -6.511719 5.160156 -6.304688 5.351562 -6.046875 C 5.542969 -5.785156 5.671875 -5.4375 5.746094 -5 L 4.628906 -4.851562 C 4.578125 -5.195312 4.429688 -5.46875 4.1875 -5.664062 C 3.945312 -5.859375 3.597656 -5.953125 3.15625 -5.953125 C 2.628906 -5.953125 2.253906 -5.867188 2.03125 -5.695312 C 1.808594 -5.519531 1.695312 -5.316406 1.695312 -5.085938 C 1.695312 -4.9375 1.742188 -4.804688 1.835938 -4.683594 C 1.929688 -4.5625 2.074219 -4.460938 2.273438 -4.378906 C 2.386719 -4.335938 2.722656 -4.242188 3.28125 -4.085938 C 4.089844 -3.871094 4.652344 -3.695312 4.972656 -3.558594 C 5.292969 -3.421875 5.542969 -3.21875 5.726562 -2.957031 C 5.90625 -2.695312 6 -2.371094 6 -1.980469 C 6 -1.601562 5.886719 -1.242188 5.664062 -0.90625 C 5.441406 -0.570312 5.121094 -0.308594 4.703125 -0.125 C 4.285156 0.0585938 3.8125 0.152344 3.28125 0.152344 C 2.40625 0.152344 1.738281 -0.03125 1.277344 -0.394531 C 0.820312 -0.757812 0.527344 -1.296875 0.398438 -2.011719 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph4-4">
-<path style="stroke:none;" d="M 3.351562 -1.023438 L 3.515625 -0.0117188 C 3.195312 0.0546875 2.90625 0.0898438 2.652344 0.0898438 C 2.238281 0.0898438 1.917969 0.0234375 1.6875 -0.109375 C 1.460938 -0.238281 1.300781 -0.410156 1.207031 -0.625 C 1.113281 -0.839844 1.066406 -1.289062 1.066406 -1.972656 L 1.066406 -5.851562 L 0.226562 -5.851562 L 0.226562 -6.742188 L 1.066406 -6.742188 L 1.066406 -8.410156 L 2.203125 -9.097656 L 2.203125 -6.742188 L 3.351562 -6.742188 L 3.351562 -5.851562 L 2.203125 -5.851562 L 2.203125 -1.910156 C 2.203125 -1.585938 2.222656 -1.375 2.261719 -1.28125 C 2.304688 -1.1875 2.367188 -1.113281 2.460938 -1.058594 C 2.550781 -1.003906 2.679688 -0.976562 2.851562 -0.976562 C 2.976562 -0.976562 3.144531 -0.992188 3.351562 -1.023438 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph4-5">
-<path style="stroke:none;" d="M 1.179688 0 L 1.179688 -1.300781 L 2.480469 -1.300781 L 2.480469 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph4-6">
-<path style="stroke:none;" d="M 1.003906 0 L 1.003906 -9.304688 L 4.511719 -9.304688 C 5.128906 -9.304688 5.601562 -9.277344 5.929688 -9.21875 C 6.386719 -9.140625 6.769531 -8.996094 7.078125 -8.78125 C 7.386719 -8.566406 7.636719 -8.269531 7.824219 -7.882812 C 8.011719 -7.5 8.105469 -7.074219 8.105469 -6.613281 C 8.105469 -5.824219 7.855469 -5.152344 7.351562 -4.605469 C 6.847656 -4.058594 5.9375 -3.78125 4.621094 -3.78125 L 2.234375 -3.78125 L 2.234375 0 Z M 2.234375 -4.882812 L 4.640625 -4.882812 C 5.4375 -4.882812 6 -5.03125 6.335938 -5.324219 C 6.667969 -5.621094 6.835938 -6.039062 6.835938 -6.578125 C 6.835938 -6.964844 6.738281 -7.296875 6.542969 -7.574219 C 6.34375 -7.851562 6.085938 -8.035156 5.765625 -8.125 C 5.558594 -8.179688 5.171875 -8.207031 4.613281 -8.207031 L 2.234375 -8.207031 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph4-7">
-<path style="stroke:none;" d="M 0.804688 2.597656 L 0.679688 1.523438 C 0.929688 1.589844 1.148438 1.625 1.332031 1.625 C 1.585938 1.625 1.789062 1.582031 1.941406 1.5 C 2.09375 1.414062 2.21875 1.296875 2.316406 1.140625 C 2.390625 1.027344 2.503906 0.746094 2.664062 0.292969 C 2.6875 0.230469 2.722656 0.136719 2.765625 0.0117188 L 0.210938 -6.742188 L 1.441406 -6.742188 L 2.84375 -2.835938 C 3.027344 -2.34375 3.1875 -1.820312 3.332031 -1.277344 C 3.464844 -1.800781 3.621094 -2.3125 3.800781 -2.8125 L 5.242188 -6.742188 L 6.386719 -6.742188 L 3.820312 0.113281 C 3.546875 0.855469 3.332031 1.363281 3.179688 1.644531 C 2.976562 2.019531 2.746094 2.296875 2.480469 2.472656 C 2.21875 2.648438 1.90625 2.734375 1.542969 2.734375 C 1.324219 2.734375 1.078125 2.6875 0.804688 2.597656 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph4-8">
-<path style="stroke:none;" d="M 0.855469 0 L 0.855469 -9.304688 L 2 -9.304688 L 2 -5.96875 C 2.53125 -6.585938 3.207031 -6.894531 4.019531 -6.894531 C 4.519531 -6.894531 4.953125 -6.796875 5.320312 -6.597656 C 5.6875 -6.402344 5.949219 -6.128906 6.109375 -5.78125 C 6.269531 -5.433594 6.347656 -4.933594 6.347656 -4.273438 L 6.347656 0 L 5.203125 0 L 5.203125 -4.273438 C 5.203125 -4.84375 5.082031 -5.257812 4.832031 -5.519531 C 4.585938 -5.78125 4.234375 -5.910156 3.78125 -5.910156 C 3.445312 -5.910156 3.125 -5.820312 2.828125 -5.644531 C 2.53125 -5.46875 2.316406 -5.234375 2.191406 -4.933594 C 2.0625 -4.632812 2 -4.21875 2 -3.6875 L 2 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph4-9">
-<path style="stroke:none;" d="M 0.855469 0 L 0.855469 -6.742188 L 1.886719 -6.742188 L 1.886719 -5.78125 C 2.382812 -6.523438 3.09375 -6.894531 4.03125 -6.894531 C 4.4375 -6.894531 4.808594 -6.820312 5.152344 -6.675781 C 5.492188 -6.527344 5.746094 -6.335938 5.914062 -6.101562 C 6.085938 -5.863281 6.203125 -5.582031 6.273438 -5.257812 C 6.3125 -5.046875 6.335938 -4.675781 6.335938 -4.144531 L 6.335938 0 L 5.191406 0 L 5.191406 -4.101562 C 5.191406 -4.566406 5.148438 -4.914062 5.058594 -5.144531 C 4.96875 -5.375 4.8125 -5.558594 4.585938 -5.695312 C 4.359375 -5.835938 4.09375 -5.902344 3.789062 -5.902344 C 3.304688 -5.902344 2.882812 -5.75 2.53125 -5.441406 C 2.175781 -5.132812 2 -4.546875 2 -3.679688 L 2 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph4-10">
-<path style="stroke:none;" d="M 0.855469 2.582031 L 0.855469 -6.742188 L 1.898438 -6.742188 L 1.898438 -5.867188 C 2.144531 -6.207031 2.421875 -6.464844 2.730469 -6.636719 C 3.039062 -6.808594 3.414062 -6.894531 3.851562 -6.894531 C 4.429688 -6.894531 4.9375 -6.746094 5.375 -6.449219 C 5.816406 -6.152344 6.148438 -5.734375 6.375 -5.195312 C 6.597656 -4.65625 6.710938 -4.066406 6.710938 -3.421875 C 6.710938 -2.730469 6.585938 -2.109375 6.339844 -1.558594 C 6.089844 -1.007812 5.730469 -0.582031 5.257812 -0.289062 C 4.785156 0.00390625 4.289062 0.152344 3.769531 0.152344 C 3.390625 0.152344 3.046875 0.0703125 2.746094 -0.0898438 C 2.441406 -0.25 2.195312 -0.453125 2 -0.699219 L 2 2.582031 Z M 1.890625 -3.332031 C 1.890625 -2.464844 2.066406 -1.824219 2.417969 -1.410156 C 2.769531 -0.996094 3.195312 -0.789062 3.695312 -0.789062 C 4.203125 -0.789062 4.636719 -1 5 -1.429688 C 5.359375 -1.859375 5.542969 -2.527344 5.542969 -3.429688 C 5.542969 -4.289062 5.363281 -4.929688 5.011719 -5.359375 C 4.65625 -5.785156 4.234375 -6 3.746094 -6 C 3.257812 -6 2.828125 -5.769531 2.453125 -5.316406 C 2.078125 -4.859375 1.890625 -4.199219 1.890625 -3.332031 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph4-11">
-<path style="stroke:none;" d="M 1.910156 0 L 0.851562 0 L 0.851562 -9.304688 L 1.992188 -9.304688 L 1.992188 -5.984375 C 2.476562 -6.589844 3.089844 -6.894531 3.839844 -6.894531 C 4.253906 -6.894531 4.648438 -6.808594 5.019531 -6.644531 C 5.390625 -6.476562 5.691406 -6.242188 5.933594 -5.9375 C 6.171875 -5.636719 6.359375 -5.269531 6.492188 -4.84375 C 6.628906 -4.414062 6.695312 -3.957031 6.695312 -3.472656 C 6.695312 -2.316406 6.410156 -1.425781 5.839844 -0.792969 C 5.269531 -0.164062 4.582031 0.152344 3.78125 0.152344 C 2.988281 0.152344 2.363281 -0.179688 1.910156 -0.84375 Z M 1.898438 -3.421875 C 1.898438 -2.613281 2.007812 -2.027344 2.226562 -1.667969 C 2.585938 -1.082031 3.074219 -0.789062 3.6875 -0.789062 C 4.1875 -0.789062 4.617188 -1.003906 4.984375 -1.4375 C 5.347656 -1.871094 5.527344 -2.519531 5.527344 -3.375 C 5.527344 -4.257812 5.355469 -4.90625 5.003906 -5.324219 C 4.65625 -5.742188 4.234375 -5.953125 3.738281 -5.953125 C 3.238281 -5.953125 2.808594 -5.738281 2.445312 -5.304688 C 2.082031 -4.871094 1.898438 -4.242188 1.898438 -3.421875 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph4-12">
-<path style="stroke:none;" d="M 0.863281 -7.992188 L 0.863281 -9.304688 L 2.007812 -9.304688 L 2.007812 -7.992188 Z M 0.863281 0 L 0.863281 -6.742188 L 2.007812 -6.742188 L 2.007812 0 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph4-13">
-<path style="stroke:none;" d="M 5.230469 0 L 5.230469 -0.851562 C 4.804688 -0.183594 4.175781 0.152344 3.34375 0.152344 C 2.808594 0.152344 2.3125 0.00390625 1.863281 -0.292969 C 1.414062 -0.589844 1.0625 -1 0.816406 -1.53125 C 0.570312 -2.0625 0.445312 -2.675781 0.445312 -3.363281 C 0.445312 -4.035156 0.554688 -4.648438 0.78125 -5.195312 C 1.003906 -5.742188 1.339844 -6.164062 1.789062 -6.457031 C 2.238281 -6.75 2.738281 -6.894531 3.292969 -6.894531 C 3.699219 -6.894531 4.0625 -6.808594 4.378906 -6.636719 C 4.695312 -6.464844 4.957031 -6.242188 5.15625 -5.96875 L 5.15625 -9.304688 L 6.289062 -9.304688 L 6.289062 0 Z M 1.617188 -3.363281 C 1.617188 -2.5 1.800781 -1.855469 2.164062 -1.429688 C 2.527344 -1 2.957031 -0.789062 3.453125 -0.789062 C 3.953125 -0.789062 4.375 -0.992188 4.726562 -1.398438 C 5.074219 -1.808594 5.25 -2.429688 5.25 -3.269531 C 5.25 -4.191406 5.070312 -4.867188 4.714844 -5.300781 C 4.359375 -5.730469 3.921875 -5.949219 3.402344 -5.949219 C 2.894531 -5.949219 2.46875 -5.742188 2.128906 -5.324219 C 1.789062 -4.910156 1.617188 -4.257812 1.617188 -3.363281 Z "/>
-</symbol>
-<symbol overflow="visible" id="glyph4-14">
-<path style="stroke:none;" d="M 4.84375 0 L 3.699219 0 L 3.699219 -7.28125 C 3.425781 -7.019531 3.066406 -6.757812 2.617188 -6.492188 C 2.171875 -6.230469 1.769531 -6.035156 1.414062 -5.902344 L 1.414062 -7.007812 C 2.054688 -7.308594 2.613281 -7.671875 3.089844 -8.101562 C 3.570312 -8.527344 3.90625 -8.941406 4.105469 -9.34375 L 4.84375 -9.34375 Z "/>
-</symbol>
-</g>
-<clipPath id="clip1">
- <path d="M 94 19 L 96 19 L 96 215 L 94 215 Z "/>
-</clipPath>
-<clipPath id="clip2">
- <path d="M 204 19 L 206 19 L 206 215 L 204 215 Z "/>
-</clipPath>
-<clipPath id="clip3">
- <path d="M 314 19 L 316 19 L 316 215 L 314 215 Z "/>
-</clipPath>
-<clipPath id="clip4">
- <path d="M 39 171 L 355 171 L 355 173 L 39 173 Z "/>
-</clipPath>
-<clipPath id="clip5">
- <path d="M 39 107 L 355 107 L 355 109 L 39 109 Z "/>
-</clipPath>
-<clipPath id="clip6">
- <path d="M 39 44 L 355 44 L 355 46 L 39 46 Z "/>
-</clipPath>
-</defs>
-<g id="surface18">
-<g clip-path="url(#clip1)" clip-rule="nonzero">
-<path style="fill:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:0.5;stroke-dasharray:1,2;stroke-miterlimit:3.25;" d="M 95.160156 214.296875 L 95.160156 19 "/>
-</g>
-<g clip-path="url(#clip2)" clip-rule="nonzero">
-<path style="fill:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:0.5;stroke-dasharray:1,2;stroke-miterlimit:3.25;" d="M 204.84375 214.296875 L 204.84375 19 "/>
-</g>
-<g clip-path="url(#clip3)" clip-rule="nonzero">
-<path style="fill:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:0.5;stroke-dasharray:1,2;stroke-miterlimit:3.25;" d="M 314.53125 214.296875 L 314.53125 19 "/>
-</g>
-<g clip-path="url(#clip4)" clip-rule="nonzero">
-<path style="fill:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:0.5;stroke-dasharray:1,2;stroke-miterlimit:3.25;" d="M 39 171.960938 L 355 171.960938 "/>
-</g>
-<g clip-path="url(#clip5)" clip-rule="nonzero">
-<path style="fill:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:0.5;stroke-dasharray:1,2;stroke-miterlimit:3.25;" d="M 39 108.234375 L 355 108.234375 "/>
-</g>
-<g clip-path="url(#clip6)" clip-rule="nonzero">
-<path style="fill:none;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:0.5;stroke-dasharray:1,2;stroke-miterlimit:3.25;" d="M 39 44.511719 L 355 44.511719 "/>
-</g>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 55.070312 201 C 55.070312 200.183594 54.75 199.402344 54.171875 198.828125 C 53.597656 198.25 52.816406 197.929688 52 197.929688 C 51.183594 197.929688 50.402344 198.25 49.828125 198.828125 C 49.25 199.402344 48.929688 200.183594 48.929688 201 C 48.929688 201.816406 49.25 202.597656 49.828125 203.171875 C 50.402344 203.75 51.183594 204.070312 52 204.070312 C 52.816406 204.070312 53.597656 203.75 54.171875 203.171875 C 54.75 202.597656 55.070312 201.816406 55.070312 201 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 88.070312 176 C 88.070312 175.183594 87.75 174.402344 87.171875 173.828125 C 86.597656 173.25 85.816406 172.929688 85 172.929688 C 84.183594 172.929688 83.402344 173.25 82.828125 173.828125 C 82.25 174.402344 81.929688 175.183594 81.929688 176 C 81.929688 176.816406 82.25 177.597656 82.828125 178.171875 C 83.402344 178.75 84.183594 179.070312 85 179.070312 C 85.816406 179.070312 86.597656 178.75 87.171875 178.171875 C 87.75 177.597656 88.070312 176.816406 88.070312 176 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 121.070312 160 C 121.070312 159.183594 120.75 158.402344 120.171875 157.828125 C 119.597656 157.25 118.816406 156.929688 118 156.929688 C 117.183594 156.929688 116.402344 157.25 115.828125 157.828125 C 115.25 158.402344 114.929688 159.183594 114.929688 160 C 114.929688 160.816406 115.25 161.597656 115.828125 162.171875 C 116.402344 162.75 117.183594 163.070312 118 163.070312 C 118.816406 163.070312 119.597656 162.75 120.171875 162.171875 C 120.75 161.597656 121.070312 160.816406 121.070312 160 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 154.070312 142 C 154.070312 141.183594 153.75 140.402344 153.171875 139.828125 C 152.597656 139.25 151.816406 138.929688 151 138.929688 C 150.183594 138.929688 149.402344 139.25 148.828125 139.828125 C 148.25 140.402344 147.929688 141.183594 147.929688 142 C 147.929688 142.816406 148.25 143.597656 148.828125 144.171875 C 149.402344 144.75 150.183594 145.070312 151 145.070312 C 151.816406 145.070312 152.597656 144.75 153.171875 144.171875 C 153.75 143.597656 154.070312 142.816406 154.070312 142 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 187.070312 124 C 187.070312 123.183594 186.75 122.402344 186.171875 121.828125 C 185.597656 121.25 184.816406 120.929688 184 120.929688 C 183.183594 120.929688 182.402344 121.25 181.828125 121.828125 C 181.25 122.402344 180.929688 123.183594 180.929688 124 C 180.929688 124.816406 181.25 125.597656 181.828125 126.171875 C 182.402344 126.75 183.183594 127.070312 184 127.070312 C 184.816406 127.070312 185.597656 126.75 186.171875 126.171875 C 186.75 125.597656 187.070312 124.816406 187.070312 124 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 220.070312 105 C 220.070312 104.183594 219.75 103.402344 219.171875 102.828125 C 218.597656 102.25 217.816406 101.929688 217 101.929688 C 216.183594 101.929688 215.402344 102.25 214.828125 102.828125 C 214.25 103.402344 213.929688 104.183594 213.929688 105 C 213.929688 105.816406 214.25 106.597656 214.828125 107.171875 C 215.402344 107.75 216.183594 108.070312 217 108.070312 C 217.816406 108.070312 218.597656 107.75 219.171875 107.171875 C 219.75 106.597656 220.070312 105.816406 220.070312 105 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 253.070312 86 C 253.070312 85.183594 252.75 84.402344 252.171875 83.828125 C 251.597656 83.25 250.816406 82.929688 250 82.929688 C 249.183594 82.929688 248.402344 83.25 247.828125 83.828125 C 247.25 84.402344 246.929688 85.183594 246.929688 86 C 246.929688 86.816406 247.25 87.597656 247.828125 88.171875 C 248.402344 88.75 249.183594 89.070312 250 89.070312 C 250.816406 89.070312 251.597656 88.75 252.171875 88.171875 C 252.75 87.597656 253.070312 86.816406 253.070312 86 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 286.070312 67 C 286.070312 66.183594 285.75 65.402344 285.171875 64.828125 C 284.597656 64.25 283.816406 63.929688 283 63.929688 C 282.183594 63.929688 281.402344 64.25 280.828125 64.828125 C 280.25 65.402344 279.929688 66.183594 279.929688 67 C 279.929688 67.816406 280.25 68.597656 280.828125 69.171875 C 281.402344 69.75 282.183594 70.070312 283 70.070312 C 283.816406 70.070312 284.597656 69.75 285.171875 69.171875 C 285.75 68.597656 286.070312 67.816406 286.070312 67 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 319.070312 48 C 319.070312 47.183594 318.75 46.402344 318.171875 45.828125 C 317.597656 45.25 316.816406 44.929688 316 44.929688 C 315.183594 44.929688 314.402344 45.25 313.828125 45.828125 C 313.25 46.402344 312.929688 47.183594 312.929688 48 C 312.929688 48.816406 313.25 49.597656 313.828125 50.171875 C 314.402344 50.75 315.183594 51.070312 316 51.070312 C 316.816406 51.070312 317.597656 50.75 318.171875 50.171875 C 318.75 49.597656 319.070312 48.816406 319.070312 48 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 352.070312 29 C 352.070312 28.183594 351.75 27.402344 351.171875 26.828125 C 350.597656 26.25 349.816406 25.929688 349 25.929688 C 348.183594 25.929688 347.402344 26.25 346.828125 26.828125 C 346.25 27.402344 345.929688 28.183594 345.929688 29 C 345.929688 29.816406 346.25 30.597656 346.828125 31.171875 C 347.402344 31.75 348.183594 32.070312 349 32.070312 C 349.816406 32.070312 350.597656 31.75 351.171875 31.171875 C 351.75 30.597656 352.070312 29.816406 352.070312 29 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 55.070312 191 C 55.070312 190.183594 54.75 189.402344 54.171875 188.828125 C 53.597656 188.25 52.816406 187.929688 52 187.929688 C 51.183594 187.929688 50.402344 188.25 49.828125 188.828125 C 49.25 189.402344 48.929688 190.183594 48.929688 191 C 48.929688 191.816406 49.25 192.597656 49.828125 193.171875 C 50.402344 193.75 51.183594 194.070312 52 194.070312 C 52.816406 194.070312 53.597656 193.75 54.171875 193.171875 C 54.75 192.597656 55.070312 191.816406 55.070312 191 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 88.070312 181 C 88.070312 180.183594 87.75 179.402344 87.171875 178.828125 C 86.597656 178.25 85.816406 177.929688 85 177.929688 C 84.183594 177.929688 83.402344 178.25 82.828125 178.828125 C 82.25 179.402344 81.929688 180.183594 81.929688 181 C 81.929688 181.816406 82.25 182.597656 82.828125 183.171875 C 83.402344 183.75 84.183594 184.070312 85 184.070312 C 85.816406 184.070312 86.597656 183.75 87.171875 183.171875 C 87.75 182.597656 88.070312 181.816406 88.070312 181 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 121.070312 170 C 121.070312 169.183594 120.75 168.402344 120.171875 167.828125 C 119.597656 167.25 118.816406 166.929688 118 166.929688 C 117.183594 166.929688 116.402344 167.25 115.828125 167.828125 C 115.25 168.402344 114.929688 169.183594 114.929688 170 C 114.929688 170.816406 115.25 171.597656 115.828125 172.171875 C 116.402344 172.75 117.183594 173.070312 118 173.070312 C 118.816406 173.070312 119.597656 172.75 120.171875 172.171875 C 120.75 171.597656 121.070312 170.816406 121.070312 170 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 154.070312 157 C 154.070312 156.183594 153.75 155.402344 153.171875 154.828125 C 152.597656 154.25 151.816406 153.929688 151 153.929688 C 150.183594 153.929688 149.402344 154.25 148.828125 154.828125 C 148.25 155.402344 147.929688 156.183594 147.929688 157 C 147.929688 157.816406 148.25 158.597656 148.828125 159.171875 C 149.402344 159.75 150.183594 160.070312 151 160.070312 C 151.816406 160.070312 152.597656 159.75 153.171875 159.171875 C 153.75 158.597656 154.070312 157.816406 154.070312 157 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 187.070312 142 C 187.070312 141.183594 186.75 140.402344 186.171875 139.828125 C 185.597656 139.25 184.816406 138.929688 184 138.929688 C 183.183594 138.929688 182.402344 139.25 181.828125 139.828125 C 181.25 140.402344 180.929688 141.183594 180.929688 142 C 180.929688 142.816406 181.25 143.597656 181.828125 144.171875 C 182.402344 144.75 183.183594 145.070312 184 145.070312 C 184.816406 145.070312 185.597656 144.75 186.171875 144.171875 C 186.75 143.597656 187.070312 142.816406 187.070312 142 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 220.070312 125 C 220.070312 124.183594 219.75 123.402344 219.171875 122.828125 C 218.597656 122.25 217.816406 121.929688 217 121.929688 C 216.183594 121.929688 215.402344 122.25 214.828125 122.828125 C 214.25 123.402344 213.929688 124.183594 213.929688 125 C 213.929688 125.816406 214.25 126.597656 214.828125 127.171875 C 215.402344 127.75 216.183594 128.070312 217 128.070312 C 217.816406 128.070312 218.597656 127.75 219.171875 127.171875 C 219.75 126.597656 220.070312 125.816406 220.070312 125 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 253.070312 107 C 253.070312 106.183594 252.75 105.402344 252.171875 104.828125 C 251.597656 104.25 250.816406 103.929688 250 103.929688 C 249.183594 103.929688 248.402344 104.25 247.828125 104.828125 C 247.25 105.402344 246.929688 106.183594 246.929688 107 C 246.929688 107.816406 247.25 108.597656 247.828125 109.171875 C 248.402344 109.75 249.183594 110.070312 250 110.070312 C 250.816406 110.070312 251.597656 109.75 252.171875 109.171875 C 252.75 108.597656 253.070312 107.816406 253.070312 107 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 286.070312 88 C 286.070312 87.183594 285.75 86.402344 285.171875 85.828125 C 284.597656 85.25 283.816406 84.929688 283 84.929688 C 282.183594 84.929688 281.402344 85.25 280.828125 85.828125 C 280.25 86.402344 279.929688 87.183594 279.929688 88 C 279.929688 88.816406 280.25 89.597656 280.828125 90.171875 C 281.402344 90.75 282.183594 91.070312 283 91.070312 C 283.816406 91.070312 284.597656 90.75 285.171875 90.171875 C 285.75 89.597656 286.070312 88.816406 286.070312 88 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 319.070312 69 C 319.070312 68.183594 318.75 67.402344 318.171875 66.828125 C 317.597656 66.25 316.816406 65.929688 316 65.929688 C 315.183594 65.929688 314.402344 66.25 313.828125 66.828125 C 313.25 67.402344 312.929688 68.183594 312.929688 69 C 312.929688 69.816406 313.25 70.597656 313.828125 71.171875 C 314.402344 71.75 315.183594 72.070312 316 72.070312 C 316.816406 72.070312 317.597656 71.75 318.171875 71.171875 C 318.75 70.597656 319.070312 69.816406 319.070312 69 Z "/>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 352.070312 50 C 352.070312 49.183594 351.75 48.402344 351.171875 47.828125 C 350.597656 47.25 349.816406 46.929688 349 46.929688 C 348.183594 46.929688 347.402344 47.25 346.828125 47.828125 C 346.25 48.402344 345.929688 49.183594 345.929688 50 C 345.929688 50.816406 346.25 51.597656 346.828125 52.171875 C 347.402344 52.75 348.183594 53.070312 349 53.070312 C 349.816406 53.070312 350.597656 52.75 351.171875 52.171875 C 351.75 51.597656 352.070312 50.816406 352.070312 50 Z "/>
-<path style="fill:none;stroke-width:0.5;stroke-linecap:square;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 214.296875 L 39 214.296875 "/>
-<path style="fill:none;stroke-width:0.5;stroke-linecap:square;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 214.296875 L 39 19 "/>
-<path style="fill:none;stroke-width:0.5;stroke-linecap:square;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 19 L 355 19 "/>
-<path style="fill:none;stroke-width:0.5;stroke-linecap:square;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 19 L 355 214.296875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 95.160156 214.296875 L 95.160156 211.140625 "/>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph0-1" x="89.659467" y="226.29874"/>
- <use xlink:href="#glyph0-2" x="95.220991" y="226.29874"/>
-</g>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 204.84375 214.296875 L 204.84375 211.140625 "/>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph0-1" x="196.345465" y="226.29874"/>
- <use xlink:href="#glyph0-2" x="201.906989" y="226.29874"/>
- <use xlink:href="#glyph0-2" x="207.468512" y="226.29874"/>
-</g>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 314.53125 214.296875 L 314.53125 211.140625 "/>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph0-1" x="303.531463" y="226.29874"/>
- <use xlink:href="#glyph0-2" x="309.092987" y="226.29874"/>
- <use xlink:href="#glyph0-2" x="314.65451" y="226.29874"/>
- <use xlink:href="#glyph0-2" x="320.216034" y="226.29874"/>
-</g>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 51.511719 214.296875 L 51.511719 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 62.140625 214.296875 L 62.140625 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 70.824219 214.296875 L 70.824219 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 78.167969 214.296875 L 78.167969 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 84.53125 214.296875 L 84.53125 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 90.140625 214.296875 L 90.140625 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 128.179688 214.296875 L 128.179688 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 147.492188 214.296875 L 147.492188 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 161.195312 214.296875 L 161.195312 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 171.828125 214.296875 L 171.828125 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 180.511719 214.296875 L 180.511719 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 187.855469 214.296875 L 187.855469 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 194.214844 214.296875 L 194.214844 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 199.828125 214.296875 L 199.828125 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 237.863281 214.296875 L 237.863281 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 257.179688 214.296875 L 257.179688 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 270.882812 214.296875 L 270.882812 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 281.511719 214.296875 L 281.511719 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 290.199219 214.296875 L 290.199219 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 297.539062 214.296875 L 297.539062 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 303.902344 214.296875 L 303.902344 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 309.511719 214.296875 L 309.511719 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 347.550781 214.296875 L 347.550781 212.71875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 171.960938 L 42.160156 171.960938 "/>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph0-1" x="19" y="176.961688"/>
- <use xlink:href="#glyph0-2" x="24.561523" y="176.961688"/>
-</g>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph1-1" x="30" y="172.81325"/>
-</g>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 108.234375 L 42.160156 108.234375 "/>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph0-1" x="19" y="113.23603"/>
- <use xlink:href="#glyph0-2" x="24.561523" y="113.23603"/>
-</g>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph1-2" x="30" y="109.087593"/>
-</g>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 44.511719 L 42.160156 44.511719 "/>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph0-1" x="19" y="49.510373"/>
- <use xlink:href="#glyph0-2" x="24.561523" y="49.510373"/>
-</g>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph1-3" x="30" y="45.361936"/>
-</g>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 205.28125 L 40.578125 205.28125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 197.320312 L 40.578125 197.320312 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 191.144531 L 40.578125 191.144531 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 186.097656 L 40.578125 186.097656 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 181.832031 L 40.578125 181.832031 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 178.136719 L 40.578125 178.136719 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 174.878906 L 40.578125 174.878906 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 152.777344 L 40.578125 152.777344 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 141.558594 L 40.578125 141.558594 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 133.59375 L 40.578125 133.59375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 127.417969 L 40.578125 127.417969 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 122.375 L 40.578125 122.375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 118.105469 L 40.578125 118.105469 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 114.410156 L 40.578125 114.410156 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 111.152344 L 40.578125 111.152344 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 89.050781 L 40.578125 89.050781 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 77.832031 L 40.578125 77.832031 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 69.871094 L 40.578125 69.871094 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 63.695312 L 40.578125 63.695312 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 58.648438 L 40.578125 58.648438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 54.382812 L 40.578125 54.382812 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 50.6875 L 40.578125 50.6875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 47.425781 L 40.578125 47.425781 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 39 25.328125 L 40.578125 25.328125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 95.160156 19 L 95.160156 22.160156 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 204.84375 19 L 204.84375 22.160156 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 314.53125 19 L 314.53125 22.160156 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 51.511719 19 L 51.511719 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 62.140625 19 L 62.140625 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 70.824219 19 L 70.824219 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 78.167969 19 L 78.167969 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 84.53125 19 L 84.53125 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 90.140625 19 L 90.140625 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 128.179688 19 L 128.179688 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 147.492188 19 L 147.492188 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 161.195312 19 L 161.195312 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 171.828125 19 L 171.828125 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 180.511719 19 L 180.511719 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 187.855469 19 L 187.855469 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 194.214844 19 L 194.214844 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 199.828125 19 L 199.828125 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 237.863281 19 L 237.863281 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 257.179688 19 L 257.179688 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 270.882812 19 L 270.882812 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 281.511719 19 L 281.511719 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 290.199219 19 L 290.199219 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 297.539062 19 L 297.539062 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 303.902344 19 L 303.902344 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 309.511719 19 L 309.511719 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 347.550781 19 L 347.550781 20.578125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 171.960938 L 351.839844 171.960938 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 108.234375 L 351.839844 108.234375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 44.511719 L 351.839844 44.511719 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 205.28125 L 353.421875 205.28125 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 197.320312 L 353.421875 197.320312 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 191.144531 L 353.421875 191.144531 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 186.097656 L 353.421875 186.097656 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 181.832031 L 353.421875 181.832031 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 178.136719 L 353.421875 178.136719 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 174.878906 L 353.421875 174.878906 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 152.777344 L 353.421875 152.777344 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 141.558594 L 353.421875 141.558594 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 133.59375 L 353.421875 133.59375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 127.417969 L 353.421875 127.417969 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 122.375 L 353.421875 122.375 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 118.105469 L 353.421875 118.105469 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 114.410156 L 353.421875 114.410156 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 111.152344 L 353.421875 111.152344 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 89.050781 L 353.421875 89.050781 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 77.832031 L 353.421875 77.832031 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 69.871094 L 353.421875 69.871094 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 63.695312 L 353.421875 63.695312 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 58.648438 L 353.421875 58.648438 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 54.382812 L 353.421875 54.382812 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 50.6875 L 353.421875 50.6875 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 47.425781 L 353.421875 47.425781 "/>
-<path style="fill:none;stroke-width:0.1;stroke-linecap:butt;stroke-linejoin:miter;stroke:rgb(39.99939%,39.99939%,39.99939%);stroke-opacity:1;stroke-miterlimit:3.25;" d="M 355 25.328125 L 353.421875 25.328125 "/>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph0-3" x="175.5" y="245.29874"/>
- <use xlink:href="#glyph0-4" x="181.608398" y="245.29874"/>
- <use xlink:href="#glyph0-5" x="187.169922" y="245.29874"/>
- <use xlink:href="#glyph0-6" x="192.731445" y="245.29874"/>
- <use xlink:href="#glyph0-7" x="197.731445" y="245.29874"/>
- <use xlink:href="#glyph0-8" x="200.509766" y="245.29874"/>
- <use xlink:href="#glyph0-9" x="202.731445" y="245.29874"/>
- <use xlink:href="#glyph0-5" x="208.292969" y="245.29874"/>
- <use xlink:href="#glyph0-10" x="213.854492" y="245.29874"/>
-</g>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph2-1" x="9" y="129.14937"/>
- <use xlink:href="#glyph2-2" x="9" y="122.479448"/>
- <use xlink:href="#glyph2-3" x="9" y="117.479448"/>
- <use xlink:href="#glyph2-4" x="9" y="114.701128"/>
- <use xlink:href="#glyph2-5" x="9" y="109.139605"/>
-</g>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph3-1" x="148" y="12"/>
- <use xlink:href="#glyph3-2" x="155.330078" y="12"/>
- <use xlink:href="#glyph3-3" x="157.996094" y="12"/>
- <use xlink:href="#glyph3-4" x="160.662109" y="12"/>
-</g>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph3-5" x="170" y="12"/>
- <use xlink:href="#glyph3-2" x="176" y="12"/>
- <use xlink:href="#glyph3-6" x="178.666016" y="12"/>
- <use xlink:href="#glyph3-4" x="184.666016" y="12"/>
-</g>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph3-7" x="194" y="12"/>
- <use xlink:href="#glyph3-8" x="200.673828" y="12"/>
-</g>
-<g style="fill:rgb(39.99939%,39.99939%,39.99939%);fill-opacity:1;">
- <use xlink:href="#glyph3-9" x="207" y="12"/>
- <use xlink:href="#glyph3-7" x="216.996094" y="12"/>
- <use xlink:href="#glyph3-10" x="223.669922" y="12"/>
- <use xlink:href="#glyph3-11" x="230.34375" y="12"/>
- <use xlink:href="#glyph3-3" x="237.017578" y="12"/>
- <use xlink:href="#glyph3-4" x="239.683594" y="12"/>
-</g>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(36.84082%,50.67749%,70.979309%);fill-opacity:1;" d="M 382.148438 113 C 382.148438 112.164062 381.816406 111.363281 381.226562 110.773438 C 380.636719 110.183594 379.835938 109.851562 379 109.851562 C 378.164062 109.851562 377.363281 110.183594 376.773438 110.773438 C 376.183594 111.363281 375.851562 112.164062 375.851562 113 C 375.851562 113.835938 376.183594 114.636719 376.773438 115.226562 C 377.363281 115.816406 378.164062 116.148438 379 116.148438 C 379.835938 116.148438 380.636719 115.816406 381.226562 115.226562 C 381.816406 114.636719 382.148438 113.835938 382.148438 113 Z "/>
-<g style="fill:rgb(0%,0%,0%);fill-opacity:1;">
- <use xlink:href="#glyph4-1" x="391" y="117.28418"/>
- <use xlink:href="#glyph4-2" x="399.670898" y="117.28418"/>
- <use xlink:href="#glyph4-2" x="406.901367" y="117.28418"/>
- <use xlink:href="#glyph4-3" x="414.131836" y="117.28418"/>
- <use xlink:href="#glyph4-4" x="420.631836" y="117.28418"/>
-</g>
-<g style="fill:rgb(0%,0%,0%);fill-opacity:1;">
- <use xlink:href="#glyph4-5" x="424" y="117.28418"/>
-</g>
-<g style="fill:rgb(0%,0%,0%);fill-opacity:1;">
- <use xlink:href="#glyph4-6" x="428" y="117.28418"/>
- <use xlink:href="#glyph4-7" x="436.670898" y="117.28418"/>
- <use xlink:href="#glyph4-4" x="443.170898" y="117.28418"/>
- <use xlink:href="#glyph4-8" x="446.783203" y="117.28418"/>
- <use xlink:href="#glyph4-2" x="454.013672" y="117.28418"/>
- <use xlink:href="#glyph4-9" x="461.244141" y="117.28418"/>
-</g>
-<path style=" stroke:none;fill-rule:evenodd;fill:rgb(88.070679%,61.103821%,14.204407%);fill-opacity:1;" d="M 382.148438 136 C 382.148438 135.164062 381.816406 134.363281 381.226562 133.773438 C 380.636719 133.183594 379.835938 132.851562 379 132.851562 C 378.164062 132.851562 377.363281 133.183594 376.773438 133.773438 C 376.183594 134.363281 375.851562 135.164062 375.851562 136 C 375.851562 136.835938 376.183594 137.636719 376.773438 138.226562 C 377.363281 138.816406 378.164062 139.148438 379 139.148438 C 379.835938 139.148438 380.636719 138.816406 381.226562 138.226562 C 381.816406 137.636719 382.148438 136.835938 382.148438 136 Z "/>
-<g style="fill:rgb(0%,0%,0%);fill-opacity:1;">
- <use xlink:href="#glyph4-10" x="391" y="140.28418"/>
- <use xlink:href="#glyph4-7" x="398.230469" y="140.28418"/>
- <use xlink:href="#glyph4-11" x="404.730469" y="140.28418"/>
- <use xlink:href="#glyph4-12" x="411.960938" y="140.28418"/>
- <use xlink:href="#glyph4-9" x="414.849609" y="140.28418"/>
- <use xlink:href="#glyph4-13" x="422.080078" y="140.28418"/>
- <use xlink:href="#glyph4-14" x="429.310547" y="140.28418"/>
- <use xlink:href="#glyph4-14" x="436.541016" y="140.28418"/>
-</g>
-</g>
-</svg>
diff --git a/thirdparty/pybind11/pybind11/docs/reference.rst b/thirdparty/pybind11/pybind11/docs/reference.rst
deleted file mode 100644
index 3d211f7e96b0c425ddfd358c23c7f5ac2d48acd2..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/reference.rst
+++ /dev/null
@@ -1,80 +0,0 @@
-.. _reference:
-
-.. warning::
-
- Please be advised that the reference documentation discussing pybind11
- internals is currently incomplete. Please refer to the previous sections
- and the pybind11 header files for the nitty gritty details.
-
-Reference
-#########
-
-Macros
-======
-
-.. doxygendefine:: PYBIND11_PLUGIN
-
-.. _core_types:
-
-Convenience classes for arbitrary Python types
-==============================================
-
-Common member functions
------------------------
-
-.. doxygenclass:: object_api
- :members:
-
-Without reference counting
---------------------------
-
-.. doxygenclass:: handle
- :members:
-
-With reference counting
------------------------
-
-.. doxygenclass:: object
- :members:
-
-.. doxygenfunction:: reinterpret_borrow
-
-.. doxygenfunction:: reinterpret_steal
-
-Convenience classes for specific Python types
-=============================================
-
-.. doxygenclass:: module
- :members:
-
-.. doxygengroup:: pytypes
- :members:
-
-.. _extras:
-
-Passing extra arguments to ``def`` or ``class_``
-================================================
-
-.. doxygengroup:: annotations
- :members:
-
-Python build-in functions
-=========================
-
-.. doxygengroup:: python_builtins
- :members:
-
-Exceptions
-==========
-
-.. doxygenclass:: error_already_set
- :members:
-
-.. doxygenclass:: builtin_exception
- :members:
-
-
-Literals
-========
-
-.. doxygennamespace:: literals
diff --git a/thirdparty/pybind11/pybind11/docs/release.rst b/thirdparty/pybind11/pybind11/docs/release.rst
deleted file mode 100644
index 30d159a6f5f18dfaf2184ad82b63edf687d43adc..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/release.rst
+++ /dev/null
@@ -1,24 +0,0 @@
-To release a new version of pybind11:
-
-- Update the version number and push to pypi
- - Update ``pybind11/_version.py`` (set release version, remove 'dev').
- - Update ``PYBIND11_VERSION_MAJOR`` etc. in ``include/pybind11/common.h``.
- - Ensure that all the information in ``setup.py`` is up-to-date.
- - Update version in ``docs/conf.py``.
- - Tag release date in ``docs/changelog.rst``.
- - ``git add`` and ``git commit``.
- - if new minor version: ``git checkout -b vX.Y``, ``git push -u origin vX.Y``
- - ``git tag -a vX.Y.Z -m 'vX.Y.Z release'``.
- - ``git push``
- - ``git push --tags``.
- - ``python setup.py sdist upload``.
- - ``python setup.py bdist_wheel upload``.
-- Update conda-forge (https://github.com/conda-forge/pybind11-feedstock) via PR
- - change version number in ``recipe/meta.yml``
- - update checksum to match the one computed by pypi
-- Get back to work
- - Update ``_version.py`` (add 'dev' and increment minor).
- - Update version in ``docs/conf.py``
- - Update version macros in ``include/pybind11/common.h``
- - ``git add`` and ``git commit``.
- ``git push``
diff --git a/thirdparty/pybind11/pybind11/docs/requirements.txt b/thirdparty/pybind11/pybind11/docs/requirements.txt
deleted file mode 100644
index 3818fe80eecc9e91b3a164885d94dffda28d8d35..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/docs/requirements.txt
+++ /dev/null
@@ -1 +0,0 @@
-breathe == 4.5.0
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/attr.h b/thirdparty/pybind11/pybind11/include/pybind11/attr.h
deleted file mode 100644
index e38a1a32debea10f51ab60bebc609caa5b46272e..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/attr.h
+++ /dev/null
@@ -1,422 +0,0 @@
-/*
- pybind11/pybind11.h: Infrastructure for processing custom
- type and function attributes
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "cast.h"
-
-NAMESPACE_BEGIN(pybind11)
-
-/// \addtogroup annotations
-/// @{
-
-/// Annotation for methods
-struct is_method { handle class_; is_method(const handle &c) : class_(c) { } };
-
-/// Annotation for operators
-struct is_operator { };
-
-/// Annotation for parent scope
-struct scope { handle value; scope(const handle &s) : value(s) { } };
-
-/// Annotation for documentation
-struct doc { const char *value; doc(const char *value) : value(value) { } };
-
-/// Annotation for function names
-struct name { const char *value; name(const char *value) : value(value) { } };
-
-/// Annotation indicating that a function is an overload associated with a given "sibling"
-struct sibling { handle value; sibling(const handle &value) : value(value.ptr()) { } };
-
-/// Annotation indicating that a class derives from another given type
-template <typename T> struct base {
- PYBIND11_DEPRECATED("base<T>() was deprecated in favor of specifying 'T' as a template argument to class_")
- base() { }
-};
-
-/// Keep patient alive while nurse lives
-template <size_t Nurse, size_t Patient> struct keep_alive { };
-
-/// Annotation indicating that a class is involved in a multiple inheritance relationship
-struct multiple_inheritance { };
-
-/// Annotation which enables dynamic attributes, i.e. adds `__dict__` to a class
-struct dynamic_attr { };
-
-/// Annotation which enables the buffer protocol for a type
-struct buffer_protocol { };
-
-/// Annotation which requests that a special metaclass is created for a type
-struct metaclass {
- handle value;
-
- PYBIND11_DEPRECATED("py::metaclass() is no longer required. It's turned on by default now.")
- metaclass() = default;
-
- /// Override pybind11's default metaclass
- explicit metaclass(handle value) : value(value) { }
-};
-
-/// Annotation to mark enums as an arithmetic type
-struct arithmetic { };
-
-/// @} annotations
-
-NAMESPACE_BEGIN(detail)
-/* Forward declarations */
-enum op_id : int;
-enum op_type : int;
-struct undefined_t;
-template <op_id id, op_type ot, typename L = undefined_t, typename R = undefined_t> struct op_;
-template <typename... Args> struct init;
-template <typename... Args> struct init_alias;
-inline void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret);
-
-/// Internal data structure which holds metadata about a keyword argument
-struct argument_record {
- const char *name; ///< Argument name
- const char *descr; ///< Human-readable version of the argument value
- handle value; ///< Associated Python object
- bool convert : 1; ///< True if the argument is allowed to convert when loading
-
- argument_record(const char *name, const char *descr, handle value, bool convert)
- : name(name), descr(descr), value(value), convert(convert) { }
-};
-
-/// Internal data structure which holds metadata about a bound function (signature, overloads, etc.)
-struct function_record {
- function_record()
- : is_constructor(false), is_stateless(false), is_operator(false),
- has_args(false), has_kwargs(false), is_method(false) { }
-
- /// Function name
- char *name = nullptr; /* why no C++ strings? They generate heavier code.. */
-
- // User-specified documentation string
- char *doc = nullptr;
-
- /// Human-readable version of the function signature
- char *signature = nullptr;
-
- /// List of registered keyword arguments
- std::vector<argument_record> args;
-
- /// Pointer to lambda function which converts arguments and performs the actual call
- handle (*impl) (function_call &) = nullptr;
-
- /// Storage for the wrapped function pointer and captured data, if any
- void *data[3] = { };
-
- /// Pointer to custom destructor for 'data' (if needed)
- void (*free_data) (function_record *ptr) = nullptr;
-
- /// Return value policy associated with this function
- return_value_policy policy = return_value_policy::automatic;
-
- /// True if name == '__init__'
- bool is_constructor : 1;
-
- /// True if this is a stateless function pointer
- bool is_stateless : 1;
-
- /// True if this is an operator (__add__), etc.
- bool is_operator : 1;
-
- /// True if the function has a '*args' argument
- bool has_args : 1;
-
- /// True if the function has a '**kwargs' argument
- bool has_kwargs : 1;
-
- /// True if this is a method
- bool is_method : 1;
-
- /// Number of arguments (including py::args and/or py::kwargs, if present)
- std::uint16_t nargs;
-
- /// Python method object
- PyMethodDef *def = nullptr;
-
- /// Python handle to the parent scope (a class or a module)
- handle scope;
-
- /// Python handle to the sibling function representing an overload chain
- handle sibling;
-
- /// Pointer to next overload
- function_record *next = nullptr;
-};
-
-/// Special data structure which (temporarily) holds metadata about a bound class
-struct type_record {
- PYBIND11_NOINLINE type_record()
- : multiple_inheritance(false), dynamic_attr(false), buffer_protocol(false) { }
-
- /// Handle to the parent scope
- handle scope;
-
- /// Name of the class
- const char *name = nullptr;
-
- // Pointer to RTTI type_info data structure
- const std::type_info *type = nullptr;
-
- /// How large is the underlying C++ type?
- size_t type_size = 0;
-
- /// How large is pybind11::instance<type>?
- size_t instance_size = 0;
-
- /// The global operator new can be overridden with a class-specific variant
- void *(*operator_new)(size_t) = ::operator new;
-
- /// Function pointer to class_<..>::init_holder
- void (*init_holder)(PyObject *, const void *) = nullptr;
-
- /// Function pointer to class_<..>::dealloc
- void (*dealloc)(PyObject *) = nullptr;
-
- /// List of base classes of the newly created type
- list bases;
-
- /// Optional docstring
- const char *doc = nullptr;
-
- /// Custom metaclass (optional)
- handle metaclass;
-
- /// Multiple inheritance marker
- bool multiple_inheritance : 1;
-
- /// Does the class manage a __dict__?
- bool dynamic_attr : 1;
-
- /// Does the class implement the buffer protocol?
- bool buffer_protocol : 1;
-
- /// Is the default (unique_ptr) holder type used?
- bool default_holder : 1;
-
- PYBIND11_NOINLINE void add_base(const std::type_info *base, void *(*caster)(void *)) {
- auto base_info = detail::get_type_info(*base, false);
- if (!base_info) {
- std::string tname(base->name());
- detail::clean_type_id(tname);
- pybind11_fail("generic_type: type \"" + std::string(name) +
- "\" referenced unknown base type \"" + tname + "\"");
- }
-
- if (default_holder != base_info->default_holder) {
- std::string tname(base->name());
- detail::clean_type_id(tname);
- pybind11_fail("generic_type: type \"" + std::string(name) + "\" " +
- (default_holder ? "does not have" : "has") +
- " a non-default holder type while its base \"" + tname + "\" " +
- (base_info->default_holder ? "does not" : "does"));
- }
-
- bases.append((PyObject *) base_info->type);
-
- if (base_info->type->tp_dictoffset != 0)
- dynamic_attr = true;
-
- if (caster)
- base_info->implicit_casts.push_back(std::make_pair(type, caster));
- }
-};
-
-inline function_call::function_call(function_record &f, handle p) :
- func(f), parent(p) {
- args.reserve(f.nargs);
- args_convert.reserve(f.nargs);
-}
-
-/**
- * Partial template specializations to process custom attributes provided to
- * cpp_function_ and class_. These are either used to initialize the respective
- * fields in the type_record and function_record data structures or executed at
- * runtime to deal with custom call policies (e.g. keep_alive).
- */
-template <typename T, typename SFINAE = void> struct process_attribute;
-
-template <typename T> struct process_attribute_default {
- /// Default implementation: do nothing
- static void init(const T &, function_record *) { }
- static void init(const T &, type_record *) { }
- static void precall(function_call &) { }
- static void postcall(function_call &, handle) { }
-};
-
-/// Process an attribute specifying the function's name
-template <> struct process_attribute<name> : process_attribute_default<name> {
- static void init(const name &n, function_record *r) { r->name = const_cast<char *>(n.value); }
-};
-
-/// Process an attribute specifying the function's docstring
-template <> struct process_attribute<doc> : process_attribute_default<doc> {
- static void init(const doc &n, function_record *r) { r->doc = const_cast<char *>(n.value); }
-};
-
-/// Process an attribute specifying the function's docstring (provided as a C-style string)
-template <> struct process_attribute<const char *> : process_attribute_default<const char *> {
- static void init(const char *d, function_record *r) { r->doc = const_cast<char *>(d); }
- static void init(const char *d, type_record *r) { r->doc = const_cast<char *>(d); }
-};
-template <> struct process_attribute<char *> : process_attribute<const char *> { };
-
-/// Process an attribute indicating the function's return value policy
-template <> struct process_attribute<return_value_policy> : process_attribute_default<return_value_policy> {
- static void init(const return_value_policy &p, function_record *r) { r->policy = p; }
-};
-
-/// Process an attribute which indicates that this is an overloaded function associated with a given sibling
-template <> struct process_attribute<sibling> : process_attribute_default<sibling> {
- static void init(const sibling &s, function_record *r) { r->sibling = s.value; }
-};
-
-/// Process an attribute which indicates that this function is a method
-template <> struct process_attribute<is_method> : process_attribute_default<is_method> {
- static void init(const is_method &s, function_record *r) { r->is_method = true; r->scope = s.class_; }
-};
-
-/// Process an attribute which indicates the parent scope of a method
-template <> struct process_attribute<scope> : process_attribute_default<scope> {
- static void init(const scope &s, function_record *r) { r->scope = s.value; }
-};
-
-/// Process an attribute which indicates that this function is an operator
-template <> struct process_attribute<is_operator> : process_attribute_default<is_operator> {
- static void init(const is_operator &, function_record *r) { r->is_operator = true; }
-};
-
-/// Process a keyword argument attribute (*without* a default value)
-template <> struct process_attribute<arg> : process_attribute_default<arg> {
- static void init(const arg &a, function_record *r) {
- if (r->is_method && r->args.empty())
- r->args.emplace_back("self", nullptr, handle(), true /*convert*/);
- r->args.emplace_back(a.name, nullptr, handle(), !a.flag_noconvert);
- }
-};
-
-/// Process a keyword argument attribute (*with* a default value)
-template <> struct process_attribute<arg_v> : process_attribute_default<arg_v> {
- static void init(const arg_v &a, function_record *r) {
- if (r->is_method && r->args.empty())
- r->args.emplace_back("self", nullptr /*descr*/, handle() /*parent*/, true /*convert*/);
-
- if (!a.value) {
-#if !defined(NDEBUG)
- std::string descr("'");
- if (a.name) descr += std::string(a.name) + ": ";
- descr += a.type + "'";
- if (r->is_method) {
- if (r->name)
- descr += " in method '" + (std::string) str(r->scope) + "." + (std::string) r->name + "'";
- else
- descr += " in method of '" + (std::string) str(r->scope) + "'";
- } else if (r->name) {
- descr += " in function '" + (std::string) r->name + "'";
- }
- pybind11_fail("arg(): could not convert default argument "
- + descr + " into a Python object (type not registered yet?)");
-#else
- pybind11_fail("arg(): could not convert default argument "
- "into a Python object (type not registered yet?). "
- "Compile in debug mode for more information.");
-#endif
- }
- r->args.emplace_back(a.name, a.descr, a.value.inc_ref(), !a.flag_noconvert);
- }
-};
-
-/// Process a parent class attribute. Single inheritance only (class_ itself already guarantees that)
-template <typename T>
-struct process_attribute<T, enable_if_t<is_pyobject<T>::value>> : process_attribute_default<handle> {
- static void init(const handle &h, type_record *r) { r->bases.append(h); }
-};
-
-/// Process a parent class attribute (deprecated, does not support multiple inheritance)
-template <typename T>
-struct process_attribute<base<T>> : process_attribute_default<base<T>> {
- static void init(const base<T> &, type_record *r) { r->add_base(&typeid(T), nullptr); }
-};
-
-/// Process a multiple inheritance attribute
-template <>
-struct process_attribute<multiple_inheritance> : process_attribute_default<multiple_inheritance> {
- static void init(const multiple_inheritance &, type_record *r) { r->multiple_inheritance = true; }
-};
-
-template <>
-struct process_attribute<dynamic_attr> : process_attribute_default<dynamic_attr> {
- static void init(const dynamic_attr &, type_record *r) { r->dynamic_attr = true; }
-};
-
-template <>
-struct process_attribute<buffer_protocol> : process_attribute_default<buffer_protocol> {
- static void init(const buffer_protocol &, type_record *r) { r->buffer_protocol = true; }
-};
-
-template <>
-struct process_attribute<metaclass> : process_attribute_default<metaclass> {
- static void init(const metaclass &m, type_record *r) { r->metaclass = m.value; }
-};
-
-
-/// Process an 'arithmetic' attribute for enums (does nothing here)
-template <>
-struct process_attribute<arithmetic> : process_attribute_default<arithmetic> {};
-
-/***
- * Process a keep_alive call policy -- invokes keep_alive_impl during the
- * pre-call handler if both Nurse, Patient != 0 and use the post-call handler
- * otherwise
- */
-template <size_t Nurse, size_t Patient> struct process_attribute<keep_alive<Nurse, Patient>> : public process_attribute_default<keep_alive<Nurse, Patient>> {
- template <size_t N = Nurse, size_t P = Patient, enable_if_t<N != 0 && P != 0, int> = 0>
- static void precall(function_call &call) { keep_alive_impl(Nurse, Patient, call, handle()); }
- template <size_t N = Nurse, size_t P = Patient, enable_if_t<N != 0 && P != 0, int> = 0>
- static void postcall(function_call &, handle) { }
- template <size_t N = Nurse, size_t P = Patient, enable_if_t<N == 0 || P == 0, int> = 0>
- static void precall(function_call &) { }
- template <size_t N = Nurse, size_t P = Patient, enable_if_t<N == 0 || P == 0, int> = 0>
- static void postcall(function_call &call, handle ret) { keep_alive_impl(Nurse, Patient, call, ret); }
-};
-
-/// Recursively iterate over variadic template arguments
-template <typename... Args> struct process_attributes {
- static void init(const Args&... args, function_record *r) {
- int unused[] = { 0, (process_attribute<typename std::decay<Args>::type>::init(args, r), 0) ... };
- ignore_unused(unused);
- }
- static void init(const Args&... args, type_record *r) {
- int unused[] = { 0, (process_attribute<typename std::decay<Args>::type>::init(args, r), 0) ... };
- ignore_unused(unused);
- }
- static void precall(function_call &call) {
- int unused[] = { 0, (process_attribute<typename std::decay<Args>::type>::precall(call), 0) ... };
- ignore_unused(unused);
- }
- static void postcall(function_call &call, handle fn_ret) {
- int unused[] = { 0, (process_attribute<typename std::decay<Args>::type>::postcall(call, fn_ret), 0) ... };
- ignore_unused(unused);
- }
-};
-
-/// Check the number of named arguments at compile time
-template <typename... Extra,
- size_t named = constexpr_sum(std::is_base_of<arg, Extra>::value...),
- size_t self = constexpr_sum(std::is_same<is_method, Extra>::value...)>
-constexpr bool expected_num_args(size_t nargs, bool has_args, bool has_kwargs) {
- return named == 0 || (self + named + has_args + has_kwargs) == nargs;
-}
-
-NAMESPACE_END(detail)
-NAMESPACE_END(pybind11)
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/cast.h b/thirdparty/pybind11/pybind11/include/pybind11/cast.h
deleted file mode 100644
index fe19075e45843e6245e1a3a26aed6fa7b10470c2..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/cast.h
+++ /dev/null
@@ -1,1604 +0,0 @@
-/*
- pybind11/cast.h: Partial template specializations to cast between
- C++ and Python types
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "pytypes.h"
-#include "typeid.h"
-#include "descr.h"
-#include <array>
-#include <limits>
-
-NAMESPACE_BEGIN(pybind11)
-NAMESPACE_BEGIN(detail)
-inline PyTypeObject *make_static_property_type();
-inline PyTypeObject *make_default_metaclass();
-
-/// Additional type information which does not fit into the PyTypeObject
-struct type_info {
- PyTypeObject *type;
- size_t type_size;
- void *(*operator_new)(size_t);
- void (*init_holder)(PyObject *, const void *);
- void (*dealloc)(PyObject *);
- std::vector<PyObject *(*)(PyObject *, PyTypeObject *)> implicit_conversions;
- std::vector<std::pair<const std::type_info *, void *(*)(void *)>> implicit_casts;
- std::vector<bool (*)(PyObject *, void *&)> *direct_conversions;
- buffer_info *(*get_buffer)(PyObject *, void *) = nullptr;
- void *get_buffer_data = nullptr;
- /** A simple type never occurs as a (direct or indirect) parent
- * of a class that makes use of multiple inheritance */
- bool simple_type = true;
- /* for base vs derived holder_type checks */
- bool default_holder = true;
-};
-
-PYBIND11_NOINLINE inline internals &get_internals() {
- static internals *internals_ptr = nullptr;
- if (internals_ptr)
- return *internals_ptr;
- handle builtins(PyEval_GetBuiltins());
- const char *id = PYBIND11_INTERNALS_ID;
- if (builtins.contains(id) && isinstance<capsule>(builtins[id])) {
- internals_ptr = capsule(builtins[id]);
- } else {
- internals_ptr = new internals();
- #if defined(WITH_THREAD)
- PyEval_InitThreads();
- PyThreadState *tstate = PyThreadState_Get();
- internals_ptr->tstate = PyThread_create_key();
- PyThread_set_key_value(internals_ptr->tstate, tstate);
- internals_ptr->istate = tstate->interp;
- #endif
- builtins[id] = capsule(internals_ptr);
- internals_ptr->registered_exception_translators.push_front(
- [](std::exception_ptr p) -> void {
- try {
- if (p) std::rethrow_exception(p);
- } catch (error_already_set &e) { e.restore(); return;
- } catch (const builtin_exception &e) { e.set_error(); return;
- } catch (const std::bad_alloc &e) { PyErr_SetString(PyExc_MemoryError, e.what()); return;
- } catch (const std::domain_error &e) { PyErr_SetString(PyExc_ValueError, e.what()); return;
- } catch (const std::invalid_argument &e) { PyErr_SetString(PyExc_ValueError, e.what()); return;
- } catch (const std::length_error &e) { PyErr_SetString(PyExc_ValueError, e.what()); return;
- } catch (const std::out_of_range &e) { PyErr_SetString(PyExc_IndexError, e.what()); return;
- } catch (const std::range_error &e) { PyErr_SetString(PyExc_ValueError, e.what()); return;
- } catch (const std::exception &e) { PyErr_SetString(PyExc_RuntimeError, e.what()); return;
- } catch (...) {
- PyErr_SetString(PyExc_RuntimeError, "Caught an unknown exception!");
- return;
- }
- }
- );
- internals_ptr->static_property_type = make_static_property_type();
- internals_ptr->default_metaclass = make_default_metaclass();
- }
- return *internals_ptr;
-}
-
-PYBIND11_NOINLINE inline detail::type_info* get_type_info(PyTypeObject *type) {
- auto const &type_dict = get_internals().registered_types_py;
- do {
- auto it = type_dict.find(type);
- if (it != type_dict.end())
- return (detail::type_info *) it->second;
- type = type->tp_base;
- if (!type)
- return nullptr;
- } while (true);
-}
-
-PYBIND11_NOINLINE inline detail::type_info *get_type_info(const std::type_info &tp,
- bool throw_if_missing = false) {
- auto &types = get_internals().registered_types_cpp;
-
- auto it = types.find(std::type_index(tp));
- if (it != types.end())
- return (detail::type_info *) it->second;
- if (throw_if_missing) {
- std::string tname = tp.name();
- detail::clean_type_id(tname);
- pybind11_fail("pybind11::detail::get_type_info: unable to find type info for \"" + tname + "\"");
- }
- return nullptr;
-}
-
-PYBIND11_NOINLINE inline handle get_type_handle(const std::type_info &tp, bool throw_if_missing) {
- detail::type_info *type_info = get_type_info(tp, throw_if_missing);
- return handle(type_info ? ((PyObject *) type_info->type) : nullptr);
-}
-
-PYBIND11_NOINLINE inline bool isinstance_generic(handle obj, const std::type_info &tp) {
- handle type = detail::get_type_handle(tp, false);
- if (!type)
- return false;
- return isinstance(obj, type);
-}
-
-PYBIND11_NOINLINE inline std::string error_string() {
- if (!PyErr_Occurred()) {
- PyErr_SetString(PyExc_RuntimeError, "Unknown internal error occurred");
- return "Unknown internal error occurred";
- }
-
- error_scope scope; // Preserve error state
-
- std::string errorString;
- if (scope.type) {
- errorString += handle(scope.type).attr("__name__").cast<std::string>();
- errorString += ": ";
- }
- if (scope.value)
- errorString += (std::string) str(scope.value);
-
- PyErr_NormalizeException(&scope.type, &scope.value, &scope.trace);
-
-#if PY_MAJOR_VERSION >= 3
- if (scope.trace != nullptr)
- PyException_SetTraceback(scope.value, scope.trace);
-#endif
-
-#if !defined(PYPY_VERSION)
- if (scope.trace) {
- PyTracebackObject *trace = (PyTracebackObject *) scope.trace;
-
- /* Get the deepest trace possible */
- while (trace->tb_next)
- trace = trace->tb_next;
-
- PyFrameObject *frame = trace->tb_frame;
- errorString += "\n\nAt:\n";
- while (frame) {
- int lineno = PyFrame_GetLineNumber(frame);
- errorString +=
- " " + handle(frame->f_code->co_filename).cast<std::string>() +
- "(" + std::to_string(lineno) + "): " +
- handle(frame->f_code->co_name).cast<std::string>() + "\n";
- frame = frame->f_back;
- }
- trace = trace->tb_next;
- }
-#endif
-
- return errorString;
-}
-
-PYBIND11_NOINLINE inline handle get_object_handle(const void *ptr, const detail::type_info *type ) {
- auto &instances = get_internals().registered_instances;
- auto range = instances.equal_range(ptr);
- for (auto it = range.first; it != range.second; ++it) {
- auto instance_type = detail::get_type_info(Py_TYPE(it->second));
- if (instance_type && instance_type == type)
- return handle((PyObject *) it->second);
- }
- return handle();
-}
-
-inline PyThreadState *get_thread_state_unchecked() {
-#if defined(PYPY_VERSION)
- return PyThreadState_GET();
-#elif PY_VERSION_HEX < 0x03000000
- return _PyThreadState_Current;
-#elif PY_VERSION_HEX < 0x03050000
- return (PyThreadState*) _Py_atomic_load_relaxed(&_PyThreadState_Current);
-#elif PY_VERSION_HEX < 0x03050200
- return (PyThreadState*) _PyThreadState_Current.value;
-#else
- return _PyThreadState_UncheckedGet();
-#endif
-}
-
-// Forward declaration
-inline void keep_alive_impl(handle nurse, handle patient);
-
-class type_caster_generic {
-public:
- PYBIND11_NOINLINE type_caster_generic(const std::type_info &type_info)
- : typeinfo(get_type_info(type_info)) { }
-
- PYBIND11_NOINLINE bool load(handle src, bool convert) {
- if (!src)
- return false;
- return load(src, convert, Py_TYPE(src.ptr()));
- }
-
- bool load(handle src, bool convert, PyTypeObject *tobj) {
- if (!src || !typeinfo)
- return false;
- if (src.is_none()) {
- value = nullptr;
- return true;
- }
-
- if (typeinfo->simple_type) { /* Case 1: no multiple inheritance etc. involved */
- /* Check if we can safely perform a reinterpret-style cast */
- if (PyType_IsSubtype(tobj, typeinfo->type)) {
- value = reinterpret_cast<instance<void> *>(src.ptr())->value;
- return true;
- }
- } else { /* Case 2: multiple inheritance */
- /* Check if we can safely perform a reinterpret-style cast */
- if (tobj == typeinfo->type) {
- value = reinterpret_cast<instance<void> *>(src.ptr())->value;
- return true;
- }
-
- /* If this is a python class, also check the parents recursively */
- auto const &type_dict = get_internals().registered_types_py;
- bool new_style_class = PyType_Check((PyObject *) tobj);
- if (type_dict.find(tobj) == type_dict.end() && new_style_class && tobj->tp_bases) {
- auto parents = reinterpret_borrow<tuple>(tobj->tp_bases);
- for (handle parent : parents) {
- bool result = load(src, convert, (PyTypeObject *) parent.ptr());
- if (result)
- return true;
- }
- }
-
- /* Try implicit casts */
- for (auto &cast : typeinfo->implicit_casts) {
- type_caster_generic sub_caster(*cast.first);
- if (sub_caster.load(src, convert)) {
- value = cast.second(sub_caster.value);
- return true;
- }
- }
- }
-
- /* Perform an implicit conversion */
- if (convert) {
- for (auto &converter : typeinfo->implicit_conversions) {
- temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
- if (load(temp, false))
- return true;
- }
- for (auto &converter : *typeinfo->direct_conversions) {
- if (converter(src.ptr(), value))
- return true;
- }
- }
- return false;
- }
-
- PYBIND11_NOINLINE static handle cast(const void *_src, return_value_policy policy, handle parent,
- const std::type_info *type_info,
- const std::type_info *type_info_backup,
- void *(*copy_constructor)(const void *),
- void *(*move_constructor)(const void *),
- const void *existing_holder = nullptr) {
- void *src = const_cast<void *>(_src);
- if (src == nullptr)
- return none().inc_ref();
-
- auto &internals = get_internals();
-
- auto it = internals.registered_types_cpp.find(std::type_index(*type_info));
- if (it == internals.registered_types_cpp.end()) {
- type_info = type_info_backup;
- it = internals.registered_types_cpp.find(std::type_index(*type_info));
- }
-
- if (it == internals.registered_types_cpp.end()) {
- std::string tname = type_info->name();
- detail::clean_type_id(tname);
- std::string msg = "Unregistered type : " + tname;
- PyErr_SetString(PyExc_TypeError, msg.c_str());
- return handle();
- }
-
- auto tinfo = (const detail::type_info *) it->second;
-
- auto it_instances = internals.registered_instances.equal_range(src);
- for (auto it_i = it_instances.first; it_i != it_instances.second; ++it_i) {
- auto instance_type = detail::get_type_info(Py_TYPE(it_i->second));
- if (instance_type && instance_type == tinfo)
- return handle((PyObject *) it_i->second).inc_ref();
- }
-
- auto inst = reinterpret_steal<object>(PyType_GenericAlloc(tinfo->type, 0));
-
- auto wrapper = (instance<void> *) inst.ptr();
-
- wrapper->value = nullptr;
- wrapper->owned = false;
-
- switch (policy) {
- case return_value_policy::automatic:
- case return_value_policy::take_ownership:
- wrapper->value = src;
- wrapper->owned = true;
- break;
-
- case return_value_policy::automatic_reference:
- case return_value_policy::reference:
- wrapper->value = src;
- wrapper->owned = false;
- break;
-
- case return_value_policy::copy:
- if (copy_constructor)
- wrapper->value = copy_constructor(src);
- else
- throw cast_error("return_value_policy = copy, but the "
- "object is non-copyable!");
- wrapper->owned = true;
- break;
-
- case return_value_policy::move:
- if (move_constructor)
- wrapper->value = move_constructor(src);
- else if (copy_constructor)
- wrapper->value = copy_constructor(src);
- else
- throw cast_error("return_value_policy = move, but the "
- "object is neither movable nor copyable!");
- wrapper->owned = true;
- break;
-
- case return_value_policy::reference_internal:
- wrapper->value = src;
- wrapper->owned = false;
- detail::keep_alive_impl(inst, parent);
- break;
-
- default:
- throw cast_error("unhandled return_value_policy: should not happen!");
- }
-
- tinfo->init_holder(inst.ptr(), existing_holder);
-
- internals.registered_instances.emplace(wrapper->value, inst.ptr());
-
- return inst.release();
- }
-
-protected:
- const type_info *typeinfo = nullptr;
- void *value = nullptr;
- object temp;
-};
-
-/* Determine suitable casting operator */
-template <typename T>
-using cast_op_type = typename std::conditional<std::is_pointer<typename std::remove_reference<T>::type>::value,
- typename std::add_pointer<intrinsic_t<T>>::type,
- typename std::add_lvalue_reference<intrinsic_t<T>>::type>::type;
-
-// std::is_copy_constructible isn't quite enough: it lets std::vector<T> (and similar) through when
-// T is non-copyable, but code containing such a copy constructor fails to actually compile.
-template <typename T, typename SFINAE = void> struct is_copy_constructible : std::is_copy_constructible<T> {};
-
-// Specialization for types that appear to be copy constructible but also look like stl containers
-// (we specifically check for: has `value_type` and `reference` with `reference = value_type&`): if
-// so, copy constructability depends on whether the value_type is copy constructible.
-template <typename Container> struct is_copy_constructible<Container, enable_if_t<
- std::is_copy_constructible<Container>::value &&
- std::is_same<typename Container::value_type &, typename Container::reference>::value
- >> : std::is_copy_constructible<typename Container::value_type> {};
-
-/// Generic type caster for objects stored on the heap
-template <typename type> class type_caster_base : public type_caster_generic {
- using itype = intrinsic_t<type>;
-public:
- static PYBIND11_DESCR name() { return type_descr(_<type>()); }
-
- type_caster_base() : type_caster_base(typeid(type)) { }
- explicit type_caster_base(const std::type_info &info) : type_caster_generic(info) { }
-
- static handle cast(const itype &src, return_value_policy policy, handle parent) {
- if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
- policy = return_value_policy::copy;
- return cast(&src, policy, parent);
- }
-
- static handle cast(itype &&src, return_value_policy, handle parent) {
- return cast(&src, return_value_policy::move, parent);
- }
-
- static handle cast(const itype *src, return_value_policy policy, handle parent) {
- return type_caster_generic::cast(
- src, policy, parent, src ? &typeid(*src) : nullptr, &typeid(type),
- make_copy_constructor(src), make_move_constructor(src));
- }
-
- static handle cast_holder(const itype *src, const void *holder) {
- return type_caster_generic::cast(
- src, return_value_policy::take_ownership, {},
- src ? &typeid(*src) : nullptr, &typeid(type),
- nullptr, nullptr, holder);
- }
-
- template <typename T> using cast_op_type = pybind11::detail::cast_op_type<T>;
-
- operator itype*() { return (type *) value; }
- operator itype&() { if (!value) throw reference_cast_error(); return *((itype *) value); }
-
-protected:
- typedef void *(*Constructor)(const void *stream);
-#if !defined(_MSC_VER)
- /* Only enabled when the types are {copy,move}-constructible *and* when the type
- does not have a private operator new implementaton. */
- template <typename T = type, typename = enable_if_t<is_copy_constructible<T>::value>> static auto make_copy_constructor(const T *value) -> decltype(new T(*value), Constructor(nullptr)) {
- return [](const void *arg) -> void * { return new T(*((const T *) arg)); }; }
- template <typename T = type> static auto make_move_constructor(const T *value) -> decltype(new T(std::move(*((T *) value))), Constructor(nullptr)) {
- return [](const void *arg) -> void * { return (void *) new T(std::move(*const_cast<T *>(reinterpret_cast<const T *>(arg)))); }; }
-#else
- /* Visual Studio 2015's SFINAE implementation doesn't yet handle the above robustly in all situations.
- Use a workaround that only tests for constructibility for now. */
- template <typename T = type, typename = enable_if_t<is_copy_constructible<T>::value>>
- static Constructor make_copy_constructor(const T *value) {
- return [](const void *arg) -> void * { return new T(*((const T *)arg)); }; }
- template <typename T = type, typename = enable_if_t<std::is_move_constructible<T>::value>>
- static Constructor make_move_constructor(const T *value) {
- return [](const void *arg) -> void * { return (void *) new T(std::move(*((T *)arg))); }; }
-#endif
-
- static Constructor make_copy_constructor(...) { return nullptr; }
- static Constructor make_move_constructor(...) { return nullptr; }
-};
-
-template <typename type, typename SFINAE = void> class type_caster : public type_caster_base<type> { };
-template <typename type> using make_caster = type_caster<intrinsic_t<type>>;
-
-// Shortcut for calling a caster's `cast_op_type` cast operator for casting a type_caster to a T
-template <typename T> typename make_caster<T>::template cast_op_type<T> cast_op(make_caster<T> &caster) {
- return caster.operator typename make_caster<T>::template cast_op_type<T>();
-}
-template <typename T> typename make_caster<T>::template cast_op_type<T> cast_op(make_caster<T> &&caster) {
- return cast_op<T>(caster);
-}
-
-template <typename type> class type_caster<std::reference_wrapper<type>> : public type_caster_base<type> {
-public:
- static handle cast(const std::reference_wrapper<type> &src, return_value_policy policy, handle parent) {
- return type_caster_base<type>::cast(&src.get(), policy, parent);
- }
- template <typename T> using cast_op_type = std::reference_wrapper<type>;
- operator std::reference_wrapper<type>() { return std::ref(*((type *) this->value)); }
-};
-
-#define PYBIND11_TYPE_CASTER(type, py_name) \
- protected: \
- type value; \
- public: \
- static PYBIND11_DESCR name() { return type_descr(py_name); } \
- static handle cast(const type *src, return_value_policy policy, handle parent) { \
- if (!src) return none().release(); \
- return cast(*src, policy, parent); \
- } \
- operator type*() { return &value; } \
- operator type&() { return value; } \
- template <typename _T> using cast_op_type = pybind11::detail::cast_op_type<_T>
-
-
-template <typename CharT> using is_std_char_type = any_of<
- std::is_same<CharT, char>, /* std::string */
- std::is_same<CharT, char16_t>, /* std::u16string */
- std::is_same<CharT, char32_t>, /* std::u32string */
- std::is_same<CharT, wchar_t> /* std::wstring */
->;
-
-template <typename T>
-struct type_caster<T, enable_if_t<std::is_arithmetic<T>::value && !is_std_char_type<T>::value>> {
- using _py_type_0 = conditional_t<sizeof(T) <= sizeof(long), long, long long>;
- using _py_type_1 = conditional_t<std::is_signed<T>::value, _py_type_0, typename std::make_unsigned<_py_type_0>::type>;
- using py_type = conditional_t<std::is_floating_point<T>::value, double, _py_type_1>;
-public:
-
- bool load(handle src, bool convert) {
- py_type py_value;
-
- if (!src)
- return false;
-
- if (std::is_floating_point<T>::value) {
- if (convert || PyFloat_Check(src.ptr()))
- py_value = (py_type) PyFloat_AsDouble(src.ptr());
- else
- return false;
- } else if (sizeof(T) <= sizeof(long)) {
- if (PyFloat_Check(src.ptr()))
- return false;
- if (std::is_signed<T>::value)
- py_value = (py_type) PyLong_AsLong(src.ptr());
- else
- py_value = (py_type) PyLong_AsUnsignedLong(src.ptr());
- } else {
- if (PyFloat_Check(src.ptr()))
- return false;
- if (std::is_signed<T>::value)
- py_value = (py_type) PYBIND11_LONG_AS_LONGLONG(src.ptr());
- else
- py_value = (py_type) PYBIND11_LONG_AS_UNSIGNED_LONGLONG(src.ptr());
- }
-
- if ((py_value == (py_type) -1 && PyErr_Occurred()) ||
- (std::is_integral<T>::value && sizeof(py_type) != sizeof(T) &&
- (py_value < (py_type) std::numeric_limits<T>::min() ||
- py_value > (py_type) std::numeric_limits<T>::max()))) {
-#if PY_VERSION_HEX < 0x03000000
- bool type_error = PyErr_ExceptionMatches(PyExc_SystemError);
-#else
- bool type_error = PyErr_ExceptionMatches(PyExc_TypeError);
-#endif
- PyErr_Clear();
- if (type_error && convert && PyNumber_Check(src.ptr())) {
- auto tmp = reinterpret_borrow<object>(std::is_floating_point<T>::value
- ? PyNumber_Float(src.ptr())
- : PyNumber_Long(src.ptr()));
- PyErr_Clear();
- return load(tmp, false);
- }
- return false;
- }
-
- value = (T) py_value;
- return true;
- }
-
- static handle cast(T src, return_value_policy /* policy */, handle /* parent */) {
- if (std::is_floating_point<T>::value) {
- return PyFloat_FromDouble((double) src);
- } else if (sizeof(T) <= sizeof(long)) {
- if (std::is_signed<T>::value)
- return PyLong_FromLong((long) src);
- else
- return PyLong_FromUnsignedLong((unsigned long) src);
- } else {
- if (std::is_signed<T>::value)
- return PyLong_FromLongLong((long long) src);
- else
- return PyLong_FromUnsignedLongLong((unsigned long long) src);
- }
- }
-
- PYBIND11_TYPE_CASTER(T, _<std::is_integral<T>::value>("int", "float"));
-};
-
-template<typename T> struct void_caster {
-public:
- bool load(handle, bool) { return false; }
- static handle cast(T, return_value_policy /* policy */, handle /* parent */) {
- return none().inc_ref();
- }
- PYBIND11_TYPE_CASTER(T, _("None"));
-};
-
-template <> class type_caster<void_type> : public void_caster<void_type> {};
-
-template <> class type_caster<void> : public type_caster<void_type> {
-public:
- using type_caster<void_type>::cast;
-
- bool load(handle h, bool) {
- if (!h) {
- return false;
- } else if (h.is_none()) {
- value = nullptr;
- return true;
- }
-
- /* Check if this is a capsule */
- if (isinstance<capsule>(h)) {
- value = reinterpret_borrow<capsule>(h);
- return true;
- }
-
- /* Check if this is a C++ type */
- if (get_type_info((PyTypeObject *) h.get_type().ptr())) {
- value = ((instance<void> *) h.ptr())->value;
- return true;
- }
-
- /* Fail */
- return false;
- }
-
- static handle cast(const void *ptr, return_value_policy /* policy */, handle /* parent */) {
- if (ptr)
- return capsule(ptr).release();
- else
- return none().inc_ref();
- }
-
- template <typename T> using cast_op_type = void*&;
- operator void *&() { return value; }
- static PYBIND11_DESCR name() { return type_descr(_("capsule")); }
-private:
- void *value = nullptr;
-};
-
-template <> class type_caster<std::nullptr_t> : public type_caster<void_type> { };
-
-template <> class type_caster<bool> {
-public:
- bool load(handle src, bool) {
- if (!src) return false;
- else if (src.ptr() == Py_True) { value = true; return true; }
- else if (src.ptr() == Py_False) { value = false; return true; }
- else return false;
- }
- static handle cast(bool src, return_value_policy /* policy */, handle /* parent */) {
- return handle(src ? Py_True : Py_False).inc_ref();
- }
- PYBIND11_TYPE_CASTER(bool, _("bool"));
-};
-
-// Helper class for UTF-{8,16,32} C++ stl strings:
-template <typename CharT, class Traits, class Allocator>
-struct type_caster<std::basic_string<CharT, Traits, Allocator>, enable_if_t<is_std_char_type<CharT>::value>> {
- // Simplify life by being able to assume standard char sizes (the standard only guarantees
- // minimums), but Python requires exact sizes
- static_assert(!std::is_same<CharT, char>::value || sizeof(CharT) == 1, "Unsupported char size != 1");
- static_assert(!std::is_same<CharT, char16_t>::value || sizeof(CharT) == 2, "Unsupported char16_t size != 2");
- static_assert(!std::is_same<CharT, char32_t>::value || sizeof(CharT) == 4, "Unsupported char32_t size != 4");
- // wchar_t can be either 16 bits (Windows) or 32 (everywhere else)
- static_assert(!std::is_same<CharT, wchar_t>::value || sizeof(CharT) == 2 || sizeof(CharT) == 4,
- "Unsupported wchar_t size != 2/4");
- static constexpr size_t UTF_N = 8 * sizeof(CharT);
-
- using StringType = std::basic_string<CharT, Traits, Allocator>;
-
- bool load(handle src, bool) {
-#if PY_MAJOR_VERSION < 3
- object temp;
-#endif
- handle load_src = src;
- if (!src) {
- return false;
- } else if (!PyUnicode_Check(load_src.ptr())) {
-#if PY_MAJOR_VERSION >= 3
- return false;
- // The below is a guaranteed failure in Python 3 when PyUnicode_Check returns false
-#else
- if (!PYBIND11_BYTES_CHECK(load_src.ptr()))
- return false;
- temp = reinterpret_steal<object>(PyUnicode_FromObject(load_src.ptr()));
- if (!temp) { PyErr_Clear(); return false; }
- load_src = temp;
-#endif
- }
-
- object utfNbytes = reinterpret_steal<object>(PyUnicode_AsEncodedString(
- load_src.ptr(), UTF_N == 8 ? "utf-8" : UTF_N == 16 ? "utf-16" : "utf-32", nullptr));
- if (!utfNbytes) { PyErr_Clear(); return false; }
-
- const CharT *buffer = reinterpret_cast<const CharT *>(PYBIND11_BYTES_AS_STRING(utfNbytes.ptr()));
- size_t length = (size_t) PYBIND11_BYTES_SIZE(utfNbytes.ptr()) / sizeof(CharT);
- if (UTF_N > 8) { buffer++; length--; } // Skip BOM for UTF-16/32
- value = StringType(buffer, length);
- return true;
- }
-
- static handle cast(const StringType &src, return_value_policy /* policy */, handle /* parent */) {
- const char *buffer = reinterpret_cast<const char *>(src.c_str());
- ssize_t nbytes = ssize_t(src.size() * sizeof(CharT));
- handle s = decode_utfN(buffer, nbytes);
- if (!s) throw error_already_set();
- return s;
- }
-
- PYBIND11_TYPE_CASTER(StringType, _(PYBIND11_STRING_NAME));
-
-private:
- static handle decode_utfN(const char *buffer, ssize_t nbytes) {
-#if !defined(PYPY_VERSION)
- return
- UTF_N == 8 ? PyUnicode_DecodeUTF8(buffer, nbytes, nullptr) :
- UTF_N == 16 ? PyUnicode_DecodeUTF16(buffer, nbytes, nullptr, nullptr) :
- PyUnicode_DecodeUTF32(buffer, nbytes, nullptr, nullptr);
-#else
- // PyPy seems to have multiple problems related to PyUnicode_UTF*: the UTF8 version
- // sometimes segfaults for unknown reasons, while the UTF16 and 32 versions require a
- // non-const char * arguments, which is also a nuissance, so bypass the whole thing by just
- // passing the encoding as a string value, which works properly:
- return PyUnicode_Decode(buffer, nbytes, UTF_N == 8 ? "utf-8" : UTF_N == 16 ? "utf-16" : "utf-32", nullptr);
-#endif
- }
-};
-
-// Type caster for C-style strings. We basically use a std::string type caster, but also add the
-// ability to use None as a nullptr char* (which the string caster doesn't allow).
-template <typename CharT> struct type_caster<CharT, enable_if_t<is_std_char_type<CharT>::value>> {
- using StringType = std::basic_string<CharT>;
- using StringCaster = type_caster<StringType>;
- StringCaster str_caster;
- bool none = false;
-public:
- bool load(handle src, bool convert) {
- if (!src) return false;
- if (src.is_none()) {
- // Defer accepting None to other overloads (if we aren't in convert mode):
- if (!convert) return false;
- none = true;
- return true;
- }
- return str_caster.load(src, convert);
- }
-
- static handle cast(const CharT *src, return_value_policy policy, handle parent) {
- if (src == nullptr) return pybind11::none().inc_ref();
- return StringCaster::cast(StringType(src), policy, parent);
- }
-
- static handle cast(CharT src, return_value_policy policy, handle parent) {
- if (std::is_same<char, CharT>::value) {
- handle s = PyUnicode_DecodeLatin1((const char *) &src, 1, nullptr);
- if (!s) throw error_already_set();
- return s;
- }
- return StringCaster::cast(StringType(1, src), policy, parent);
- }
-
- operator CharT*() { return none ? nullptr : const_cast<CharT *>(static_cast<StringType &>(str_caster).c_str()); }
- operator CharT() {
- if (none)
- throw value_error("Cannot convert None to a character");
-
- auto &value = static_cast<StringType &>(str_caster);
- size_t str_len = value.size();
- if (str_len == 0)
- throw value_error("Cannot convert empty string to a character");
-
- // If we're in UTF-8 mode, we have two possible failures: one for a unicode character that
- // is too high, and one for multiple unicode characters (caught later), so we need to figure
- // out how long the first encoded character is in bytes to distinguish between these two
- // errors. We also allow want to allow unicode characters U+0080 through U+00FF, as those
- // can fit into a single char value.
- if (StringCaster::UTF_N == 8 && str_len > 1 && str_len <= 4) {
- unsigned char v0 = static_cast<unsigned char>(value[0]);
- size_t char0_bytes = !(v0 & 0x80) ? 1 : // low bits only: 0-127
- (v0 & 0xE0) == 0xC0 ? 2 : // 0b110xxxxx - start of 2-byte sequence
- (v0 & 0xF0) == 0xE0 ? 3 : // 0b1110xxxx - start of 3-byte sequence
- 4; // 0b11110xxx - start of 4-byte sequence
-
- if (char0_bytes == str_len) {
- // If we have a 128-255 value, we can decode it into a single char:
- if (char0_bytes == 2 && (v0 & 0xFC) == 0xC0) { // 0x110000xx 0x10xxxxxx
- return static_cast<CharT>(((v0 & 3) << 6) + (static_cast<unsigned char>(value[1]) & 0x3F));
- }
- // Otherwise we have a single character, but it's > U+00FF
- throw value_error("Character code point not in range(0x100)");
- }
- }
-
- // UTF-16 is much easier: we can only have a surrogate pair for values above U+FFFF, thus a
- // surrogate pair with total length 2 instantly indicates a range error (but not a "your
- // string was too long" error).
- else if (StringCaster::UTF_N == 16 && str_len == 2) {
- char16_t v0 = static_cast<char16_t>(value[0]);
- if (v0 >= 0xD800 && v0 < 0xE000)
- throw value_error("Character code point not in range(0x10000)");
- }
-
- if (str_len != 1)
- throw value_error("Expected a character, but multi-character string found");
-
- return value[0];
- }
-
- static PYBIND11_DESCR name() { return type_descr(_(PYBIND11_STRING_NAME)); }
- template <typename _T> using cast_op_type = typename std::remove_reference<pybind11::detail::cast_op_type<_T>>::type;
-};
-
-template <typename T1, typename T2> class type_caster<std::pair<T1, T2>> {
- typedef std::pair<T1, T2> type;
-public:
- bool load(handle src, bool convert) {
- if (!isinstance<sequence>(src))
- return false;
- const auto seq = reinterpret_borrow<sequence>(src);
- if (seq.size() != 2)
- return false;
- return first.load(seq[0], convert) && second.load(seq[1], convert);
- }
-
- static handle cast(const type &src, return_value_policy policy, handle parent) {
- auto o1 = reinterpret_steal<object>(make_caster<T1>::cast(src.first, policy, parent));
- auto o2 = reinterpret_steal<object>(make_caster<T2>::cast(src.second, policy, parent));
- if (!o1 || !o2)
- return handle();
- tuple result(2);
- PyTuple_SET_ITEM(result.ptr(), 0, o1.release().ptr());
- PyTuple_SET_ITEM(result.ptr(), 1, o2.release().ptr());
- return result.release();
- }
-
- static PYBIND11_DESCR name() {
- return type_descr(
- _("Tuple[") + make_caster<T1>::name() + _(", ") + make_caster<T2>::name() + _("]")
- );
- }
-
- template <typename T> using cast_op_type = type;
-
- operator type() {
- return type(cast_op<T1>(first), cast_op<T2>(second));
- }
-protected:
- make_caster<T1> first;
- make_caster<T2> second;
-};
-
-template <typename... Tuple> class type_caster<std::tuple<Tuple...>> {
- using type = std::tuple<Tuple...>;
- using indices = make_index_sequence<sizeof...(Tuple)>;
- static constexpr auto size = sizeof...(Tuple);
-
-public:
- bool load(handle src, bool convert) {
- if (!isinstance<sequence>(src))
- return false;
- const auto seq = reinterpret_borrow<sequence>(src);
- if (seq.size() != size)
- return false;
- return load_impl(seq, convert, indices{});
- }
-
- static handle cast(const type &src, return_value_policy policy, handle parent) {
- return cast_impl(src, policy, parent, indices{});
- }
-
- static PYBIND11_DESCR name() {
- return type_descr(_("Tuple[") + detail::concat(make_caster<Tuple>::name()...) + _("]"));
- }
-
- template <typename T> using cast_op_type = type;
-
- operator type() { return implicit_cast(indices{}); }
-
-protected:
- template <size_t... Is>
- type implicit_cast(index_sequence<Is...>) { return type(cast_op<Tuple>(std::get<Is>(value))...); }
-
- static constexpr bool load_impl(const sequence &, bool, index_sequence<>) { return true; }
-
- template <size_t... Is>
- bool load_impl(const sequence &seq, bool convert, index_sequence<Is...>) {
- for (bool r : {std::get<Is>(value).load(seq[Is], convert)...})
- if (!r)
- return false;
- return true;
- }
-
- static handle cast_impl(const type &, return_value_policy, handle,
- index_sequence<>) { return tuple().release(); }
-
- /* Implementation: Convert a C++ tuple into a Python tuple */
- template <size_t... Is>
- static handle cast_impl(const type &src, return_value_policy policy, handle parent, index_sequence<Is...>) {
- std::array<object, size> entries {{
- reinterpret_steal<object>(make_caster<Tuple>::cast(std::get<Is>(src), policy, parent))...
- }};
- for (const auto &entry: entries)
- if (!entry)
- return handle();
- tuple result(size);
- int counter = 0;
- for (auto & entry: entries)
- PyTuple_SET_ITEM(result.ptr(), counter++, entry.release().ptr());
- return result.release();
- }
-
- std::tuple<make_caster<Tuple>...> value;
-};
-
-/// Helper class which abstracts away certain actions. Users can provide specializations for
-/// custom holders, but it's only necessary if the type has a non-standard interface.
-template <typename T>
-struct holder_helper {
- static auto get(const T &p) -> decltype(p.get()) { return p.get(); }
-};
-
-/// Type caster for holder types like std::shared_ptr, etc.
-template <typename type, typename holder_type>
-struct copyable_holder_caster : public type_caster_base<type> {
-public:
- using base = type_caster_base<type>;
- using base::base;
- using base::cast;
- using base::typeinfo;
- using base::value;
- using base::temp;
-
- PYBIND11_NOINLINE bool load(handle src, bool convert) {
- return load(src, convert, Py_TYPE(src.ptr()));
- }
-
- bool load(handle src, bool convert, PyTypeObject *tobj) {
- if (!src || !typeinfo)
- return false;
- if (src.is_none()) {
- value = nullptr;
- return true;
- }
-
- if (typeinfo->default_holder)
- throw cast_error("Unable to load a custom holder type from a default-holder instance");
-
- if (typeinfo->simple_type) { /* Case 1: no multiple inheritance etc. involved */
- /* Check if we can safely perform a reinterpret-style cast */
- if (PyType_IsSubtype(tobj, typeinfo->type))
- return load_value_and_holder(src);
- } else { /* Case 2: multiple inheritance */
- /* Check if we can safely perform a reinterpret-style cast */
- if (tobj == typeinfo->type)
- return load_value_and_holder(src);
-
- /* If this is a python class, also check the parents recursively */
- auto const &type_dict = get_internals().registered_types_py;
- bool new_style_class = PyType_Check((PyObject *) tobj);
- if (type_dict.find(tobj) == type_dict.end() && new_style_class && tobj->tp_bases) {
- auto parents = reinterpret_borrow<tuple>(tobj->tp_bases);
- for (handle parent : parents) {
- bool result = load(src, convert, (PyTypeObject *) parent.ptr());
- if (result)
- return true;
- }
- }
-
- if (try_implicit_casts(src, convert))
- return true;
- }
-
- if (convert) {
- for (auto &converter : typeinfo->implicit_conversions) {
- temp = reinterpret_steal<object>(converter(src.ptr(), typeinfo->type));
- if (load(temp, false))
- return true;
- }
- }
-
- return false;
- }
-
- bool load_value_and_holder(handle src) {
- auto inst = (instance<type, holder_type> *) src.ptr();
- value = (void *) inst->value;
- if (inst->holder_constructed) {
- holder = inst->holder;
- return true;
- } else {
- throw cast_error("Unable to cast from non-held to held instance (T& to Holder<T>) "
-#if defined(NDEBUG)
- "(compile in debug mode for type information)");
-#else
- "of type '" + type_id<holder_type>() + "''");
-#endif
- }
- }
-
- template <typename T = holder_type, detail::enable_if_t<!std::is_constructible<T, const T &, type*>::value, int> = 0>
- bool try_implicit_casts(handle, bool) { return false; }
-
- template <typename T = holder_type, detail::enable_if_t<std::is_constructible<T, const T &, type*>::value, int> = 0>
- bool try_implicit_casts(handle src, bool convert) {
- for (auto &cast : typeinfo->implicit_casts) {
- copyable_holder_caster sub_caster(*cast.first);
- if (sub_caster.load(src, convert)) {
- value = cast.second(sub_caster.value);
- holder = holder_type(sub_caster.holder, (type *) value);
- return true;
- }
- }
- return false;
- }
-
- explicit operator type*() { return this->value; }
- explicit operator type&() { return *(this->value); }
- explicit operator holder_type*() { return &holder; }
-
- // Workaround for Intel compiler bug
- // see pybind11 issue 94
- #if defined(__ICC) || defined(__INTEL_COMPILER)
- operator holder_type&() { return holder; }
- #else
- explicit operator holder_type&() { return holder; }
- #endif
-
- static handle cast(const holder_type &src, return_value_policy, handle) {
- const auto *ptr = holder_helper<holder_type>::get(src);
- return type_caster_base<type>::cast_holder(ptr, &src);
- }
-
-protected:
- holder_type holder;
-};
-
-/// Specialize for the common std::shared_ptr, so users don't need to
-template <typename T>
-class type_caster<std::shared_ptr<T>> : public copyable_holder_caster<T, std::shared_ptr<T>> { };
-
-template <typename type, typename holder_type>
-struct move_only_holder_caster {
- static handle cast(holder_type &&src, return_value_policy, handle) {
- auto *ptr = holder_helper<holder_type>::get(src);
- return type_caster_base<type>::cast_holder(ptr, &src);
- }
- static PYBIND11_DESCR name() { return type_caster_base<type>::name(); }
-};
-
-template <typename type, typename deleter>
-class type_caster<std::unique_ptr<type, deleter>>
- : public move_only_holder_caster<type, std::unique_ptr<type, deleter>> { };
-
-template <typename type, typename holder_type>
-using type_caster_holder = conditional_t<std::is_copy_constructible<holder_type>::value,
- copyable_holder_caster<type, holder_type>,
- move_only_holder_caster<type, holder_type>>;
-
-template <typename T, bool Value = false> struct always_construct_holder { static constexpr bool value = Value; };
-
-/// Create a specialization for custom holder types (silently ignores std::shared_ptr)
-#define PYBIND11_DECLARE_HOLDER_TYPE(type, holder_type, ...) \
- namespace pybind11 { namespace detail { \
- template <typename type> \
- struct always_construct_holder<holder_type> : always_construct_holder<void, ##__VA_ARGS__> { }; \
- template <typename type> \
- class type_caster<holder_type, enable_if_t<!is_shared_ptr<holder_type>::value>> \
- : public type_caster_holder<type, holder_type> { }; \
- }}
-
-// PYBIND11_DECLARE_HOLDER_TYPE holder types:
-template <typename base, typename holder> struct is_holder_type :
- std::is_base_of<detail::type_caster_holder<base, holder>, detail::type_caster<holder>> {};
-// Specialization for always-supported unique_ptr holders:
-template <typename base, typename deleter> struct is_holder_type<base, std::unique_ptr<base, deleter>> :
- std::true_type {};
-
-template <typename T> struct handle_type_name { static PYBIND11_DESCR name() { return _<T>(); } };
-template <> struct handle_type_name<bytes> { static PYBIND11_DESCR name() { return _(PYBIND11_BYTES_NAME); } };
-template <> struct handle_type_name<args> { static PYBIND11_DESCR name() { return _("*args"); } };
-template <> struct handle_type_name<kwargs> { static PYBIND11_DESCR name() { return _("**kwargs"); } };
-
-template <typename type>
-struct pyobject_caster {
- template <typename T = type, enable_if_t<std::is_same<T, handle>::value, int> = 0>
- bool load(handle src, bool /* convert */) { value = src; return static_cast<bool>(value); }
-
- template <typename T = type, enable_if_t<std::is_base_of<object, T>::value, int> = 0>
- bool load(handle src, bool /* convert */) {
- if (!isinstance<type>(src))
- return false;
- value = reinterpret_borrow<type>(src);
- return true;
- }
-
- static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) {
- return src.inc_ref();
- }
- PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name());
-};
-
-template <typename T>
-class type_caster<T, enable_if_t<is_pyobject<T>::value>> : public pyobject_caster<T> { };
-
-// Our conditions for enabling moving are quite restrictive:
-// At compile time:
-// - T needs to be a non-const, non-pointer, non-reference type
-// - type_caster<T>::operator T&() must exist
-// - the type must be move constructible (obviously)
-// At run-time:
-// - if the type is non-copy-constructible, the object must be the sole owner of the type (i.e. it
-// must have ref_count() == 1)h
-// If any of the above are not satisfied, we fall back to copying.
-template <typename T> using move_is_plain_type = satisfies_none_of<T,
- std::is_void, std::is_pointer, std::is_reference, std::is_const
->;
-template <typename T, typename SFINAE = void> struct move_always : std::false_type {};
-template <typename T> struct move_always<T, enable_if_t<all_of<
- move_is_plain_type<T>,
- negation<std::is_copy_constructible<T>>,
- std::is_move_constructible<T>,
- std::is_same<decltype(std::declval<make_caster<T>>().operator T&()), T&>
->::value>> : std::true_type {};
-template <typename T, typename SFINAE = void> struct move_if_unreferenced : std::false_type {};
-template <typename T> struct move_if_unreferenced<T, enable_if_t<all_of<
- move_is_plain_type<T>,
- negation<move_always<T>>,
- std::is_move_constructible<T>,
- std::is_same<decltype(std::declval<make_caster<T>>().operator T&()), T&>
->::value>> : std::true_type {};
-template <typename T> using move_never = none_of<move_always<T>, move_if_unreferenced<T>>;
-
-// Detect whether returning a `type` from a cast on type's type_caster is going to result in a
-// reference or pointer to a local variable of the type_caster. Basically, only
-// non-reference/pointer `type`s and reference/pointers from a type_caster_generic are safe;
-// everything else returns a reference/pointer to a local variable.
-template <typename type> using cast_is_temporary_value_reference = bool_constant<
- (std::is_reference<type>::value || std::is_pointer<type>::value) &&
- !std::is_base_of<type_caster_generic, make_caster<type>>::value
->;
-
-// When a value returned from a C++ function is being cast back to Python, we almost always want to
-// force `policy = move`, regardless of the return value policy the function/method was declared
-// with. Some classes (most notably Eigen::Ref and related) need to avoid this, and so can do so by
-// specializing this struct.
-template <typename Return, typename SFINAE = void> struct return_value_policy_override {
- static return_value_policy policy(return_value_policy p) {
- return !std::is_lvalue_reference<Return>::value && !std::is_pointer<Return>::value
- ? return_value_policy::move : p;
- }
-};
-
-// Basic python -> C++ casting; throws if casting fails
-template <typename T, typename SFINAE> type_caster<T, SFINAE> &load_type(type_caster<T, SFINAE> &conv, const handle &handle) {
- if (!conv.load(handle, true)) {
-#if defined(NDEBUG)
- throw cast_error("Unable to cast Python instance to C++ type (compile in debug mode for details)");
-#else
- throw cast_error("Unable to cast Python instance of type " +
- (std::string) str(handle.get_type()) + " to C++ type '" + type_id<T>() + "''");
-#endif
- }
- return conv;
-}
-// Wrapper around the above that also constructs and returns a type_caster
-template <typename T> make_caster<T> load_type(const handle &handle) {
- make_caster<T> conv;
- load_type(conv, handle);
- return conv;
-}
-
-NAMESPACE_END(detail)
-
-// pytype -> C++ type
-template <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0>
-T cast(const handle &handle) {
- using namespace detail;
- static_assert(!cast_is_temporary_value_reference<T>::value,
- "Unable to cast type to reference: value is local to type caster");
- return cast_op<T>(load_type<T>(handle));
-}
-
-// pytype -> pytype (calls converting constructor)
-template <typename T, detail::enable_if_t<detail::is_pyobject<T>::value, int> = 0>
-T cast(const handle &handle) { return T(reinterpret_borrow<object>(handle)); }
-
-// C++ type -> py::object
-template <typename T, detail::enable_if_t<!detail::is_pyobject<T>::value, int> = 0>
-object cast(const T &value, return_value_policy policy = return_value_policy::automatic_reference,
- handle parent = handle()) {
- if (policy == return_value_policy::automatic)
- policy = std::is_pointer<T>::value ? return_value_policy::take_ownership : return_value_policy::copy;
- else if (policy == return_value_policy::automatic_reference)
- policy = std::is_pointer<T>::value ? return_value_policy::reference : return_value_policy::copy;
- return reinterpret_steal<object>(detail::make_caster<T>::cast(value, policy, parent));
-}
-
-template <typename T> T handle::cast() const { return pybind11::cast<T>(*this); }
-template <> inline void handle::cast() const { return; }
-
-template <typename T>
-detail::enable_if_t<!detail::move_never<T>::value, T> move(object &&obj) {
- if (obj.ref_count() > 1)
-#if defined(NDEBUG)
- throw cast_error("Unable to cast Python instance to C++ rvalue: instance has multiple references"
- " (compile in debug mode for details)");
-#else
- throw cast_error("Unable to move from Python " + (std::string) str(obj.get_type()) +
- " instance to C++ " + type_id<T>() + " instance: instance has multiple references");
-#endif
-
- // Move into a temporary and return that, because the reference may be a local value of `conv`
- T ret = std::move(detail::load_type<T>(obj).operator T&());
- return ret;
-}
-
-// Calling cast() on an rvalue calls pybind::cast with the object rvalue, which does:
-// - If we have to move (because T has no copy constructor), do it. This will fail if the moved
-// object has multiple references, but trying to copy will fail to compile.
-// - If both movable and copyable, check ref count: if 1, move; otherwise copy
-// - Otherwise (not movable), copy.
-template <typename T> detail::enable_if_t<detail::move_always<T>::value, T> cast(object &&object) {
- return move<T>(std::move(object));
-}
-template <typename T> detail::enable_if_t<detail::move_if_unreferenced<T>::value, T> cast(object &&object) {
- if (object.ref_count() > 1)
- return cast<T>(object);
- else
- return move<T>(std::move(object));
-}
-template <typename T> detail::enable_if_t<detail::move_never<T>::value, T> cast(object &&object) {
- return cast<T>(object);
-}
-
-template <typename T> T object::cast() const & { return pybind11::cast<T>(*this); }
-template <typename T> T object::cast() && { return pybind11::cast<T>(std::move(*this)); }
-template <> inline void object::cast() const & { return; }
-template <> inline void object::cast() && { return; }
-
-NAMESPACE_BEGIN(detail)
-
-// Declared in pytypes.h:
-template <typename T, enable_if_t<!is_pyobject<T>::value, int>>
-object object_or_cast(T &&o) { return pybind11::cast(std::forward<T>(o)); }
-
-struct overload_unused {}; // Placeholder type for the unneeded (and dead code) static variable in the OVERLOAD_INT macro
-template <typename ret_type> using overload_caster_t = conditional_t<
- cast_is_temporary_value_reference<ret_type>::value, make_caster<ret_type>, overload_unused>;
-
-// Trampoline use: for reference/pointer types to value-converted values, we do a value cast, then
-// store the result in the given variable. For other types, this is a no-op.
-template <typename T> enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&o, make_caster<T> &caster) {
- return cast_op<T>(load_type(caster, o));
-}
-template <typename T> enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_ref(object &&, overload_unused &) {
- pybind11_fail("Internal error: cast_ref fallback invoked"); }
-
-// Trampoline use: Having a pybind11::cast with an invalid reference type is going to static_assert, even
-// though if it's in dead code, so we provide a "trampoline" to pybind11::cast that only does anything in
-// cases where pybind11::cast is valid.
-template <typename T> enable_if_t<!cast_is_temporary_value_reference<T>::value, T> cast_safe(object &&o) {
- return pybind11::cast<T>(std::move(o)); }
-template <typename T> enable_if_t<cast_is_temporary_value_reference<T>::value, T> cast_safe(object &&) {
- pybind11_fail("Internal error: cast_safe fallback invoked"); }
-template <> inline void cast_safe<void>(object &&) {}
-
-NAMESPACE_END(detail)
-
-template <return_value_policy policy = return_value_policy::automatic_reference,
- typename... Args> tuple make_tuple(Args&&... args_) {
- const size_t size = sizeof...(Args);
- std::array<object, size> args {
- { reinterpret_steal<object>(detail::make_caster<Args>::cast(
- std::forward<Args>(args_), policy, nullptr))... }
- };
- for (auto &arg_value : args) {
- if (!arg_value) {
-#if defined(NDEBUG)
- throw cast_error("make_tuple(): unable to convert arguments to Python object (compile in debug mode for details)");
-#else
- throw cast_error("make_tuple(): unable to convert arguments of types '" +
- (std::string) type_id<std::tuple<Args...>>() + "' to Python object");
-#endif
- }
- }
- tuple result(size);
- int counter = 0;
- for (auto &arg_value : args)
- PyTuple_SET_ITEM(result.ptr(), counter++, arg_value.release().ptr());
- return result;
-}
-
-/// \ingroup annotations
-/// Annotation for arguments
-struct arg {
- /// Constructs an argument with the name of the argument; if null or omitted, this is a positional argument.
- constexpr explicit arg(const char *name = nullptr) : name(name), flag_noconvert(false) { }
- /// Assign a value to this argument
- template <typename T> arg_v operator=(T &&value) const;
- /// Indicate that the type should not be converted in the type caster
- arg &noconvert(bool flag = true) { flag_noconvert = flag; return *this; }
-
- const char *name; ///< If non-null, this is a named kwargs argument
- bool flag_noconvert : 1; ///< If set, do not allow conversion (requires a supporting type caster!)
-};
-
-/// \ingroup annotations
-/// Annotation for arguments with values
-struct arg_v : arg {
-private:
- template <typename T>
- arg_v(arg &&base, T &&x, const char *descr = nullptr)
- : arg(base),
- value(reinterpret_steal<object>(
- detail::make_caster<T>::cast(x, return_value_policy::automatic, {})
- )),
- descr(descr)
-#if !defined(NDEBUG)
- , type(type_id<T>())
-#endif
- { }
-
-public:
- /// Direct construction with name, default, and description
- template <typename T>
- arg_v(const char *name, T &&x, const char *descr = nullptr)
- : arg_v(arg(name), std::forward<T>(x), descr) { }
-
- /// Called internally when invoking `py::arg("a") = value`
- template <typename T>
- arg_v(const arg &base, T &&x, const char *descr = nullptr)
- : arg_v(arg(base), std::forward<T>(x), descr) { }
-
- /// Same as `arg::noconvert()`, but returns *this as arg_v&, not arg&
- arg_v &noconvert(bool flag = true) { arg::noconvert(flag); return *this; }
-
- /// The default value
- object value;
- /// The (optional) description of the default value
- const char *descr;
-#if !defined(NDEBUG)
- /// The C++ type name of the default value (only available when compiled in debug mode)
- std::string type;
-#endif
-};
-
-template <typename T>
-arg_v arg::operator=(T &&value) const { return {std::move(*this), std::forward<T>(value)}; }
-
-/// Alias for backward compatibility -- to be removed in version 2.0
-template <typename /*unused*/> using arg_t = arg_v;
-
-inline namespace literals {
-/** \rst
- String literal version of `arg`
- \endrst */
-constexpr arg operator"" _a(const char *name, size_t) { return arg(name); }
-}
-
-NAMESPACE_BEGIN(detail)
-
-// forward declaration
-struct function_record;
-
-/// Internal data associated with a single function call
-struct function_call {
- function_call(function_record &f, handle p); // Implementation in attr.h
-
- /// The function data:
- const function_record &func;
-
- /// Arguments passed to the function:
- std::vector<handle> args;
-
- /// The `convert` value the arguments should be loaded with
- std::vector<bool> args_convert;
-
- /// The parent, if any
- handle parent;
-};
-
-
-/// Helper class which loads arguments for C++ functions called from Python
-template <typename... Args>
-class argument_loader {
- using indices = make_index_sequence<sizeof...(Args)>;
-
- template <typename Arg> using argument_is_args = std::is_same<intrinsic_t<Arg>, args>;
- template <typename Arg> using argument_is_kwargs = std::is_same<intrinsic_t<Arg>, kwargs>;
- // Get args/kwargs argument positions relative to the end of the argument list:
- static constexpr auto args_pos = constexpr_first<argument_is_args, Args...>() - (int) sizeof...(Args),
- kwargs_pos = constexpr_first<argument_is_kwargs, Args...>() - (int) sizeof...(Args);
-
- static constexpr bool args_kwargs_are_last = kwargs_pos >= - 1 && args_pos >= kwargs_pos - 1;
-
- static_assert(args_kwargs_are_last, "py::args/py::kwargs are only permitted as the last argument(s) of a function");
-
-public:
- static constexpr bool has_kwargs = kwargs_pos < 0;
- static constexpr bool has_args = args_pos < 0;
-
- static PYBIND11_DESCR arg_names() { return detail::concat(make_caster<Args>::name()...); }
-
- bool load_args(function_call &call) {
- return load_impl_sequence(call, indices{});
- }
-
- template <typename Return, typename Func>
- enable_if_t<!std::is_void<Return>::value, Return> call(Func &&f) {
- return call_impl<Return>(std::forward<Func>(f), indices{});
- }
-
- template <typename Return, typename Func>
- enable_if_t<std::is_void<Return>::value, void_type> call(Func &&f) {
- call_impl<Return>(std::forward<Func>(f), indices{});
- return void_type();
- }
-
-private:
-
- static bool load_impl_sequence(function_call &, index_sequence<>) { return true; }
-
- template <size_t... Is>
- bool load_impl_sequence(function_call &call, index_sequence<Is...>) {
- for (bool r : {std::get<Is>(value).load(call.args[Is], call.args_convert[Is])...})
- if (!r)
- return false;
- return true;
- }
-
- template <typename Return, typename Func, size_t... Is>
- Return call_impl(Func &&f, index_sequence<Is...>) {
- return std::forward<Func>(f)(cast_op<Args>(std::get<Is>(value))...);
- }
-
- std::tuple<make_caster<Args>...> value;
-};
-
-/// Helper class which collects only positional arguments for a Python function call.
-/// A fancier version below can collect any argument, but this one is optimal for simple calls.
-template <return_value_policy policy>
-class simple_collector {
-public:
- template <typename... Ts>
- explicit simple_collector(Ts &&...values)
- : m_args(pybind11::make_tuple<policy>(std::forward<Ts>(values)...)) { }
-
- const tuple &args() const & { return m_args; }
- dict kwargs() const { return {}; }
-
- tuple args() && { return std::move(m_args); }
-
- /// Call a Python function and pass the collected arguments
- object call(PyObject *ptr) const {
- PyObject *result = PyObject_CallObject(ptr, m_args.ptr());
- if (!result)
- throw error_already_set();
- return reinterpret_steal<object>(result);
- }
-
-private:
- tuple m_args;
-};
-
-/// Helper class which collects positional, keyword, * and ** arguments for a Python function call
-template <return_value_policy policy>
-class unpacking_collector {
-public:
- template <typename... Ts>
- explicit unpacking_collector(Ts &&...values) {
- // Tuples aren't (easily) resizable so a list is needed for collection,
- // but the actual function call strictly requires a tuple.
- auto args_list = list();
- int _[] = { 0, (process(args_list, std::forward<Ts>(values)), 0)... };
- ignore_unused(_);
-
- m_args = std::move(args_list);
- }
-
- const tuple &args() const & { return m_args; }
- const dict &kwargs() const & { return m_kwargs; }
-
- tuple args() && { return std::move(m_args); }
- dict kwargs() && { return std::move(m_kwargs); }
-
- /// Call a Python function and pass the collected arguments
- object call(PyObject *ptr) const {
- PyObject *result = PyObject_Call(ptr, m_args.ptr(), m_kwargs.ptr());
- if (!result)
- throw error_already_set();
- return reinterpret_steal<object>(result);
- }
-
-private:
- template <typename T>
- void process(list &args_list, T &&x) {
- auto o = reinterpret_steal<object>(detail::make_caster<T>::cast(std::forward<T>(x), policy, {}));
- if (!o) {
-#if defined(NDEBUG)
- argument_cast_error();
-#else
- argument_cast_error(std::to_string(args_list.size()), type_id<T>());
-#endif
- }
- args_list.append(o);
- }
-
- void process(list &args_list, detail::args_proxy ap) {
- for (const auto &a : ap)
- args_list.append(a);
- }
-
- void process(list &/*args_list*/, arg_v a) {
- if (!a.name)
-#if defined(NDEBUG)
- nameless_argument_error();
-#else
- nameless_argument_error(a.type);
-#endif
-
- if (m_kwargs.contains(a.name)) {
-#if defined(NDEBUG)
- multiple_values_error();
-#else
- multiple_values_error(a.name);
-#endif
- }
- if (!a.value) {
-#if defined(NDEBUG)
- argument_cast_error();
-#else
- argument_cast_error(a.name, a.type);
-#endif
- }
- m_kwargs[a.name] = a.value;
- }
-
- void process(list &/*args_list*/, detail::kwargs_proxy kp) {
- if (!kp)
- return;
- for (const auto &k : reinterpret_borrow<dict>(kp)) {
- if (m_kwargs.contains(k.first)) {
-#if defined(NDEBUG)
- multiple_values_error();
-#else
- multiple_values_error(str(k.first));
-#endif
- }
- m_kwargs[k.first] = k.second;
- }
- }
-
- [[noreturn]] static void nameless_argument_error() {
- throw type_error("Got kwargs without a name; only named arguments "
- "may be passed via py::arg() to a python function call. "
- "(compile in debug mode for details)");
- }
- [[noreturn]] static void nameless_argument_error(std::string type) {
- throw type_error("Got kwargs without a name of type '" + type + "'; only named "
- "arguments may be passed via py::arg() to a python function call. ");
- }
- [[noreturn]] static void multiple_values_error() {
- throw type_error("Got multiple values for keyword argument "
- "(compile in debug mode for details)");
- }
-
- [[noreturn]] static void multiple_values_error(std::string name) {
- throw type_error("Got multiple values for keyword argument '" + name + "'");
- }
-
- [[noreturn]] static void argument_cast_error() {
- throw cast_error("Unable to convert call argument to Python object "
- "(compile in debug mode for details)");
- }
-
- [[noreturn]] static void argument_cast_error(std::string name, std::string type) {
- throw cast_error("Unable to convert call argument '" + name
- + "' of type '" + type + "' to Python object");
- }
-
-private:
- tuple m_args;
- dict m_kwargs;
-};
-
-/// Collect only positional arguments for a Python function call
-template <return_value_policy policy, typename... Args,
- typename = enable_if_t<all_of<is_positional<Args>...>::value>>
-simple_collector<policy> collect_arguments(Args &&...args) {
- return simple_collector<policy>(std::forward<Args>(args)...);
-}
-
-/// Collect all arguments, including keywords and unpacking (only instantiated when needed)
-template <return_value_policy policy, typename... Args,
- typename = enable_if_t<!all_of<is_positional<Args>...>::value>>
-unpacking_collector<policy> collect_arguments(Args &&...args) {
- // Following argument order rules for generalized unpacking according to PEP 448
- static_assert(
- constexpr_last<is_positional, Args...>() < constexpr_first<is_keyword_or_ds, Args...>()
- && constexpr_last<is_s_unpacking, Args...>() < constexpr_first<is_ds_unpacking, Args...>(),
- "Invalid function call: positional args must precede keywords and ** unpacking; "
- "* unpacking must precede ** unpacking"
- );
- return unpacking_collector<policy>(std::forward<Args>(args)...);
-}
-
-template <typename Derived>
-template <return_value_policy policy, typename... Args>
-object object_api<Derived>::operator()(Args &&...args) const {
- return detail::collect_arguments<policy>(std::forward<Args>(args)...).call(derived().ptr());
-}
-
-template <typename Derived>
-template <return_value_policy policy, typename... Args>
-object object_api<Derived>::call(Args &&...args) const {
- return operator()<policy>(std::forward<Args>(args)...);
-}
-
-NAMESPACE_END(detail)
-
-#define PYBIND11_MAKE_OPAQUE(Type) \
- namespace pybind11 { namespace detail { \
- template<> class type_caster<Type> : public type_caster_base<Type> { }; \
- }}
-
-NAMESPACE_END(pybind11)
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/chrono.h b/thirdparty/pybind11/pybind11/include/pybind11/chrono.h
deleted file mode 100644
index 8a41d08b0c1570adc0efada9d7d5cf74fe326158..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/chrono.h
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
- pybind11/chrono.h: Transparent conversion between std::chrono and python's datetime
-
- Copyright (c) 2016 Trent Houliston <trent@houliston.me> and
- Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "pybind11.h"
-#include <cmath>
-#include <ctime>
-#include <chrono>
-#include <datetime.h>
-
-// Backport the PyDateTime_DELTA functions from Python3.3 if required
-#ifndef PyDateTime_DELTA_GET_DAYS
-#define PyDateTime_DELTA_GET_DAYS(o) (((PyDateTime_Delta*)o)->days)
-#endif
-#ifndef PyDateTime_DELTA_GET_SECONDS
-#define PyDateTime_DELTA_GET_SECONDS(o) (((PyDateTime_Delta*)o)->seconds)
-#endif
-#ifndef PyDateTime_DELTA_GET_MICROSECONDS
-#define PyDateTime_DELTA_GET_MICROSECONDS(o) (((PyDateTime_Delta*)o)->microseconds)
-#endif
-
-NAMESPACE_BEGIN(pybind11)
-NAMESPACE_BEGIN(detail)
-
-template <typename type> class duration_caster {
-public:
- typedef typename type::rep rep;
- typedef typename type::period period;
-
- typedef std::chrono::duration<uint_fast32_t, std::ratio<86400>> days;
-
- bool load(handle src, bool) {
- using namespace std::chrono;
-
- // Lazy initialise the PyDateTime import
- if (!PyDateTimeAPI) { PyDateTime_IMPORT; }
-
- if (!src) return false;
- // If invoked with datetime.delta object
- if (PyDelta_Check(src.ptr())) {
- value = type(duration_cast<duration<rep, period>>(
- days(PyDateTime_DELTA_GET_DAYS(src.ptr()))
- + seconds(PyDateTime_DELTA_GET_SECONDS(src.ptr()))
- + microseconds(PyDateTime_DELTA_GET_MICROSECONDS(src.ptr()))));
- return true;
- }
- // If invoked with a float we assume it is seconds and convert
- else if (PyFloat_Check(src.ptr())) {
- value = type(duration_cast<duration<rep, period>>(duration<double>(PyFloat_AsDouble(src.ptr()))));
- return true;
- }
- else return false;
- }
-
- // If this is a duration just return it back
- static const std::chrono::duration<rep, period>& get_duration(const std::chrono::duration<rep, period> &src) {
- return src;
- }
-
- // If this is a time_point get the time_since_epoch
- template <typename Clock> static std::chrono::duration<rep, period> get_duration(const std::chrono::time_point<Clock, std::chrono::duration<rep, period>> &src) {
- return src.time_since_epoch();
- }
-
- static handle cast(const type &src, return_value_policy /* policy */, handle /* parent */) {
- using namespace std::chrono;
-
- // Use overloaded function to get our duration from our source
- // Works out if it is a duration or time_point and get the duration
- auto d = get_duration(src);
-
- // Lazy initialise the PyDateTime import
- if (!PyDateTimeAPI) { PyDateTime_IMPORT; }
-
- // Declare these special duration types so the conversions happen with the correct primitive types (int)
- using dd_t = duration<int, std::ratio<86400>>;
- using ss_t = duration<int, std::ratio<1>>;
- using us_t = duration<int, std::micro>;
-
- auto dd = duration_cast<dd_t>(d);
- auto subd = d - dd;
- auto ss = duration_cast<ss_t>(subd);
- auto us = duration_cast<us_t>(subd - ss);
- return PyDelta_FromDSU(dd.count(), ss.count(), us.count());
- }
-
- PYBIND11_TYPE_CASTER(type, _("datetime.timedelta"));
-};
-
-// This is for casting times on the system clock into datetime.datetime instances
-template <typename Duration> class type_caster<std::chrono::time_point<std::chrono::system_clock, Duration>> {
-public:
- typedef std::chrono::time_point<std::chrono::system_clock, Duration> type;
- bool load(handle src, bool) {
- using namespace std::chrono;
-
- // Lazy initialise the PyDateTime import
- if (!PyDateTimeAPI) { PyDateTime_IMPORT; }
-
- if (!src) return false;
- if (PyDateTime_Check(src.ptr())) {
- std::tm cal;
- cal.tm_sec = PyDateTime_DATE_GET_SECOND(src.ptr());
- cal.tm_min = PyDateTime_DATE_GET_MINUTE(src.ptr());
- cal.tm_hour = PyDateTime_DATE_GET_HOUR(src.ptr());
- cal.tm_mday = PyDateTime_GET_DAY(src.ptr());
- cal.tm_mon = PyDateTime_GET_MONTH(src.ptr()) - 1;
- cal.tm_year = PyDateTime_GET_YEAR(src.ptr()) - 1900;
- cal.tm_isdst = -1;
-
- value = system_clock::from_time_t(std::mktime(&cal)) + microseconds(PyDateTime_DATE_GET_MICROSECOND(src.ptr()));
- return true;
- }
- else return false;
- }
-
- static handle cast(const std::chrono::time_point<std::chrono::system_clock, Duration> &src, return_value_policy /* policy */, handle /* parent */) {
- using namespace std::chrono;
-
- // Lazy initialise the PyDateTime import
- if (!PyDateTimeAPI) { PyDateTime_IMPORT; }
-
- std::time_t tt = system_clock::to_time_t(src);
- // this function uses static memory so it's best to copy it out asap just in case
- // otherwise other code that is using localtime may break this (not just python code)
- std::tm localtime = *std::localtime(&tt);
-
- // Declare these special duration types so the conversions happen with the correct primitive types (int)
- using us_t = duration<int, std::micro>;
-
- return PyDateTime_FromDateAndTime(localtime.tm_year + 1900,
- localtime.tm_mon + 1,
- localtime.tm_mday,
- localtime.tm_hour,
- localtime.tm_min,
- localtime.tm_sec,
- (duration_cast<us_t>(src.time_since_epoch() % seconds(1))).count());
- }
- PYBIND11_TYPE_CASTER(type, _("datetime.datetime"));
-};
-
-// Other clocks that are not the system clock are not measured as datetime.datetime objects
-// since they are not measured on calendar time. So instead we just make them timedeltas
-// Or if they have passed us a time as a float we convert that
-template <typename Clock, typename Duration> class type_caster<std::chrono::time_point<Clock, Duration>>
-: public duration_caster<std::chrono::time_point<Clock, Duration>> {
-};
-
-template <typename Rep, typename Period> class type_caster<std::chrono::duration<Rep, Period>>
-: public duration_caster<std::chrono::duration<Rep, Period>> {
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(pybind11)
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/class_support.h b/thirdparty/pybind11/pybind11/include/pybind11/class_support.h
deleted file mode 100644
index 992703ff321989150d052618bf8d51b3306a99d9..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/class_support.h
+++ /dev/null
@@ -1,504 +0,0 @@
-/*
- pybind11/class_support.h: Python C API implementation details for py::class_
-
- Copyright (c) 2017 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "attr.h"
-
-NAMESPACE_BEGIN(pybind11)
-NAMESPACE_BEGIN(detail)
-
-#if !defined(PYPY_VERSION)
-
-/// `pybind11_static_property.__get__()`: Always pass the class instead of the instance.
-extern "C" inline PyObject *pybind11_static_get(PyObject *self, PyObject * /*ob*/, PyObject *cls) {
- return PyProperty_Type.tp_descr_get(self, cls, cls);
-}
-
-/// `pybind11_static_property.__set__()`: Just like the above `__get__()`.
-extern "C" inline int pybind11_static_set(PyObject *self, PyObject *obj, PyObject *value) {
- PyObject *cls = PyType_Check(obj) ? obj : (PyObject *) Py_TYPE(obj);
- return PyProperty_Type.tp_descr_set(self, cls, value);
-}
-
-/** A `static_property` is the same as a `property` but the `__get__()` and `__set__()`
- methods are modified to always use the object type instead of a concrete instance.
- Return value: New reference. */
-inline PyTypeObject *make_static_property_type() {
- constexpr auto *name = "pybind11_static_property";
- auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name));
-
- /* Danger zone: from now (and until PyType_Ready), make sure to
- issue no Python C API calls which could potentially invoke the
- garbage collector (the GC will call type_traverse(), which will in
- turn find the newly constructed type in an invalid state) */
- auto heap_type = (PyHeapTypeObject *) PyType_Type.tp_alloc(&PyType_Type, 0);
- if (!heap_type)
- pybind11_fail("make_static_property_type(): error allocating type!");
-
- heap_type->ht_name = name_obj.inc_ref().ptr();
-#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
- heap_type->ht_qualname = name_obj.inc_ref().ptr();
-#endif
-
- auto type = &heap_type->ht_type;
- type->tp_name = name;
- type->tp_base = &PyProperty_Type;
- type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
- type->tp_descr_get = pybind11_static_get;
- type->tp_descr_set = pybind11_static_set;
-
- if (PyType_Ready(type) < 0)
- pybind11_fail("make_static_property_type(): failure in PyType_Ready()!");
-
- setattr((PyObject *) type, "__module__", str("pybind11_builtins"));
-
- return type;
-}
-
-#else // PYPY
-
-/** PyPy has some issues with the above C API, so we evaluate Python code instead.
- This function will only be called once so performance isn't really a concern.
- Return value: New reference. */
-inline PyTypeObject *make_static_property_type() {
- auto d = dict();
- PyObject *result = PyRun_String(R"(\
- class pybind11_static_property(property):
- def __get__(self, obj, cls):
- return property.__get__(self, cls, cls)
-
- def __set__(self, obj, value):
- cls = obj if isinstance(obj, type) else type(obj)
- property.__set__(self, cls, value)
- )", Py_file_input, d.ptr(), d.ptr()
- );
- if (result == nullptr)
- throw error_already_set();
- Py_DECREF(result);
- return (PyTypeObject *) d["pybind11_static_property"].cast<object>().release().ptr();
-}
-
-#endif // PYPY
-
-/** Inheriting from multiple C++ types in Python is not supported -- set an error instead.
- A Python definition (`class C(A, B): pass`) will call `tp_new` so we check for multiple
- C++ bases here. On the other hand, C++ type definitions (`py::class_<C, A, B>(m, "C")`)
- don't not use `tp_new` and will not trigger this error. */
-extern "C" inline PyObject *pybind11_meta_new(PyTypeObject *metaclass, PyObject *args,
- PyObject *kwargs) {
- PyObject *bases = PyTuple_GetItem(args, 1); // arguments: (name, bases, dict)
- if (!bases)
- return nullptr;
-
- auto &internals = get_internals();
- auto num_cpp_bases = 0;
- for (auto base : reinterpret_borrow<tuple>(bases)) {
- auto base_type = (PyTypeObject *) base.ptr();
- auto instance_size = static_cast<size_t>(base_type->tp_basicsize);
- if (PyObject_IsSubclass(base.ptr(), internals.get_base(instance_size)))
- ++num_cpp_bases;
- }
-
- if (num_cpp_bases > 1) {
- PyErr_SetString(PyExc_TypeError, "Can't inherit from multiple C++ classes in Python."
- "Use py::class_ to define the class in C++ instead.");
- return nullptr;
- } else {
- return PyType_Type.tp_new(metaclass, args, kwargs);
- }
-}
-
-/** Types with static properties need to handle `Type.static_prop = x` in a specific way.
- By default, Python replaces the `static_property` itself, but for wrapped C++ types
- we need to call `static_property.__set__()` in order to propagate the new value to
- the underlying C++ data structure. */
-extern "C" inline int pybind11_meta_setattro(PyObject* obj, PyObject* name, PyObject* value) {
- // Use `_PyType_Lookup()` instead of `PyObject_GetAttr()` in order to get the raw
- // descriptor (`property`) instead of calling `tp_descr_get` (`property.__get__()`).
- PyObject *descr = _PyType_Lookup((PyTypeObject *) obj, name);
-
- // Call `static_property.__set__()` instead of replacing the `static_property`.
- if (descr && PyObject_IsInstance(descr, (PyObject *) get_internals().static_property_type)) {
-#if !defined(PYPY_VERSION)
- return Py_TYPE(descr)->tp_descr_set(descr, obj, value);
-#else
- if (PyObject *result = PyObject_CallMethod(descr, "__set__", "OO", obj, value)) {
- Py_DECREF(result);
- return 0;
- } else {
- return -1;
- }
-#endif
- } else {
- return PyType_Type.tp_setattro(obj, name, value);
- }
-}
-
-/** This metaclass is assigned by default to all pybind11 types and is required in order
- for static properties to function correctly. Users may override this using `py::metaclass`.
- Return value: New reference. */
-inline PyTypeObject* make_default_metaclass() {
- constexpr auto *name = "pybind11_type";
- auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name));
-
- /* Danger zone: from now (and until PyType_Ready), make sure to
- issue no Python C API calls which could potentially invoke the
- garbage collector (the GC will call type_traverse(), which will in
- turn find the newly constructed type in an invalid state) */
- auto heap_type = (PyHeapTypeObject *) PyType_Type.tp_alloc(&PyType_Type, 0);
- if (!heap_type)
- pybind11_fail("make_default_metaclass(): error allocating metaclass!");
-
- heap_type->ht_name = name_obj.inc_ref().ptr();
-#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
- heap_type->ht_qualname = name_obj.inc_ref().ptr();
-#endif
-
- auto type = &heap_type->ht_type;
- type->tp_name = name;
- type->tp_base = &PyType_Type;
- type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
-
- type->tp_new = pybind11_meta_new;
- type->tp_setattro = pybind11_meta_setattro;
-
- if (PyType_Ready(type) < 0)
- pybind11_fail("make_default_metaclass(): failure in PyType_Ready()!");
-
- setattr((PyObject *) type, "__module__", str("pybind11_builtins"));
-
- return type;
-}
-
-/// Instance creation function for all pybind11 types. It only allocates space for the
-/// C++ object, but doesn't call the constructor -- an `__init__` function must do that.
-extern "C" inline PyObject *pybind11_object_new(PyTypeObject *type, PyObject *, PyObject *) {
- PyObject *self = type->tp_alloc(type, 0);
- auto instance = (instance_essentials<void> *) self;
- auto tinfo = get_type_info(type);
- instance->value = tinfo->operator_new(tinfo->type_size);
- instance->owned = true;
- instance->holder_constructed = false;
- get_internals().registered_instances.emplace(instance->value, self);
- return self;
-}
-
-/// An `__init__` function constructs the C++ object. Users should provide at least one
-/// of these using `py::init` or directly with `.def(__init__, ...)`. Otherwise, the
-/// following default function will be used which simply throws an exception.
-extern "C" inline int pybind11_object_init(PyObject *self, PyObject *, PyObject *) {
- PyTypeObject *type = Py_TYPE(self);
- std::string msg;
-#if defined(PYPY_VERSION)
- msg += handle((PyObject *) type).attr("__module__").cast<std::string>() + ".";
-#endif
- msg += type->tp_name;
- msg += ": No constructor defined!";
- PyErr_SetString(PyExc_TypeError, msg.c_str());
- return -1;
-}
-
-/// Instance destructor function for all pybind11 types. It calls `type_info.dealloc`
-/// to destroy the C++ object itself, while the rest is Python bookkeeping.
-extern "C" inline void pybind11_object_dealloc(PyObject *self) {
- auto instance = (instance_essentials<void> *) self;
- if (instance->value) {
- auto type = Py_TYPE(self);
- get_type_info(type)->dealloc(self);
-
- auto ®istered_instances = get_internals().registered_instances;
- auto range = registered_instances.equal_range(instance->value);
- bool found = false;
- for (auto it = range.first; it != range.second; ++it) {
- if (type == Py_TYPE(it->second)) {
- registered_instances.erase(it);
- found = true;
- break;
- }
- }
- if (!found)
- pybind11_fail("pybind11_object_dealloc(): Tried to deallocate unregistered instance!");
-
- if (instance->weakrefs)
- PyObject_ClearWeakRefs(self);
-
- PyObject **dict_ptr = _PyObject_GetDictPtr(self);
- if (dict_ptr)
- Py_CLEAR(*dict_ptr);
- }
- Py_TYPE(self)->tp_free(self);
-}
-
-/** Create a type which can be used as a common base for all classes with the same
- instance size, i.e. all classes with the same `sizeof(holder_type)`. This is
- needed in order to satisfy Python's requirements for multiple inheritance.
- Return value: New reference. */
-inline PyObject *make_object_base_type(size_t instance_size) {
- auto name = "pybind11_object_" + std::to_string(instance_size);
- auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name.c_str()));
-
- /* Danger zone: from now (and until PyType_Ready), make sure to
- issue no Python C API calls which could potentially invoke the
- garbage collector (the GC will call type_traverse(), which will in
- turn find the newly constructed type in an invalid state) */
- auto metaclass = get_internals().default_metaclass;
- auto heap_type = (PyHeapTypeObject *) metaclass->tp_alloc(metaclass, 0);
- if (!heap_type)
- pybind11_fail("make_object_base_type(): error allocating type!");
-
- heap_type->ht_name = name_obj.inc_ref().ptr();
-#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
- heap_type->ht_qualname = name_obj.inc_ref().ptr();
-#endif
-
- auto type = &heap_type->ht_type;
- type->tp_name = strdup(name.c_str());
- type->tp_base = &PyBaseObject_Type;
- type->tp_basicsize = static_cast<ssize_t>(instance_size);
- type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
-
- type->tp_new = pybind11_object_new;
- type->tp_init = pybind11_object_init;
- type->tp_dealloc = pybind11_object_dealloc;
-
- /* Support weak references (needed for the keep_alive feature) */
- type->tp_weaklistoffset = offsetof(instance_essentials<void>, weakrefs);
-
- if (PyType_Ready(type) < 0)
- pybind11_fail("PyType_Ready failed in make_object_base_type():" + error_string());
-
- setattr((PyObject *) type, "__module__", str("pybind11_builtins"));
-
- assert(!PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC));
- return (PyObject *) heap_type;
-}
-
-/** Return the appropriate base type for the given instance size. The results are cached
- in `internals.bases` so that only a single base is ever created for any size value.
- Return value: Borrowed reference. */
-inline PyObject *internals::get_base(size_t instance_size) {
- auto it = bases.find(instance_size);
- if (it != bases.end()) {
- return it->second;
- } else {
- auto base = make_object_base_type(instance_size);
- bases[instance_size] = base;
- return base;
- }
-}
-
-/// dynamic_attr: Support for `d = instance.__dict__`.
-extern "C" inline PyObject *pybind11_get_dict(PyObject *self, void *) {
- PyObject *&dict = *_PyObject_GetDictPtr(self);
- if (!dict)
- dict = PyDict_New();
- Py_XINCREF(dict);
- return dict;
-}
-
-/// dynamic_attr: Support for `instance.__dict__ = dict()`.
-extern "C" inline int pybind11_set_dict(PyObject *self, PyObject *new_dict, void *) {
- if (!PyDict_Check(new_dict)) {
- PyErr_Format(PyExc_TypeError, "__dict__ must be set to a dictionary, not a '%.200s'",
- Py_TYPE(new_dict)->tp_name);
- return -1;
- }
- PyObject *&dict = *_PyObject_GetDictPtr(self);
- Py_INCREF(new_dict);
- Py_CLEAR(dict);
- dict = new_dict;
- return 0;
-}
-
-/// dynamic_attr: Allow the garbage collector to traverse the internal instance `__dict__`.
-extern "C" inline int pybind11_traverse(PyObject *self, visitproc visit, void *arg) {
- PyObject *&dict = *_PyObject_GetDictPtr(self);
- Py_VISIT(dict);
- return 0;
-}
-
-/// dynamic_attr: Allow the GC to clear the dictionary.
-extern "C" inline int pybind11_clear(PyObject *self) {
- PyObject *&dict = *_PyObject_GetDictPtr(self);
- Py_CLEAR(dict);
- return 0;
-}
-
-/// Give instances of this type a `__dict__` and opt into garbage collection.
-inline void enable_dynamic_attributes(PyHeapTypeObject *heap_type) {
- auto type = &heap_type->ht_type;
-#if defined(PYPY_VERSION)
- pybind11_fail(std::string(type->tp_name) + ": dynamic attributes are "
- "currently not supported in "
- "conjunction with PyPy!");
-#endif
- type->tp_flags |= Py_TPFLAGS_HAVE_GC;
- type->tp_dictoffset = type->tp_basicsize; // place dict at the end
- type->tp_basicsize += sizeof(PyObject *); // and allocate enough space for it
- type->tp_traverse = pybind11_traverse;
- type->tp_clear = pybind11_clear;
-
- static PyGetSetDef getset[] = {
- {const_cast<char*>("__dict__"), pybind11_get_dict, pybind11_set_dict, nullptr, nullptr},
- {nullptr, nullptr, nullptr, nullptr, nullptr}
- };
- type->tp_getset = getset;
-}
-
-/// buffer_protocol: Fill in the view as specified by flags.
-extern "C" inline int pybind11_getbuffer(PyObject *obj, Py_buffer *view, int flags) {
- auto tinfo = get_type_info(Py_TYPE(obj));
- if (view == nullptr || obj == nullptr || !tinfo || !tinfo->get_buffer) {
- if (view)
- view->obj = nullptr;
- PyErr_SetString(PyExc_BufferError, "generic_type::getbuffer(): Internal error");
- return -1;
- }
- memset(view, 0, sizeof(Py_buffer));
- buffer_info *info = tinfo->get_buffer(obj, tinfo->get_buffer_data);
- view->obj = obj;
- view->ndim = 1;
- view->internal = info;
- view->buf = info->ptr;
- view->itemsize = (ssize_t) info->itemsize;
- view->len = view->itemsize;
- for (auto s : info->shape)
- view->len *= s;
- if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT)
- view->format = const_cast<char *>(info->format.c_str());
- if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) {
- view->ndim = (int) info->ndim;
- view->strides = (ssize_t *) &info->strides[0];
- view->shape = (ssize_t *) &info->shape[0];
- }
- Py_INCREF(view->obj);
- return 0;
-}
-
-/// buffer_protocol: Release the resources of the buffer.
-extern "C" inline void pybind11_releasebuffer(PyObject *, Py_buffer *view) {
- delete (buffer_info *) view->internal;
-}
-
-/// Give this type a buffer interface.
-inline void enable_buffer_protocol(PyHeapTypeObject *heap_type) {
- heap_type->ht_type.tp_as_buffer = &heap_type->as_buffer;
-#if PY_MAJOR_VERSION < 3
- heap_type->ht_type.tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER;
-#endif
-
- heap_type->as_buffer.bf_getbuffer = pybind11_getbuffer;
- heap_type->as_buffer.bf_releasebuffer = pybind11_releasebuffer;
-}
-
-/** Create a brand new Python type according to the `type_record` specification.
- Return value: New reference. */
-inline PyObject* make_new_python_type(const type_record &rec) {
- auto name = reinterpret_steal<object>(PYBIND11_FROM_STRING(rec.name));
-
-#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
- auto ht_qualname = name;
- if (rec.scope && hasattr(rec.scope, "__qualname__")) {
- ht_qualname = reinterpret_steal<object>(
- PyUnicode_FromFormat("%U.%U", rec.scope.attr("__qualname__").ptr(), name.ptr()));
- }
-#endif
-
- object module;
- if (rec.scope) {
- if (hasattr(rec.scope, "__module__"))
- module = rec.scope.attr("__module__");
- else if (hasattr(rec.scope, "__name__"))
- module = rec.scope.attr("__name__");
- }
-
-#if !defined(PYPY_VERSION)
- const auto full_name = module ? str(module).cast<std::string>() + "." + rec.name
- : std::string(rec.name);
-#else
- const auto full_name = std::string(rec.name);
-#endif
-
- char *tp_doc = nullptr;
- if (rec.doc && options::show_user_defined_docstrings()) {
- /* Allocate memory for docstring (using PyObject_MALLOC, since
- Python will free this later on) */
- size_t size = strlen(rec.doc) + 1;
- tp_doc = (char *) PyObject_MALLOC(size);
- memcpy((void *) tp_doc, rec.doc, size);
- }
-
- auto &internals = get_internals();
- auto bases = tuple(rec.bases);
- auto base = (bases.size() == 0) ? internals.get_base(rec.instance_size)
- : bases[0].ptr();
-
- /* Danger zone: from now (and until PyType_Ready), make sure to
- issue no Python C API calls which could potentially invoke the
- garbage collector (the GC will call type_traverse(), which will in
- turn find the newly constructed type in an invalid state) */
- auto metaclass = rec.metaclass.ptr() ? (PyTypeObject *) rec.metaclass.ptr()
- : internals.default_metaclass;
-
- auto heap_type = (PyHeapTypeObject *) metaclass->tp_alloc(metaclass, 0);
- if (!heap_type)
- pybind11_fail(std::string(rec.name) + ": Unable to create type object!");
-
- heap_type->ht_name = name.release().ptr();
-#if PY_MAJOR_VERSION >= 3 && PY_MINOR_VERSION >= 3
- heap_type->ht_qualname = ht_qualname.release().ptr();
-#endif
-
- auto type = &heap_type->ht_type;
- type->tp_name = strdup(full_name.c_str());
- type->tp_doc = tp_doc;
- type->tp_base = (PyTypeObject *) handle(base).inc_ref().ptr();
- type->tp_basicsize = static_cast<ssize_t>(rec.instance_size);
- if (bases.size() > 0)
- type->tp_bases = bases.release().ptr();
-
- /* Don't inherit base __init__ */
- type->tp_init = pybind11_object_init;
-
- /* Supported protocols */
- type->tp_as_number = &heap_type->as_number;
- type->tp_as_sequence = &heap_type->as_sequence;
- type->tp_as_mapping = &heap_type->as_mapping;
-
- /* Flags */
- type->tp_flags |= Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
-#if PY_MAJOR_VERSION < 3
- type->tp_flags |= Py_TPFLAGS_CHECKTYPES;
-#endif
-
- if (rec.dynamic_attr)
- enable_dynamic_attributes(heap_type);
-
- if (rec.buffer_protocol)
- enable_buffer_protocol(heap_type);
-
- if (PyType_Ready(type) < 0)
- pybind11_fail(std::string(rec.name) + ": PyType_Ready failed (" + error_string() + ")!");
-
- assert(rec.dynamic_attr ? PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC)
- : !PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC));
-
- /* Register type with the parent scope */
- if (rec.scope)
- setattr(rec.scope, rec.name, (PyObject *) type);
-
- if (module) // Needed by pydoc
- setattr((PyObject *) type, "__module__", module);
-
- return (PyObject *) type;
-}
-
-NAMESPACE_END(detail)
-NAMESPACE_END(pybind11)
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/common.h b/thirdparty/pybind11/pybind11/include/pybind11/common.h
deleted file mode 100644
index ac2be7aeffb0efd3243202d97cb473dca8c32d5a..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/common.h
+++ /dev/null
@@ -1,719 +0,0 @@
-/*
- pybind11/common.h -- Basic macros
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#if !defined(NAMESPACE_BEGIN)
-# define NAMESPACE_BEGIN(name) namespace name {
-#endif
-#if !defined(NAMESPACE_END)
-# define NAMESPACE_END(name) }
-#endif
-
-// Neither MSVC nor Intel support enough of C++14 yet (in particular, as of MSVC 2015 and ICC 17
-// beta, neither support extended constexpr, which we rely on in descr.h), so don't enable pybind
-// CPP14 features for them.
-#if !defined(_MSC_VER) && !defined(__INTEL_COMPILER)
-# if __cplusplus >= 201402L
-# define PYBIND11_CPP14
-# if __cplusplus > 201402L /* Temporary: should be updated to >= the final C++17 value once known */
-# define PYBIND11_CPP17
-# endif
-# endif
-#endif
-
-// Compiler version assertions
-#if defined(__INTEL_COMPILER)
-# if __INTEL_COMPILER < 1500
-# error pybind11 requires Intel C++ compiler v15 or newer
-# endif
-#elif defined(__clang__) && !defined(__apple_build_version__)
-# if __clang_major__ < 3 || (__clang_major__ == 3 && __clang_minor__ < 3)
-# error pybind11 requires clang 3.3 or newer
-# endif
-#elif defined(__clang__)
-// Apple changes clang version macros to its Xcode version; the first Xcode release based on
-// (upstream) clang 3.3 was Xcode 5:
-# if __clang_major__ < 5
-# error pybind11 requires Xcode/clang 5.0 or newer
-# endif
-#elif defined(__GNUG__)
-# if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 8)
-# error pybind11 requires gcc 4.8 or newer
-# endif
-#elif defined(_MSC_VER)
-// Pybind hits various compiler bugs in 2015u2 and earlier, and also makes use of some stl features
-// (e.g. std::negation) added in 2015u3:
-# if _MSC_FULL_VER < 190024210
-# error pybind11 requires MSVC 2015 update 3 or newer
-# endif
-#endif
-
-#if !defined(PYBIND11_EXPORT)
-# if defined(WIN32) || defined(_WIN32)
-# define PYBIND11_EXPORT __declspec(dllexport)
-# else
-# define PYBIND11_EXPORT __attribute__ ((visibility("default")))
-# endif
-#endif
-
-#if defined(_MSC_VER)
-# define PYBIND11_NOINLINE __declspec(noinline)
-#else
-# define PYBIND11_NOINLINE __attribute__ ((noinline))
-#endif
-
-#if defined(PYBIND11_CPP14)
-# define PYBIND11_DEPRECATED(reason) [[deprecated(reason)]]
-#elif defined(__clang__)
-# define PYBIND11_DEPRECATED(reason) __attribute__((deprecated(reason)))
-#elif defined(__GNUG__)
-# define PYBIND11_DEPRECATED(reason) __attribute__((deprecated))
-#elif defined(_MSC_VER)
-# define PYBIND11_DEPRECATED(reason) __declspec(deprecated)
-#endif
-
-#define PYBIND11_VERSION_MAJOR 2
-#define PYBIND11_VERSION_MINOR 1
-#define PYBIND11_VERSION_PATCH 1
-
-/// Include Python header, disable linking to pythonX_d.lib on Windows in debug mode
-#if defined(_MSC_VER)
-# if (PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION < 4)
-# define HAVE_ROUND 1
-# endif
-# pragma warning(push)
-# pragma warning(disable: 4510 4610 4512 4005)
-# if defined(_DEBUG)
-# define PYBIND11_DEBUG_MARKER
-# undef _DEBUG
-# endif
-#endif
-
-#include <Python.h>
-#include <frameobject.h>
-#include <pythread.h>
-
-#if defined(_WIN32) && (defined(min) || defined(max))
-# error Macro clash with min and max -- define NOMINMAX when compiling your program on Windows
-#endif
-
-#if defined(isalnum)
-# undef isalnum
-# undef isalpha
-# undef islower
-# undef isspace
-# undef isupper
-# undef tolower
-# undef toupper
-#endif
-
-#if defined(_MSC_VER)
-# if defined(PYBIND11_DEBUG_MARKER)
-# define _DEBUG
-# undef PYBIND11_DEBUG_MARKER
-# endif
-# pragma warning(pop)
-#endif
-
-#include <cstddef>
-#include <forward_list>
-#include <vector>
-#include <string>
-#include <stdexcept>
-#include <unordered_set>
-#include <unordered_map>
-#include <memory>
-#include <typeindex>
-#include <type_traits>
-
-#if PY_MAJOR_VERSION >= 3 /// Compatibility macros for various Python versions
-#define PYBIND11_INSTANCE_METHOD_NEW(ptr, class_) PyInstanceMethod_New(ptr)
-#define PYBIND11_BYTES_CHECK PyBytes_Check
-#define PYBIND11_BYTES_FROM_STRING PyBytes_FromString
-#define PYBIND11_BYTES_FROM_STRING_AND_SIZE PyBytes_FromStringAndSize
-#define PYBIND11_BYTES_AS_STRING_AND_SIZE PyBytes_AsStringAndSize
-#define PYBIND11_BYTES_AS_STRING PyBytes_AsString
-#define PYBIND11_BYTES_SIZE PyBytes_Size
-#define PYBIND11_LONG_CHECK(o) PyLong_Check(o)
-#define PYBIND11_LONG_AS_LONGLONG(o) PyLong_AsLongLong(o)
-#define PYBIND11_LONG_AS_UNSIGNED_LONGLONG(o) PyLong_AsUnsignedLongLong(o)
-#define PYBIND11_BYTES_NAME "bytes"
-#define PYBIND11_STRING_NAME "str"
-#define PYBIND11_SLICE_OBJECT PyObject
-#define PYBIND11_FROM_STRING PyUnicode_FromString
-#define PYBIND11_STR_TYPE ::pybind11::str
-#define PYBIND11_PLUGIN_IMPL(name) \
- extern "C" PYBIND11_EXPORT PyObject *PyInit_##name()
-#else
-#define PYBIND11_INSTANCE_METHOD_NEW(ptr, class_) PyMethod_New(ptr, nullptr, class_)
-#define PYBIND11_BYTES_CHECK PyString_Check
-#define PYBIND11_BYTES_FROM_STRING PyString_FromString
-#define PYBIND11_BYTES_FROM_STRING_AND_SIZE PyString_FromStringAndSize
-#define PYBIND11_BYTES_AS_STRING_AND_SIZE PyString_AsStringAndSize
-#define PYBIND11_BYTES_AS_STRING PyString_AsString
-#define PYBIND11_BYTES_SIZE PyString_Size
-#define PYBIND11_LONG_CHECK(o) (PyInt_Check(o) || PyLong_Check(o))
-#define PYBIND11_LONG_AS_LONGLONG(o) (PyInt_Check(o) ? (long long) PyLong_AsLong(o) : PyLong_AsLongLong(o))
-#define PYBIND11_LONG_AS_UNSIGNED_LONGLONG(o) (PyInt_Check(o) ? (unsigned long long) PyLong_AsUnsignedLong(o) : PyLong_AsUnsignedLongLong(o))
-#define PYBIND11_BYTES_NAME "str"
-#define PYBIND11_STRING_NAME "unicode"
-#define PYBIND11_SLICE_OBJECT PySliceObject
-#define PYBIND11_FROM_STRING PyString_FromString
-#define PYBIND11_STR_TYPE ::pybind11::bytes
-#define PYBIND11_PLUGIN_IMPL(name) \
- static PyObject *pybind11_init_wrapper(); \
- extern "C" PYBIND11_EXPORT void init##name() { \
- (void)pybind11_init_wrapper(); \
- } \
- PyObject *pybind11_init_wrapper()
-#endif
-
-#if PY_VERSION_HEX >= 0x03050000 && PY_VERSION_HEX < 0x03050200
-extern "C" {
- struct _Py_atomic_address { void *value; };
- PyAPI_DATA(_Py_atomic_address) _PyThreadState_Current;
-}
-#endif
-
-#define PYBIND11_TRY_NEXT_OVERLOAD ((PyObject *) 1) // special failure return code
-#define PYBIND11_STRINGIFY(x) #x
-#define PYBIND11_TOSTRING(x) PYBIND11_STRINGIFY(x)
-#define PYBIND11_INTERNALS_ID "__pybind11_" \
- PYBIND11_TOSTRING(PYBIND11_VERSION_MAJOR) "_" PYBIND11_TOSTRING(PYBIND11_VERSION_MINOR) "__"
-
-/** \rst
- This macro creates the entry point that will be invoked when the Python interpreter
- imports a plugin library. Please create a `module` in the function body and return
- the pointer to its underlying Python object at the end.
-
- .. code-block:: cpp
-
- PYBIND11_PLUGIN(example) {
- pybind11::module m("example", "pybind11 example plugin");
- /// Set up bindings here
- return m.ptr();
- }
-\endrst */
-#define PYBIND11_PLUGIN(name) \
- static PyObject *pybind11_init(); \
- PYBIND11_PLUGIN_IMPL(name) { \
- int major, minor; \
- if (sscanf(Py_GetVersion(), "%i.%i", &major, &minor) != 2) { \
- PyErr_SetString(PyExc_ImportError, "Can't parse Python version."); \
- return nullptr; \
- } else if (major != PY_MAJOR_VERSION || minor != PY_MINOR_VERSION) { \
- PyErr_Format(PyExc_ImportError, \
- "Python version mismatch: module was compiled for " \
- "version %i.%i, while the interpreter is running " \
- "version %i.%i.", PY_MAJOR_VERSION, PY_MINOR_VERSION, \
- major, minor); \
- return nullptr; \
- } \
- try { \
- return pybind11_init(); \
- } catch (pybind11::error_already_set &e) { \
- e.clear(); \
- PyErr_SetString(PyExc_ImportError, e.what()); \
- return nullptr; \
- } catch (const std::exception &e) { \
- PyErr_SetString(PyExc_ImportError, e.what()); \
- return nullptr; \
- } \
- } \
- PyObject *pybind11_init()
-
-NAMESPACE_BEGIN(pybind11)
-
-using ssize_t = Py_ssize_t;
-using size_t = std::size_t;
-
-/// Approach used to cast a previously unknown C++ instance into a Python object
-enum class return_value_policy : uint8_t {
- /** This is the default return value policy, which falls back to the policy
- return_value_policy::take_ownership when the return value is a pointer.
- Otherwise, it uses return_value::move or return_value::copy for rvalue
- and lvalue references, respectively. See below for a description of what
- all of these different policies do. */
- automatic = 0,
-
- /** As above, but use policy return_value_policy::reference when the return
- value is a pointer. This is the default conversion policy for function
- arguments when calling Python functions manually from C++ code (i.e. via
- handle::operator()). You probably won't need to use this. */
- automatic_reference,
-
- /** Reference an existing object (i.e. do not create a new copy) and take
- ownership. Python will call the destructor and delete operator when the
- object’s reference count reaches zero. Undefined behavior ensues when
- the C++ side does the same.. */
- take_ownership,
-
- /** Create a new copy of the returned object, which will be owned by
- Python. This policy is comparably safe because the lifetimes of the two
- instances are decoupled. */
- copy,
-
- /** Use std::move to move the return value contents into a new instance
- that will be owned by Python. This policy is comparably safe because the
- lifetimes of the two instances (move source and destination) are
- decoupled. */
- move,
-
- /** Reference an existing object, but do not take ownership. The C++ side
- is responsible for managing the object’s lifetime and deallocating it
- when it is no longer used. Warning: undefined behavior will ensue when
- the C++ side deletes an object that is still referenced and used by
- Python. */
- reference,
-
- /** This policy only applies to methods and properties. It references the
- object without taking ownership similar to the above
- return_value_policy::reference policy. In contrast to that policy, the
- function or property’s implicit this argument (called the parent) is
- considered to be the the owner of the return value (the child).
- pybind11 then couples the lifetime of the parent to the child via a
- reference relationship that ensures that the parent cannot be garbage
- collected while Python is still using the child. More advanced
- variations of this scheme are also possible using combinations of
- return_value_policy::reference and the keep_alive call policy */
- reference_internal
-};
-
-/// Information record describing a Python buffer object
-struct buffer_info {
- void *ptr = nullptr; // Pointer to the underlying storage
- size_t itemsize = 0; // Size of individual items in bytes
- size_t size = 0; // Total number of entries
- std::string format; // For homogeneous buffers, this should be set to format_descriptor<T>::format()
- size_t ndim = 0; // Number of dimensions
- std::vector<size_t> shape; // Shape of the tensor (1 entry per dimension)
- std::vector<size_t> strides; // Number of entries between adjacent entries (for each per dimension)
-
- buffer_info() { }
-
- buffer_info(void *ptr, size_t itemsize, const std::string &format, size_t ndim,
- const std::vector<size_t> &shape, const std::vector<size_t> &strides)
- : ptr(ptr), itemsize(itemsize), size(1), format(format),
- ndim(ndim), shape(shape), strides(strides) {
- for (size_t i = 0; i < ndim; ++i)
- size *= shape[i];
- }
-
- buffer_info(void *ptr, size_t itemsize, const std::string &format, size_t size)
- : buffer_info(ptr, itemsize, format, 1, std::vector<size_t> { size },
- std::vector<size_t> { itemsize }) { }
-
- explicit buffer_info(Py_buffer *view, bool ownview = true)
- : ptr(view->buf), itemsize((size_t) view->itemsize), size(1), format(view->format),
- ndim((size_t) view->ndim), shape((size_t) view->ndim), strides((size_t) view->ndim), view(view), ownview(ownview) {
- for (size_t i = 0; i < (size_t) view->ndim; ++i) {
- shape[i] = (size_t) view->shape[i];
- strides[i] = (size_t) view->strides[i];
- size *= shape[i];
- }
- }
-
- buffer_info(const buffer_info &) = delete;
- buffer_info& operator=(const buffer_info &) = delete;
-
- buffer_info(buffer_info &&other) {
- (*this) = std::move(other);
- }
-
- buffer_info& operator=(buffer_info &&rhs) {
- ptr = rhs.ptr;
- itemsize = rhs.itemsize;
- size = rhs.size;
- format = std::move(rhs.format);
- ndim = rhs.ndim;
- shape = std::move(rhs.shape);
- strides = std::move(rhs.strides);
- std::swap(view, rhs.view);
- std::swap(ownview, rhs.ownview);
- return *this;
- }
-
- ~buffer_info() {
- if (view && ownview) { PyBuffer_Release(view); delete view; }
- }
-
-private:
- Py_buffer *view = nullptr;
- bool ownview = false;
-};
-
-NAMESPACE_BEGIN(detail)
-
-inline static constexpr int log2(size_t n, int k = 0) { return (n <= 1) ? k : log2(n >> 1, k + 1); }
-
-inline std::string error_string();
-
-/// Core part of the 'instance' type which POD (needed to be able to use 'offsetof')
-template <typename type> struct instance_essentials {
- PyObject_HEAD
- type *value;
- PyObject *weakrefs;
- bool owned : 1;
- bool holder_constructed : 1;
-};
-
-/// PyObject wrapper around generic types, includes a special holder type that is responsible for lifetime management
-template <typename type, typename holder_type = std::unique_ptr<type>> struct instance : instance_essentials<type> {
- holder_type holder;
-};
-
-struct overload_hash {
- inline size_t operator()(const std::pair<const PyObject *, const char *>& v) const {
- size_t value = std::hash<const void *>()(v.first);
- value ^= std::hash<const void *>()(v.second) + 0x9e3779b9 + (value<<6) + (value>>2);
- return value;
- }
-};
-
-/// Internal data structure used to track registered instances and types
-struct internals {
- std::unordered_map<std::type_index, void*> registered_types_cpp; // std::type_index -> type_info
- std::unordered_map<const void *, void*> registered_types_py; // PyTypeObject* -> type_info
- std::unordered_multimap<const void *, void*> registered_instances; // void * -> PyObject*
- std::unordered_set<std::pair<const PyObject *, const char *>, overload_hash> inactive_overload_cache;
- std::unordered_map<std::type_index, std::vector<bool (*)(PyObject *, void *&)>> direct_conversions;
- std::forward_list<void (*) (std::exception_ptr)> registered_exception_translators;
- std::unordered_map<std::string, void *> shared_data; // Custom data to be shared across extensions
- PyTypeObject *static_property_type;
- PyTypeObject *default_metaclass;
- std::unordered_map<size_t, PyObject *> bases; // one base type per `instance_size` (very few)
-#if defined(WITH_THREAD)
- decltype(PyThread_create_key()) tstate = 0; // Usually an int but a long on Cygwin64 with Python 3.x
- PyInterpreterState *istate = nullptr;
-#endif
-
- /// Return the appropriate base type for the given instance size
- PyObject *get_base(size_t instance_size);
-};
-
-/// Return a reference to the current 'internals' information
-inline internals &get_internals();
-
-/// from __cpp_future__ import (convenient aliases from C++14/17)
-#ifdef PYBIND11_CPP14
-using std::enable_if_t;
-using std::conditional_t;
-using std::remove_cv_t;
-#else
-template <bool B, typename T = void> using enable_if_t = typename std::enable_if<B, T>::type;
-template <bool B, typename T, typename F> using conditional_t = typename std::conditional<B, T, F>::type;
-template <typename T> using remove_cv_t = typename std::remove_cv<T>::type;
-#endif
-
-/// Index sequences
-#if defined(PYBIND11_CPP14) || defined(_MSC_VER)
-using std::index_sequence;
-using std::make_index_sequence;
-#else
-template<size_t ...> struct index_sequence { };
-template<size_t N, size_t ...S> struct make_index_sequence_impl : make_index_sequence_impl <N - 1, N - 1, S...> { };
-template<size_t ...S> struct make_index_sequence_impl <0, S...> { typedef index_sequence<S...> type; };
-template<size_t N> using make_index_sequence = typename make_index_sequence_impl<N>::type;
-#endif
-
-/// Backports of std::bool_constant and std::negation to accomodate older compilers
-template <bool B> using bool_constant = std::integral_constant<bool, B>;
-template <typename T> struct negation : bool_constant<!T::value> { };
-
-template <typename...> struct void_t_impl { using type = void; };
-template <typename... Ts> using void_t = typename void_t_impl<Ts...>::type;
-
-/// Compile-time all/any/none of that check the boolean value of all template types
-#ifdef __cpp_fold_expressions
-template <class... Ts> using all_of = bool_constant<(Ts::value && ...)>;
-template <class... Ts> using any_of = bool_constant<(Ts::value || ...)>;
-#elif !defined(_MSC_VER)
-template <bool...> struct bools {};
-template <class... Ts> using all_of = std::is_same<
- bools<Ts::value..., true>,
- bools<true, Ts::value...>>;
-template <class... Ts> using any_of = negation<all_of<negation<Ts>...>>;
-#else
-// MSVC has trouble with the above, but supports std::conjunction, which we can use instead (albeit
-// at a slight loss of compilation efficiency).
-template <class... Ts> using all_of = std::conjunction<Ts...>;
-template <class... Ts> using any_of = std::disjunction<Ts...>;
-#endif
-template <class... Ts> using none_of = negation<any_of<Ts...>>;
-
-template <class T, template<class> class... Predicates> using satisfies_all_of = all_of<Predicates<T>...>;
-template <class T, template<class> class... Predicates> using satisfies_any_of = any_of<Predicates<T>...>;
-template <class T, template<class> class... Predicates> using satisfies_none_of = none_of<Predicates<T>...>;
-
-/// Strip the class from a method type
-template <typename T> struct remove_class { };
-template <typename C, typename R, typename... A> struct remove_class<R (C::*)(A...)> { typedef R type(A...); };
-template <typename C, typename R, typename... A> struct remove_class<R (C::*)(A...) const> { typedef R type(A...); };
-
-/// Helper template to strip away type modifiers
-template <typename T> struct intrinsic_type { typedef T type; };
-template <typename T> struct intrinsic_type<const T> { typedef typename intrinsic_type<T>::type type; };
-template <typename T> struct intrinsic_type<T*> { typedef typename intrinsic_type<T>::type type; };
-template <typename T> struct intrinsic_type<T&> { typedef typename intrinsic_type<T>::type type; };
-template <typename T> struct intrinsic_type<T&&> { typedef typename intrinsic_type<T>::type type; };
-template <typename T, size_t N> struct intrinsic_type<const T[N]> { typedef typename intrinsic_type<T>::type type; };
-template <typename T, size_t N> struct intrinsic_type<T[N]> { typedef typename intrinsic_type<T>::type type; };
-template <typename T> using intrinsic_t = typename intrinsic_type<T>::type;
-
-/// Helper type to replace 'void' in some expressions
-struct void_type { };
-
-/// Helper template which holds a list of types
-template <typename...> struct type_list { };
-
-/// Compile-time integer sum
-#ifdef __cpp_fold_expressions
-template <typename... Ts> constexpr size_t constexpr_sum(Ts... ns) { return (0 + ... + size_t{ns}); }
-#else
-constexpr size_t constexpr_sum() { return 0; }
-template <typename T, typename... Ts>
-constexpr size_t constexpr_sum(T n, Ts... ns) { return size_t{n} + constexpr_sum(ns...); }
-#endif
-
-NAMESPACE_BEGIN(constexpr_impl)
-/// Implementation details for constexpr functions
-constexpr int first(int i) { return i; }
-template <typename T, typename... Ts>
-constexpr int first(int i, T v, Ts... vs) { return v ? i : first(i + 1, vs...); }
-
-constexpr int last(int /*i*/, int result) { return result; }
-template <typename T, typename... Ts>
-constexpr int last(int i, int result, T v, Ts... vs) { return last(i + 1, v ? i : result, vs...); }
-NAMESPACE_END(constexpr_impl)
-
-/// Return the index of the first type in Ts which satisfies Predicate<T>. Returns sizeof...(Ts) if
-/// none match.
-template <template<typename> class Predicate, typename... Ts>
-constexpr int constexpr_first() { return constexpr_impl::first(0, Predicate<Ts>::value...); }
-
-/// Return the index of the last type in Ts which satisfies Predicate<T>, or -1 if none match.
-template <template<typename> class Predicate, typename... Ts>
-constexpr int constexpr_last() { return constexpr_impl::last(0, -1, Predicate<Ts>::value...); }
-
-// Extracts the first type from the template parameter pack matching the predicate, or Default if none match.
-template <template<class> class Predicate, class Default, class... Ts> struct first_of;
-template <template<class> class Predicate, class Default> struct first_of<Predicate, Default> {
- using type = Default;
-};
-template <template<class> class Predicate, class Default, class T, class... Ts>
-struct first_of<Predicate, Default, T, Ts...> {
- using type = typename std::conditional<
- Predicate<T>::value,
- T,
- typename first_of<Predicate, Default, Ts...>::type
- >::type;
-};
-template <template<class> class Predicate, class Default, class... T> using first_of_t = typename first_of<Predicate, Default, T...>::type;
-
-/// Defer the evaluation of type T until types Us are instantiated
-template <typename T, typename... /*Us*/> struct deferred_type { using type = T; };
-template <typename T, typename... Us> using deferred_t = typename deferred_type<T, Us...>::type;
-
-template <template<typename...> class Base>
-struct is_template_base_of_impl {
- template <typename... Us> static std::true_type check(Base<Us...> *);
- static std::false_type check(...);
-};
-
-/// Check if a template is the base of a type. For example:
-/// `is_template_base_of<Base, T>` is true if `struct T : Base<U> {}` where U can be anything
-template <template<typename...> class Base, typename T>
-#if !defined(_MSC_VER)
-using is_template_base_of = decltype(is_template_base_of_impl<Base>::check((remove_cv_t<T>*)nullptr));
-#else // MSVC2015 has trouble with decltype in template aliases
-struct is_template_base_of : decltype(is_template_base_of_impl<Base>::check((remove_cv_t<T>*)nullptr)) { };
-#endif
-
-/// Check if T is std::shared_ptr<U> where U can be anything
-template <typename T> struct is_shared_ptr : std::false_type { };
-template <typename U> struct is_shared_ptr<std::shared_ptr<U>> : std::true_type { };
-
-/// Ignore that a variable is unused in compiler warnings
-inline void ignore_unused(const int *) { }
-
-NAMESPACE_END(detail)
-
-/// Returns a named pointer that is shared among all extension modules (using the same
-/// pybind11 version) running in the current interpreter. Names starting with underscores
-/// are reserved for internal usage. Returns `nullptr` if no matching entry was found.
-inline PYBIND11_NOINLINE void* get_shared_data(const std::string& name) {
- auto& internals = detail::get_internals();
- auto it = internals.shared_data.find(name);
- return it != internals.shared_data.end() ? it->second : nullptr;
-}
-
-/// Set the shared data that can be later recovered by `get_shared_data()`.
-inline PYBIND11_NOINLINE void *set_shared_data(const std::string& name, void *data) {
- detail::get_internals().shared_data[name] = data;
- return data;
-}
-
-/// Returns a typed reference to a shared data entry (by using `get_shared_data()`) if
-/// such entry exists. Otherwise, a new object of default-constructible type `T` is
-/// added to the shared data under the given name and a reference to it is returned.
-template<typename T> T& get_or_create_shared_data(const std::string& name) {
- auto& internals = detail::get_internals();
- auto it = internals.shared_data.find(name);
- T* ptr = (T*) (it != internals.shared_data.end() ? it->second : nullptr);
- if (!ptr) {
- ptr = new T();
- internals.shared_data[name] = ptr;
- }
- return *ptr;
-}
-
-/// Fetch and hold an error which was already set in Python
-class error_already_set : public std::runtime_error {
-public:
- error_already_set() : std::runtime_error(detail::error_string()) {
- PyErr_Fetch(&type, &value, &trace);
- }
-
- error_already_set(const error_already_set &) = delete;
-
- error_already_set(error_already_set &&e)
- : std::runtime_error(e.what()), type(e.type), value(e.value),
- trace(e.trace) { e.type = e.value = e.trace = nullptr; }
-
- inline ~error_already_set(); // implementation in pybind11.h
-
- error_already_set& operator=(const error_already_set &) = delete;
-
- /// Give the error back to Python
- void restore() { PyErr_Restore(type, value, trace); type = value = trace = nullptr; }
-
- /// Clear the held Python error state (the C++ `what()` message remains intact)
- void clear() { restore(); PyErr_Clear(); }
-
-private:
- PyObject *type, *value, *trace;
-};
-
-/// C++ bindings of builtin Python exceptions
-class builtin_exception : public std::runtime_error {
-public:
- using std::runtime_error::runtime_error;
- /// Set the error using the Python C API
- virtual void set_error() const = 0;
-};
-
-#define PYBIND11_RUNTIME_EXCEPTION(name, type) \
- class name : public builtin_exception { public: \
- using builtin_exception::builtin_exception; \
- name() : name("") { } \
- void set_error() const override { PyErr_SetString(type, what()); } \
- };
-
-PYBIND11_RUNTIME_EXCEPTION(stop_iteration, PyExc_StopIteration)
-PYBIND11_RUNTIME_EXCEPTION(index_error, PyExc_IndexError)
-PYBIND11_RUNTIME_EXCEPTION(key_error, PyExc_KeyError)
-PYBIND11_RUNTIME_EXCEPTION(value_error, PyExc_ValueError)
-PYBIND11_RUNTIME_EXCEPTION(type_error, PyExc_TypeError)
-PYBIND11_RUNTIME_EXCEPTION(cast_error, PyExc_RuntimeError) /// Thrown when pybind11::cast or handle::call fail due to a type casting error
-PYBIND11_RUNTIME_EXCEPTION(reference_cast_error, PyExc_RuntimeError) /// Used internally
-
-[[noreturn]] PYBIND11_NOINLINE inline void pybind11_fail(const char *reason) { throw std::runtime_error(reason); }
-[[noreturn]] PYBIND11_NOINLINE inline void pybind11_fail(const std::string &reason) { throw std::runtime_error(reason); }
-
-template <typename T, typename SFINAE = void> struct format_descriptor { };
-
-NAMESPACE_BEGIN(detail)
-// Returns the index of the given type in the type char array below, and in the list in numpy.h
-// The order here is: bool; 8 ints ((signed,unsigned)x(8,16,32,64)bits); float,double,long double;
-// complex float,double,long double. Note that the long double types only participate when long
-// double is actually longer than double (it isn't under MSVC).
-// NB: not only the string below but also complex.h and numpy.h rely on this order.
-template <typename T, typename SFINAE = void> struct is_fmt_numeric { static constexpr bool value = false; };
-template <typename T> struct is_fmt_numeric<T, enable_if_t<std::is_arithmetic<T>::value>> {
- static constexpr bool value = true;
- static constexpr int index = std::is_same<T, bool>::value ? 0 : 1 + (
- std::is_integral<T>::value ? detail::log2(sizeof(T))*2 + std::is_unsigned<T>::value : 8 + (
- std::is_same<T, double>::value ? 1 : std::is_same<T, long double>::value ? 2 : 0));
-};
-NAMESPACE_END(detail)
-
-template <typename T> struct format_descriptor<T, detail::enable_if_t<detail::is_fmt_numeric<T>::value>> {
- static constexpr const char c = "?bBhHiIqQfdgFDG"[detail::is_fmt_numeric<T>::index];
- static constexpr const char value[2] = { c, '\0' };
- static std::string format() { return std::string(1, c); }
-};
-
-template <typename T> constexpr const char format_descriptor<
- T, detail::enable_if_t<detail::is_fmt_numeric<T>::value>>::value[2];
-
-NAMESPACE_BEGIN(detail)
-
-template <typename T, typename SFINAE = void> struct compare_buffer_info {
- static bool compare(const buffer_info& b) {
- return b.format == format_descriptor<T>::format() && b.itemsize == sizeof(T);
- }
-};
-
-template <typename T> struct compare_buffer_info<T, detail::enable_if_t<std::is_integral<T>::value>> {
- static bool compare(const buffer_info& b) {
- return b.itemsize == sizeof(T) && (b.format == format_descriptor<T>::value ||
- ((sizeof(T) == sizeof(long)) && b.format == (std::is_unsigned<T>::value ? "L" : "l")) ||
- ((sizeof(T) == sizeof(size_t)) && b.format == (std::is_unsigned<T>::value ? "N" : "n")));
- }
-};
-
-NAMESPACE_END(detail)
-
-/// RAII wrapper that temporarily clears any Python error state
-struct error_scope {
- PyObject *type, *value, *trace;
- error_scope() { PyErr_Fetch(&type, &value, &trace); }
- ~error_scope() { PyErr_Restore(type, value, trace); }
-};
-
-/// Dummy destructor wrapper that can be used to expose classes with a private destructor
-struct nodelete { template <typename T> void operator()(T*) { } };
-
-// overload_cast requires variable templates: C++14 or MSVC
-#if defined(PYBIND11_CPP14) || defined(_MSC_VER)
-#define PYBIND11_OVERLOAD_CAST 1
-
-NAMESPACE_BEGIN(detail)
-template <typename... Args>
-struct overload_cast_impl {
- template <typename Return>
- constexpr auto operator()(Return (*pf)(Args...)) const noexcept
- -> decltype(pf) { return pf; }
-
- template <typename Return, typename Class>
- constexpr auto operator()(Return (Class::*pmf)(Args...), std::false_type = {}) const noexcept
- -> decltype(pmf) { return pmf; }
-
- template <typename Return, typename Class>
- constexpr auto operator()(Return (Class::*pmf)(Args...) const, std::true_type) const noexcept
- -> decltype(pmf) { return pmf; }
-};
-NAMESPACE_END(detail)
-
-/// Syntax sugar for resolving overloaded function pointers:
-/// - regular: static_cast<Return (Class::*)(Arg0, Arg1, Arg2)>(&Class::func)
-/// - sweet: overload_cast<Arg0, Arg1, Arg2>(&Class::func)
-template <typename... Args>
-static constexpr detail::overload_cast_impl<Args...> overload_cast = {};
-// MSVC 2015 only accepts this particular initialization syntax for this variable template.
-
-/// Const member function selector for overload_cast
-/// - regular: static_cast<Return (Class::*)(Arg) const>(&Class::func)
-/// - sweet: overload_cast<Arg>(&Class::func, const_)
-static constexpr auto const_ = std::true_type{};
-
-#endif // overload_cast
-
-NAMESPACE_END(pybind11)
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/complex.h b/thirdparty/pybind11/pybind11/include/pybind11/complex.h
deleted file mode 100644
index 945ca0710f810afde3fdfbadd9c41ad6bcf694ee..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/complex.h
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- pybind11/complex.h: Complex number support
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "pybind11.h"
-#include <complex>
-
-/// glibc defines I as a macro which breaks things, e.g., boost template names
-#ifdef I
-# undef I
-#endif
-
-NAMESPACE_BEGIN(pybind11)
-NAMESPACE_BEGIN(detail)
-
-// The format codes are already in the string in common.h, we just need to provide a specialization
-template <typename T> struct is_fmt_numeric<std::complex<T>> {
- static constexpr bool value = true;
- static constexpr int index = is_fmt_numeric<T>::index + 3;
-};
-
-template <typename T> class type_caster<std::complex<T>> {
-public:
- bool load(handle src, bool convert) {
- if (!src)
- return false;
- if (!convert && !PyComplex_Check(src.ptr()))
- return false;
- Py_complex result = PyComplex_AsCComplex(src.ptr());
- if (result.real == -1.0 && PyErr_Occurred()) {
- PyErr_Clear();
- return false;
- }
- value = std::complex<T>((T) result.real, (T) result.imag);
- return true;
- }
-
- static handle cast(const std::complex<T> &src, return_value_policy /* policy */, handle /* parent */) {
- return PyComplex_FromDoubles((double) src.real(), (double) src.imag());
- }
-
- PYBIND11_TYPE_CASTER(std::complex<T>, _("complex"));
-};
-NAMESPACE_END(detail)
-NAMESPACE_END(pybind11)
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/descr.h b/thirdparty/pybind11/pybind11/include/pybind11/descr.h
deleted file mode 100644
index 2c3fb3d135968c1b94a668aec6ebeb6692973f15..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/descr.h
+++ /dev/null
@@ -1,183 +0,0 @@
-/*
- pybind11/descr.h: Helper type for concatenating type signatures
- either at runtime (C++11) or compile time (C++14)
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "common.h"
-
-NAMESPACE_BEGIN(pybind11)
-NAMESPACE_BEGIN(detail)
-
-#if defined(PYBIND11_CPP14) /* Concatenate type signatures at compile time using C++14 */
-
-template <size_t Size1, size_t Size2> class descr {
- template <size_t Size1_, size_t Size2_> friend class descr;
-public:
- constexpr descr(char const (&text) [Size1+1], const std::type_info * const (&types)[Size2+1])
- : descr(text, types,
- make_index_sequence<Size1>(),
- make_index_sequence<Size2>()) { }
-
- constexpr const char *text() const { return m_text; }
- constexpr const std::type_info * const * types() const { return m_types; }
-
- template <size_t OtherSize1, size_t OtherSize2>
- constexpr descr<Size1 + OtherSize1, Size2 + OtherSize2> operator+(const descr<OtherSize1, OtherSize2> &other) const {
- return concat(other,
- make_index_sequence<Size1>(),
- make_index_sequence<Size2>(),
- make_index_sequence<OtherSize1>(),
- make_index_sequence<OtherSize2>());
- }
-
-protected:
- template <size_t... Indices1, size_t... Indices2>
- constexpr descr(
- char const (&text) [Size1+1],
- const std::type_info * const (&types) [Size2+1],
- index_sequence<Indices1...>, index_sequence<Indices2...>)
- : m_text{text[Indices1]..., '\0'},
- m_types{types[Indices2]..., nullptr } {}
-
- template <size_t OtherSize1, size_t OtherSize2, size_t... Indices1,
- size_t... Indices2, size_t... OtherIndices1, size_t... OtherIndices2>
- constexpr descr<Size1 + OtherSize1, Size2 + OtherSize2>
- concat(const descr<OtherSize1, OtherSize2> &other,
- index_sequence<Indices1...>, index_sequence<Indices2...>,
- index_sequence<OtherIndices1...>, index_sequence<OtherIndices2...>) const {
- return descr<Size1 + OtherSize1, Size2 + OtherSize2>(
- { m_text[Indices1]..., other.m_text[OtherIndices1]..., '\0' },
- { m_types[Indices2]..., other.m_types[OtherIndices2]..., nullptr }
- );
- }
-
-protected:
- char m_text[Size1 + 1];
- const std::type_info * m_types[Size2 + 1];
-};
-
-template <size_t Size> constexpr descr<Size - 1, 0> _(char const(&text)[Size]) {
- return descr<Size - 1, 0>(text, { nullptr });
-}
-
-template <size_t Rem, size_t... Digits> struct int_to_str : int_to_str<Rem/10, Rem%10, Digits...> { };
-template <size_t...Digits> struct int_to_str<0, Digits...> {
- static constexpr auto digits = descr<sizeof...(Digits), 0>({ ('0' + Digits)..., '\0' }, { nullptr });
-};
-
-// Ternary description (like std::conditional)
-template <bool B, size_t Size1, size_t Size2>
-constexpr enable_if_t<B, descr<Size1 - 1, 0>> _(char const(&text1)[Size1], char const(&)[Size2]) {
- return _(text1);
-}
-template <bool B, size_t Size1, size_t Size2>
-constexpr enable_if_t<!B, descr<Size2 - 1, 0>> _(char const(&)[Size1], char const(&text2)[Size2]) {
- return _(text2);
-}
-template <bool B, size_t SizeA1, size_t SizeA2, size_t SizeB1, size_t SizeB2>
-constexpr enable_if_t<B, descr<SizeA1, SizeA2>> _(descr<SizeA1, SizeA2> d, descr<SizeB1, SizeB2>) { return d; }
-template <bool B, size_t SizeA1, size_t SizeA2, size_t SizeB1, size_t SizeB2>
-constexpr enable_if_t<!B, descr<SizeB1, SizeB2>> _(descr<SizeA1, SizeA2>, descr<SizeB1, SizeB2> d) { return d; }
-
-template <size_t Size> auto constexpr _() -> decltype(int_to_str<Size / 10, Size % 10>::digits) {
- return int_to_str<Size / 10, Size % 10>::digits;
-}
-
-template <typename Type> constexpr descr<1, 1> _() {
- return descr<1, 1>({ '%', '\0' }, { &typeid(Type), nullptr });
-}
-
-inline constexpr descr<0, 0> concat() { return _(""); }
-template <size_t Size1, size_t Size2, typename... Args> auto constexpr concat(descr<Size1, Size2> descr) { return descr; }
-template <size_t Size1, size_t Size2, typename... Args> auto constexpr concat(descr<Size1, Size2> descr, Args&&... args) { return descr + _(", ") + concat(args...); }
-template <size_t Size1, size_t Size2> auto constexpr type_descr(descr<Size1, Size2> descr) { return _("{") + descr + _("}"); }
-
-#define PYBIND11_DESCR constexpr auto
-
-#else /* Simpler C++11 implementation based on run-time memory allocation and copying */
-
-class descr {
-public:
- PYBIND11_NOINLINE descr(const char *text, const std::type_info * const * types) {
- size_t nChars = len(text), nTypes = len(types);
- m_text = new char[nChars];
- m_types = new const std::type_info *[nTypes];
- memcpy(m_text, text, nChars * sizeof(char));
- memcpy(m_types, types, nTypes * sizeof(const std::type_info *));
- }
-
- PYBIND11_NOINLINE descr friend operator+(descr &&d1, descr &&d2) {
- descr r;
-
- size_t nChars1 = len(d1.m_text), nTypes1 = len(d1.m_types);
- size_t nChars2 = len(d2.m_text), nTypes2 = len(d2.m_types);
-
- r.m_text = new char[nChars1 + nChars2 - 1];
- r.m_types = new const std::type_info *[nTypes1 + nTypes2 - 1];
- memcpy(r.m_text, d1.m_text, (nChars1-1) * sizeof(char));
- memcpy(r.m_text + nChars1 - 1, d2.m_text, nChars2 * sizeof(char));
- memcpy(r.m_types, d1.m_types, (nTypes1-1) * sizeof(std::type_info *));
- memcpy(r.m_types + nTypes1 - 1, d2.m_types, nTypes2 * sizeof(std::type_info *));
-
- delete[] d1.m_text; delete[] d1.m_types;
- delete[] d2.m_text; delete[] d2.m_types;
-
- return r;
- }
-
- char *text() { return m_text; }
- const std::type_info * * types() { return m_types; }
-
-protected:
- PYBIND11_NOINLINE descr() { }
-
- template <typename T> static size_t len(const T *ptr) { // return length including null termination
- const T *it = ptr;
- while (*it++ != (T) 0)
- ;
- return static_cast<size_t>(it - ptr);
- }
-
- const std::type_info **m_types = nullptr;
- char *m_text = nullptr;
-};
-
-/* The 'PYBIND11_NOINLINE inline' combinations below are intentional to get the desired linkage while producing as little object code as possible */
-
-PYBIND11_NOINLINE inline descr _(const char *text) {
- const std::type_info *types[1] = { nullptr };
- return descr(text, types);
-}
-
-template <bool B> PYBIND11_NOINLINE enable_if_t<B, descr> _(const char *text1, const char *) { return _(text1); }
-template <bool B> PYBIND11_NOINLINE enable_if_t<!B, descr> _(char const *, const char *text2) { return _(text2); }
-template <bool B> PYBIND11_NOINLINE enable_if_t<B, descr> _(descr d, descr) { return d; }
-template <bool B> PYBIND11_NOINLINE enable_if_t<!B, descr> _(descr, descr d) { return d; }
-
-template <typename Type> PYBIND11_NOINLINE descr _() {
- const std::type_info *types[2] = { &typeid(Type), nullptr };
- return descr("%", types);
-}
-
-template <size_t Size> PYBIND11_NOINLINE descr _() {
- const std::type_info *types[1] = { nullptr };
- return descr(std::to_string(Size).c_str(), types);
-}
-
-PYBIND11_NOINLINE inline descr concat() { return _(""); }
-PYBIND11_NOINLINE inline descr concat(descr &&d) { return d; }
-template <typename... Args> PYBIND11_NOINLINE descr concat(descr &&d, Args&&... args) { return std::move(d) + _(", ") + concat(std::forward<Args>(args)...); }
-PYBIND11_NOINLINE inline descr type_descr(descr&& d) { return _("{") + std::move(d) + _("}"); }
-
-#define PYBIND11_DESCR ::pybind11::detail::descr
-#endif
-
-NAMESPACE_END(detail)
-NAMESPACE_END(pybind11)
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/eigen.h b/thirdparty/pybind11/pybind11/include/pybind11/eigen.h
deleted file mode 100644
index 6abe8c48fb5c42a786cf4b7d3a1b5408ab91f8f6..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/eigen.h
+++ /dev/null
@@ -1,589 +0,0 @@
-/*
- pybind11/eigen.h: Transparent conversion for dense and sparse Eigen matrices
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "numpy.h"
-
-#if defined(__INTEL_COMPILER)
-# pragma warning(disable: 1682) // implicit conversion of a 64-bit integral type to a smaller integral type (potential portability problem)
-#elif defined(__GNUG__) || defined(__clang__)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wconversion"
-# pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-# if __GNUC__ >= 7
-# pragma GCC diagnostic ignored "-Wint-in-bool-context"
-# endif
-#endif
-
-#include <Eigen/Core>
-#include <Eigen/SparseCore>
-
-#if defined(_MSC_VER)
-# pragma warning(push)
-# pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
-#endif
-
-// Eigen prior to 3.2.7 doesn't have proper move constructors--but worse, some classes get implicit
-// move constructors that break things. We could detect this an explicitly copy, but an extra copy
-// of matrices seems highly undesirable.
-static_assert(EIGEN_VERSION_AT_LEAST(3,2,7), "Eigen support in pybind11 requires Eigen >= 3.2.7");
-
-NAMESPACE_BEGIN(pybind11)
-
-// Provide a convenience alias for easier pass-by-ref usage with fully dynamic strides:
-using EigenDStride = Eigen::Stride<Eigen::Dynamic, Eigen::Dynamic>;
-template <typename MatrixType> using EigenDRef = Eigen::Ref<MatrixType, 0, EigenDStride>;
-template <typename MatrixType> using EigenDMap = Eigen::Map<MatrixType, 0, EigenDStride>;
-
-NAMESPACE_BEGIN(detail)
-
-#if EIGEN_VERSION_AT_LEAST(3,3,0)
-using EigenIndex = Eigen::Index;
-#else
-using EigenIndex = EIGEN_DEFAULT_DENSE_INDEX_TYPE;
-#endif
-
-// Matches Eigen::Map, Eigen::Ref, blocks, etc:
-template <typename T> using is_eigen_dense_map = all_of<is_template_base_of<Eigen::DenseBase, T>, std::is_base_of<Eigen::MapBase<T, Eigen::ReadOnlyAccessors>, T>>;
-template <typename T> using is_eigen_mutable_map = std::is_base_of<Eigen::MapBase<T, Eigen::WriteAccessors>, T>;
-template <typename T> using is_eigen_dense_plain = all_of<negation<is_eigen_dense_map<T>>, is_template_base_of<Eigen::PlainObjectBase, T>>;
-template <typename T> using is_eigen_sparse = is_template_base_of<Eigen::SparseMatrixBase, T>;
-// Test for objects inheriting from EigenBase<Derived> that aren't captured by the above. This
-// basically covers anything that can be assigned to a dense matrix but that don't have a typical
-// matrix data layout that can be copied from their .data(). For example, DiagonalMatrix and
-// SelfAdjointView fall into this category.
-template <typename T> using is_eigen_other = all_of<
- is_template_base_of<Eigen::EigenBase, T>,
- negation<any_of<is_eigen_dense_map<T>, is_eigen_dense_plain<T>, is_eigen_sparse<T>>>
->;
-
-// Captures numpy/eigen conformability status (returned by EigenProps::conformable()):
-template <bool EigenRowMajor> struct EigenConformable {
- bool conformable = false;
- EigenIndex rows = 0, cols = 0;
- EigenDStride stride{0, 0};
-
- EigenConformable(bool fits = false) : conformable{fits} {}
- // Matrix type:
- EigenConformable(EigenIndex r, EigenIndex c,
- EigenIndex rstride, EigenIndex cstride) :
- conformable{true}, rows{r}, cols{c},
- stride(EigenRowMajor ? rstride : cstride /* outer stride */,
- EigenRowMajor ? cstride : rstride /* inner stride */)
- {}
- // Vector type:
- EigenConformable(EigenIndex r, EigenIndex c, EigenIndex stride)
- : EigenConformable(r, c, r == 1 ? c*stride : stride, c == 1 ? r : r*stride) {}
-
- template <typename props> bool stride_compatible() const {
- // To have compatible strides, we need (on both dimensions) one of fully dynamic strides,
- // matching strides, or a dimension size of 1 (in which case the stride value is irrelevant)
- return
- (props::inner_stride == Eigen::Dynamic || props::inner_stride == stride.inner() ||
- (EigenRowMajor ? cols : rows) == 1) &&
- (props::outer_stride == Eigen::Dynamic || props::outer_stride == stride.outer() ||
- (EigenRowMajor ? rows : cols) == 1);
- }
- operator bool() const { return conformable; }
-};
-
-template <typename Type> struct eigen_extract_stride { using type = Type; };
-template <typename PlainObjectType, int MapOptions, typename StrideType>
-struct eigen_extract_stride<Eigen::Map<PlainObjectType, MapOptions, StrideType>> { using type = StrideType; };
-template <typename PlainObjectType, int Options, typename StrideType>
-struct eigen_extract_stride<Eigen::Ref<PlainObjectType, Options, StrideType>> { using type = StrideType; };
-
-// Helper struct for extracting information from an Eigen type
-template <typename Type_> struct EigenProps {
- using Type = Type_;
- using Scalar = typename Type::Scalar;
- using StrideType = typename eigen_extract_stride<Type>::type;
- static constexpr EigenIndex
- rows = Type::RowsAtCompileTime,
- cols = Type::ColsAtCompileTime,
- size = Type::SizeAtCompileTime;
- static constexpr bool
- row_major = Type::IsRowMajor,
- vector = Type::IsVectorAtCompileTime, // At least one dimension has fixed size 1
- fixed_rows = rows != Eigen::Dynamic,
- fixed_cols = cols != Eigen::Dynamic,
- fixed = size != Eigen::Dynamic, // Fully-fixed size
- dynamic = !fixed_rows && !fixed_cols; // Fully-dynamic size
-
- template <EigenIndex i, EigenIndex ifzero> using if_zero = std::integral_constant<EigenIndex, i == 0 ? ifzero : i>;
- static constexpr EigenIndex inner_stride = if_zero<StrideType::InnerStrideAtCompileTime, 1>::value,
- outer_stride = if_zero<StrideType::OuterStrideAtCompileTime,
- vector ? size : row_major ? cols : rows>::value;
- static constexpr bool dynamic_stride = inner_stride == Eigen::Dynamic && outer_stride == Eigen::Dynamic;
- static constexpr bool requires_row_major = !dynamic_stride && !vector && (row_major ? inner_stride : outer_stride) == 1;
- static constexpr bool requires_col_major = !dynamic_stride && !vector && (row_major ? outer_stride : inner_stride) == 1;
-
- // Takes an input array and determines whether we can make it fit into the Eigen type. If
- // the array is a vector, we attempt to fit it into either an Eigen 1xN or Nx1 vector
- // (preferring the latter if it will fit in either, i.e. for a fully dynamic matrix type).
- static EigenConformable<row_major> conformable(const array &a) {
- const auto dims = a.ndim();
- if (dims < 1 || dims > 2)
- return false;
-
- if (dims == 2) { // Matrix type: require exact match (or dynamic)
-
- EigenIndex
- np_rows = a.shape(0),
- np_cols = a.shape(1),
- np_rstride = a.strides(0) / sizeof(Scalar),
- np_cstride = a.strides(1) / sizeof(Scalar);
- if ((fixed_rows && np_rows != rows) || (fixed_cols && np_cols != cols))
- return false;
-
- return {np_rows, np_cols, np_rstride, np_cstride};
- }
-
- // Otherwise we're storing an n-vector. Only one of the strides will be used, but whichever
- // is used, we want the (single) numpy stride value.
- const EigenIndex n = a.shape(0),
- stride = a.strides(0) / sizeof(Scalar);
-
- if (vector) { // Eigen type is a compile-time vector
- if (fixed && size != n)
- return false; // Vector size mismatch
- return {rows == 1 ? 1 : n, cols == 1 ? 1 : n, stride};
- }
- else if (fixed) {
- // The type has a fixed size, but is not a vector: abort
- return false;
- }
- else if (fixed_cols) {
- // Since this isn't a vector, cols must be != 1. We allow this only if it exactly
- // equals the number of elements (rows is Dynamic, and so 1 row is allowed).
- if (cols != n) return false;
- return {1, n, stride};
- }
- else {
- // Otherwise it's either fully dynamic, or column dynamic; both become a column vector
- if (fixed_rows && rows != n) return false;
- return {n, 1, stride};
- }
- }
-
- static PYBIND11_DESCR descriptor() {
- constexpr bool show_writeable = is_eigen_dense_map<Type>::value && is_eigen_mutable_map<Type>::value;
- constexpr bool show_order = is_eigen_dense_map<Type>::value;
- constexpr bool show_c_contiguous = show_order && requires_row_major;
- constexpr bool show_f_contiguous = !show_c_contiguous && show_order && requires_col_major;
-
- return _("numpy.ndarray[") + npy_format_descriptor<Scalar>::name() +
- _("[") + _<fixed_rows>(_<(size_t) rows>(), _("m")) +
- _(", ") + _<fixed_cols>(_<(size_t) cols>(), _("n")) +
- _("]") +
- // For a reference type (e.g. Ref<MatrixXd>) we have other constraints that might need to be
- // satisfied: writeable=True (for a mutable reference), and, depending on the map's stride
- // options, possibly f_contiguous or c_contiguous. We include them in the descriptor output
- // to provide some hint as to why a TypeError is occurring (otherwise it can be confusing to
- // see that a function accepts a 'numpy.ndarray[float64[3,2]]' and an error message that you
- // *gave* a numpy.ndarray of the right type and dimensions.
- _<show_writeable>(", flags.writeable", "") +
- _<show_c_contiguous>(", flags.c_contiguous", "") +
- _<show_f_contiguous>(", flags.f_contiguous", "") +
- _("]");
- }
-};
-
-// Casts an Eigen type to numpy array. If given a base, the numpy array references the src data,
-// otherwise it'll make a copy. writeable lets you turn off the writeable flag for the array.
-template <typename props> handle eigen_array_cast(typename props::Type const &src, handle base = handle(), bool writeable = true) {
- constexpr size_t elem_size = sizeof(typename props::Scalar);
- std::vector<size_t> shape, strides;
- if (props::vector) {
- shape.push_back(src.size());
- strides.push_back(elem_size * src.innerStride());
- }
- else {
- shape.push_back(src.rows());
- shape.push_back(src.cols());
- strides.push_back(elem_size * src.rowStride());
- strides.push_back(elem_size * src.colStride());
- }
- array a(std::move(shape), std::move(strides), src.data(), base);
- if (!writeable)
- array_proxy(a.ptr())->flags &= ~detail::npy_api::NPY_ARRAY_WRITEABLE_;
-
- return a.release();
-}
-
-// Takes an lvalue ref to some Eigen type and a (python) base object, creating a numpy array that
-// reference the Eigen object's data with `base` as the python-registered base class (if omitted,
-// the base will be set to None, and lifetime management is up to the caller). The numpy array is
-// non-writeable if the given type is const.
-template <typename props, typename Type>
-handle eigen_ref_array(Type &src, handle parent = none()) {
- // none here is to get past array's should-we-copy detection, which currently always
- // copies when there is no base. Setting the base to None should be harmless.
- return eigen_array_cast<props>(src, parent, !std::is_const<Type>::value);
-}
-
-// Takes a pointer to some dense, plain Eigen type, builds a capsule around it, then returns a numpy
-// array that references the encapsulated data with a python-side reference to the capsule to tie
-// its destruction to that of any dependent python objects. Const-ness is determined by whether or
-// not the Type of the pointer given is const.
-template <typename props, typename Type, typename = enable_if_t<is_eigen_dense_plain<Type>::value>>
-handle eigen_encapsulate(Type *src) {
- capsule base(src, [](void *o) { delete static_cast<Type *>(o); });
- return eigen_ref_array<props>(*src, base);
-}
-
-// Type caster for regular, dense matrix types (e.g. MatrixXd), but not maps/refs/etc. of dense
-// types.
-template<typename Type>
-struct type_caster<Type, enable_if_t<is_eigen_dense_plain<Type>::value>> {
- using Scalar = typename Type::Scalar;
- using props = EigenProps<Type>;
-
- bool load(handle src, bool) {
- auto buf = array_t<Scalar>::ensure(src);
- if (!buf)
- return false;
-
- auto dims = buf.ndim();
- if (dims < 1 || dims > 2)
- return false;
-
- auto fits = props::conformable(buf);
- if (!fits)
- return false; // Non-comformable vector/matrix types
-
- value = Eigen::Map<const Type, 0, EigenDStride>(buf.data(), fits.rows, fits.cols, fits.stride);
-
- return true;
- }
-
-private:
-
- // Cast implementation
- template <typename CType>
- static handle cast_impl(CType *src, return_value_policy policy, handle parent) {
- switch (policy) {
- case return_value_policy::take_ownership:
- case return_value_policy::automatic:
- return eigen_encapsulate<props>(src);
- case return_value_policy::move:
- return eigen_encapsulate<props>(new CType(std::move(*src)));
- case return_value_policy::copy:
- return eigen_array_cast<props>(*src);
- case return_value_policy::reference:
- case return_value_policy::automatic_reference:
- return eigen_ref_array<props>(*src);
- case return_value_policy::reference_internal:
- return eigen_ref_array<props>(*src, parent);
- default:
- throw cast_error("unhandled return_value_policy: should not happen!");
- };
- }
-
-public:
-
- // Normal returned non-reference, non-const value:
- static handle cast(Type &&src, return_value_policy /* policy */, handle parent) {
- return cast_impl(&src, return_value_policy::move, parent);
- }
- // If you return a non-reference const, we mark the numpy array readonly:
- static handle cast(const Type &&src, return_value_policy /* policy */, handle parent) {
- return cast_impl(&src, return_value_policy::move, parent);
- }
- // lvalue reference return; default (automatic) becomes copy
- static handle cast(Type &src, return_value_policy policy, handle parent) {
- if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
- policy = return_value_policy::copy;
- return cast_impl(&src, policy, parent);
- }
- // const lvalue reference return; default (automatic) becomes copy
- static handle cast(const Type &src, return_value_policy policy, handle parent) {
- if (policy == return_value_policy::automatic || policy == return_value_policy::automatic_reference)
- policy = return_value_policy::copy;
- return cast(&src, policy, parent);
- }
- // non-const pointer return
- static handle cast(Type *src, return_value_policy policy, handle parent) {
- return cast_impl(src, policy, parent);
- }
- // const pointer return
- static handle cast(const Type *src, return_value_policy policy, handle parent) {
- return cast_impl(src, policy, parent);
- }
-
- static PYBIND11_DESCR name() { return type_descr(props::descriptor()); }
-
- operator Type*() { return &value; }
- operator Type&() { return value; }
- template <typename T> using cast_op_type = cast_op_type<T>;
-
-private:
- Type value;
-};
-
-// Eigen Ref/Map classes have slightly different policy requirements, meaning we don't want to force
-// `move` when a Ref/Map rvalue is returned; we treat Ref<> sort of like a pointer (we care about
-// the underlying data, not the outer shell).
-template <typename Return>
-struct return_value_policy_override<Return, enable_if_t<is_eigen_dense_map<Return>::value>> {
- static return_value_policy policy(return_value_policy p) { return p; }
-};
-
-// Base class for casting reference/map/block/etc. objects back to python.
-template <typename MapType> struct eigen_map_caster {
-private:
- using props = EigenProps<MapType>;
-
-public:
-
- // Directly referencing a ref/map's data is a bit dangerous (whatever the map/ref points to has
- // to stay around), but we'll allow it under the assumption that you know what you're doing (and
- // have an appropriate keep_alive in place). We return a numpy array pointing directly at the
- // ref's data (The numpy array ends up read-only if the ref was to a const matrix type.) Note
- // that this means you need to ensure you don't destroy the object in some other way (e.g. with
- // an appropriate keep_alive, or with a reference to a statically allocated matrix).
- static handle cast(const MapType &src, return_value_policy policy, handle parent) {
- switch (policy) {
- case return_value_policy::copy:
- return eigen_array_cast<props>(src);
- case return_value_policy::reference_internal:
- return eigen_array_cast<props>(src, parent, is_eigen_mutable_map<MapType>::value);
- case return_value_policy::reference:
- case return_value_policy::automatic:
- case return_value_policy::automatic_reference:
- return eigen_array_cast<props>(src, none(), is_eigen_mutable_map<MapType>::value);
- default:
- // move, take_ownership don't make any sense for a ref/map:
- pybind11_fail("Invalid return_value_policy for Eigen Map/Ref/Block type");
- }
- }
-
- static PYBIND11_DESCR name() { return props::descriptor(); }
-
- // Explicitly delete these: support python -> C++ conversion on these (i.e. these can be return
- // types but not bound arguments). We still provide them (with an explicitly delete) so that
- // you end up here if you try anyway.
- bool load(handle, bool) = delete;
- operator MapType() = delete;
- template <typename> using cast_op_type = MapType;
-};
-
-// We can return any map-like object (but can only load Refs, specialized next):
-template <typename Type> struct type_caster<Type, enable_if_t<is_eigen_dense_map<Type>::value>>
- : eigen_map_caster<Type> {};
-
-// Loader for Ref<...> arguments. See the documentation for info on how to make this work without
-// copying (it requires some extra effort in many cases).
-template <typename PlainObjectType, typename StrideType>
-struct type_caster<
- Eigen::Ref<PlainObjectType, 0, StrideType>,
- enable_if_t<is_eigen_dense_map<Eigen::Ref<PlainObjectType, 0, StrideType>>::value>
-> : public eigen_map_caster<Eigen::Ref<PlainObjectType, 0, StrideType>> {
-private:
- using Type = Eigen::Ref<PlainObjectType, 0, StrideType>;
- using props = EigenProps<Type>;
- using Scalar = typename props::Scalar;
- using MapType = Eigen::Map<PlainObjectType, 0, StrideType>;
- using Array = array_t<Scalar, array::forcecast |
- ((props::row_major ? props::inner_stride : props::outer_stride) == 1 ? array::c_style :
- (props::row_major ? props::outer_stride : props::inner_stride) == 1 ? array::f_style : 0)>;
- static constexpr bool need_writeable = is_eigen_mutable_map<Type>::value;
- // Delay construction (these have no default constructor)
- std::unique_ptr<MapType> map;
- std::unique_ptr<Type> ref;
- // Our array. When possible, this is just a numpy array pointing to the source data, but
- // sometimes we can't avoid copying (e.g. input is not a numpy array at all, has an incompatible
- // layout, or is an array of a type that needs to be converted). Using a numpy temporary
- // (rather than an Eigen temporary) saves an extra copy when we need both type conversion and
- // storage order conversion. (Note that we refuse to use this temporary copy when loading an
- // argument for a Ref<M> with M non-const, i.e. a read-write reference).
- Array copy_or_ref;
-public:
- bool load(handle src, bool convert) {
- // First check whether what we have is already an array of the right type. If not, we can't
- // avoid a copy (because the copy is also going to do type conversion).
- bool need_copy = !isinstance<Array>(src);
-
- EigenConformable<props::row_major> fits;
- if (!need_copy) {
- // We don't need a converting copy, but we also need to check whether the strides are
- // compatible with the Ref's stride requirements
- Array aref = reinterpret_borrow<Array>(src);
-
- if (aref && (!need_writeable || aref.writeable())) {
- fits = props::conformable(aref);
- if (!fits) return false; // Incompatible dimensions
- if (!fits.template stride_compatible<props>())
- need_copy = true;
- else
- copy_or_ref = std::move(aref);
- }
- else {
- need_copy = true;
- }
- }
-
- if (need_copy) {
- // We need to copy: If we need a mutable reference, or we're not supposed to convert
- // (either because we're in the no-convert overload pass, or because we're explicitly
- // instructed not to copy (via `py::arg().noconvert()`) we have to fail loading.
- if (!convert || need_writeable) return false;
-
- Array copy = Array::ensure(src);
- if (!copy) return false;
- fits = props::conformable(copy);
- if (!fits || !fits.template stride_compatible<props>())
- return false;
- copy_or_ref = std::move(copy);
- }
-
- ref.reset();
- map.reset(new MapType(data(copy_or_ref), fits.rows, fits.cols, make_stride(fits.stride.outer(), fits.stride.inner())));
- ref.reset(new Type(*map));
-
- return true;
- }
-
- operator Type*() { return ref.get(); }
- operator Type&() { return *ref; }
- template <typename _T> using cast_op_type = pybind11::detail::cast_op_type<_T>;
-
-private:
- template <typename T = Type, enable_if_t<is_eigen_mutable_map<T>::value, int> = 0>
- Scalar *data(Array &a) { return a.mutable_data(); }
-
- template <typename T = Type, enable_if_t<!is_eigen_mutable_map<T>::value, int> = 0>
- const Scalar *data(Array &a) { return a.data(); }
-
- // Attempt to figure out a constructor of `Stride` that will work.
- // If both strides are fixed, use a default constructor:
- template <typename S> using stride_ctor_default = bool_constant<
- S::InnerStrideAtCompileTime != Eigen::Dynamic && S::OuterStrideAtCompileTime != Eigen::Dynamic &&
- std::is_default_constructible<S>::value>;
- // Otherwise, if there is a two-index constructor, assume it is (outer,inner) like
- // Eigen::Stride, and use it:
- template <typename S> using stride_ctor_dual = bool_constant<
- !stride_ctor_default<S>::value && std::is_constructible<S, EigenIndex, EigenIndex>::value>;
- // Otherwise, if there is a one-index constructor, and just one of the strides is dynamic, use
- // it (passing whichever stride is dynamic).
- template <typename S> using stride_ctor_outer = bool_constant<
- !any_of<stride_ctor_default<S>, stride_ctor_dual<S>>::value &&
- S::OuterStrideAtCompileTime == Eigen::Dynamic && S::InnerStrideAtCompileTime != Eigen::Dynamic &&
- std::is_constructible<S, EigenIndex>::value>;
- template <typename S> using stride_ctor_inner = bool_constant<
- !any_of<stride_ctor_default<S>, stride_ctor_dual<S>>::value &&
- S::InnerStrideAtCompileTime == Eigen::Dynamic && S::OuterStrideAtCompileTime != Eigen::Dynamic &&
- std::is_constructible<S, EigenIndex>::value>;
-
- template <typename S = StrideType, enable_if_t<stride_ctor_default<S>::value, int> = 0>
- static S make_stride(EigenIndex, EigenIndex) { return S(); }
- template <typename S = StrideType, enable_if_t<stride_ctor_dual<S>::value, int> = 0>
- static S make_stride(EigenIndex outer, EigenIndex inner) { return S(outer, inner); }
- template <typename S = StrideType, enable_if_t<stride_ctor_outer<S>::value, int> = 0>
- static S make_stride(EigenIndex outer, EigenIndex) { return S(outer); }
- template <typename S = StrideType, enable_if_t<stride_ctor_inner<S>::value, int> = 0>
- static S make_stride(EigenIndex, EigenIndex inner) { return S(inner); }
-
-};
-
-// type_caster for special matrix types (e.g. DiagonalMatrix), which are EigenBase, but not
-// EigenDense (i.e. they don't have a data(), at least not with the usual matrix layout).
-// load() is not supported, but we can cast them into the python domain by first copying to a
-// regular Eigen::Matrix, then casting that.
-template <typename Type>
-struct type_caster<Type, enable_if_t<is_eigen_other<Type>::value>> {
-protected:
- using Matrix = Eigen::Matrix<typename Type::Scalar, Type::RowsAtCompileTime, Type::ColsAtCompileTime>;
- using props = EigenProps<Matrix>;
-public:
- static handle cast(const Type &src, return_value_policy /* policy */, handle /* parent */) {
- handle h = eigen_encapsulate<props>(new Matrix(src));
- return h;
- }
- static handle cast(const Type *src, return_value_policy policy, handle parent) { return cast(*src, policy, parent); }
-
- static PYBIND11_DESCR name() { return props::descriptor(); }
-
- // Explicitly delete these: support python -> C++ conversion on these (i.e. these can be return
- // types but not bound arguments). We still provide them (with an explicitly delete) so that
- // you end up here if you try anyway.
- bool load(handle, bool) = delete;
- operator Type() = delete;
- template <typename> using cast_op_type = Type;
-};
-
-template<typename Type>
-struct type_caster<Type, enable_if_t<is_eigen_sparse<Type>::value>> {
- typedef typename Type::Scalar Scalar;
- typedef typename std::remove_reference<decltype(*std::declval<Type>().outerIndexPtr())>::type StorageIndex;
- typedef typename Type::Index Index;
- static constexpr bool rowMajor = Type::IsRowMajor;
-
- bool load(handle src, bool) {
- if (!src)
- return false;
-
- auto obj = reinterpret_borrow<object>(src);
- object sparse_module = module::import("scipy.sparse");
- object matrix_type = sparse_module.attr(
- rowMajor ? "csr_matrix" : "csc_matrix");
-
- if (obj.get_type() != matrix_type.ptr()) {
- try {
- obj = matrix_type(obj);
- } catch (const error_already_set &) {
- return false;
- }
- }
-
- auto values = array_t<Scalar>((object) obj.attr("data"));
- auto innerIndices = array_t<StorageIndex>((object) obj.attr("indices"));
- auto outerIndices = array_t<StorageIndex>((object) obj.attr("indptr"));
- auto shape = pybind11::tuple((pybind11::object) obj.attr("shape"));
- auto nnz = obj.attr("nnz").cast<Index>();
-
- if (!values || !innerIndices || !outerIndices)
- return false;
-
- value = Eigen::MappedSparseMatrix<Scalar, Type::Flags, StorageIndex>(
- shape[0].cast<Index>(), shape[1].cast<Index>(), nnz,
- outerIndices.mutable_data(), innerIndices.mutable_data(), values.mutable_data());
-
- return true;
- }
-
- static handle cast(const Type &src, return_value_policy /* policy */, handle /* parent */) {
- const_cast<Type&>(src).makeCompressed();
-
- object matrix_type = module::import("scipy.sparse").attr(
- rowMajor ? "csr_matrix" : "csc_matrix");
-
- array data((size_t) src.nonZeros(), src.valuePtr());
- array outerIndices((size_t) (rowMajor ? src.rows() : src.cols()) + 1, src.outerIndexPtr());
- array innerIndices((size_t) src.nonZeros(), src.innerIndexPtr());
-
- return matrix_type(
- std::make_tuple(data, innerIndices, outerIndices),
- std::make_pair(src.rows(), src.cols())
- ).release();
- }
-
- PYBIND11_TYPE_CASTER(Type, _<(Type::IsRowMajor) != 0>("scipy.sparse.csr_matrix[", "scipy.sparse.csc_matrix[")
- + npy_format_descriptor<Scalar>::name() + _("]"));
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(pybind11)
-
-#if defined(__GNUG__) || defined(__clang__)
-# pragma GCC diagnostic pop
-#elif defined(_MSC_VER)
-# pragma warning(pop)
-#endif
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/eval.h b/thirdparty/pybind11/pybind11/include/pybind11/eval.h
deleted file mode 100644
index 5b2b98272d57559de8729f19a4280ab689e81758..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/eval.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- pybind11/exec.h: Support for evaluating Python expressions and statements
- from strings and files
-
- Copyright (c) 2016 Klemens Morgenstern <klemens.morgenstern@ed-chemnitz.de> and
- Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#pragma once
-
-#include "pybind11.h"
-
-NAMESPACE_BEGIN(pybind11)
-
-enum eval_mode {
- /// Evaluate a string containing an isolated expression
- eval_expr,
-
- /// Evaluate a string containing a single statement. Returns \c none
- eval_single_statement,
-
- /// Evaluate a string containing a sequence of statement. Returns \c none
- eval_statements
-};
-
-template <eval_mode mode = eval_expr>
-object eval(str expr, object global = object(), object local = object()) {
- if (!global) {
- global = reinterpret_borrow<object>(PyEval_GetGlobals());
- if (!global)
- global = dict();
- }
- if (!local)
- local = global;
-
- /* PyRun_String does not accept a PyObject / encoding specifier,
- this seems to be the only alternative */
- std::string buffer = "# -*- coding: utf-8 -*-\n" + (std::string) expr;
-
- int start;
- switch (mode) {
- case eval_expr: start = Py_eval_input; break;
- case eval_single_statement: start = Py_single_input; break;
- case eval_statements: start = Py_file_input; break;
- default: pybind11_fail("invalid evaluation mode");
- }
-
- PyObject *result = PyRun_String(buffer.c_str(), start, global.ptr(), local.ptr());
- if (!result)
- throw error_already_set();
- return reinterpret_steal<object>(result);
-}
-
-template <eval_mode mode = eval_statements>
-object eval_file(str fname, object global = object(), object local = object()) {
- if (!global) {
- global = reinterpret_borrow<object>(PyEval_GetGlobals());
- if (!global)
- global = dict();
- }
- if (!local)
- local = global;
-
- int start;
- switch (mode) {
- case eval_expr: start = Py_eval_input; break;
- case eval_single_statement: start = Py_single_input; break;
- case eval_statements: start = Py_file_input; break;
- default: pybind11_fail("invalid evaluation mode");
- }
-
- int closeFile = 1;
- std::string fname_str = (std::string) fname;
-#if PY_VERSION_HEX >= 0x03040000
- FILE *f = _Py_fopen_obj(fname.ptr(), "r");
-#elif PY_VERSION_HEX >= 0x03000000
- FILE *f = _Py_fopen(fname.ptr(), "r");
-#else
- /* No unicode support in open() :( */
- auto fobj = reinterpret_steal<object>(PyFile_FromString(
- const_cast<char *>(fname_str.c_str()),
- const_cast<char*>("r")));
- FILE *f = nullptr;
- if (fobj)
- f = PyFile_AsFile(fobj.ptr());
- closeFile = 0;
-#endif
- if (!f) {
- PyErr_Clear();
- pybind11_fail("File \"" + fname_str + "\" could not be opened!");
- }
-
-#if PY_VERSION_HEX < 0x03000000 && defined(PYPY_VERSION)
- PyObject *result = PyRun_File(f, fname_str.c_str(), start, global.ptr(),
- local.ptr());
- (void) closeFile;
-#else
- PyObject *result = PyRun_FileEx(f, fname_str.c_str(), start, global.ptr(),
- local.ptr(), closeFile);
-#endif
-
- if (!result)
- throw error_already_set();
- return reinterpret_steal<object>(result);
-}
-
-NAMESPACE_END(pybind11)
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/functional.h b/thirdparty/pybind11/pybind11/include/pybind11/functional.h
deleted file mode 100644
index a99ee737f458561badb928323d84b69cb63545e8..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/functional.h
+++ /dev/null
@@ -1,81 +0,0 @@
-/*
- pybind11/functional.h: std::function<> support
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "pybind11.h"
-#include <functional>
-
-NAMESPACE_BEGIN(pybind11)
-NAMESPACE_BEGIN(detail)
-
-template <typename Return, typename... Args>
-struct type_caster<std::function<Return(Args...)>> {
- using type = std::function<Return(Args...)>;
- using retval_type = conditional_t<std::is_same<Return, void>::value, void_type, Return>;
- using function_type = Return (*) (Args...);
-
-public:
- bool load(handle src_, bool) {
- if (src_.is_none())
- return true;
-
- src_ = detail::get_function(src_);
- if (!src_ || !PyCallable_Check(src_.ptr()))
- return false;
-
- /*
- When passing a C++ function as an argument to another C++
- function via Python, every function call would normally involve
- a full C++ -> Python -> C++ roundtrip, which can be prohibitive.
- Here, we try to at least detect the case where the function is
- stateless (i.e. function pointer or lambda function without
- captured variables), in which case the roundtrip can be avoided.
- */
- if (PyCFunction_Check(src_.ptr())) {
- auto c = reinterpret_borrow<capsule>(PyCFunction_GET_SELF(src_.ptr()));
- auto rec = (function_record *) c;
-
- if (rec && rec->is_stateless && rec->data[1] == &typeid(function_type)) {
- struct capture { function_type f; };
- value = ((capture *) &rec->data)->f;
- return true;
- }
- }
-
- auto src = reinterpret_borrow<object>(src_);
- value = [src](Args... args) -> Return {
- gil_scoped_acquire acq;
- object retval(src(std::forward<Args>(args)...));
- /* Visual studio 2015 parser issue: need parentheses around this expression */
- return (retval.template cast<Return>());
- };
- return true;
- }
-
- template <typename Func>
- static handle cast(Func &&f_, return_value_policy policy, handle /* parent */) {
- if (!f_)
- return none().inc_ref();
-
- auto result = f_.template target<function_type>();
- if (result)
- return cpp_function(*result, policy).release();
- else
- return cpp_function(std::forward<Func>(f_), policy).release();
- }
-
- PYBIND11_TYPE_CASTER(type, _("Callable[[") +
- argument_loader<Args...>::arg_names() + _("], ") +
- make_caster<retval_type>::name() +
- _("]"));
-};
-
-NAMESPACE_END(detail)
-NAMESPACE_END(pybind11)
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/numpy.h b/thirdparty/pybind11/pybind11/include/pybind11/numpy.h
deleted file mode 100644
index 3227a12eb2a1179cfcd95ce8fee6a81f06fb8e22..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/numpy.h
+++ /dev/null
@@ -1,1393 +0,0 @@
-/*
- pybind11/numpy.h: Basic NumPy support, vectorize() wrapper
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "pybind11.h"
-#include "complex.h"
-#include <numeric>
-#include <algorithm>
-#include <array>
-#include <cstdlib>
-#include <cstring>
-#include <sstream>
-#include <string>
-#include <initializer_list>
-#include <functional>
-#include <utility>
-#include <typeindex>
-
-#if defined(_MSC_VER)
-# pragma warning(push)
-# pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
-#endif
-
-/* This will be true on all flat address space platforms and allows us to reduce the
- whole npy_intp / size_t / Py_intptr_t business down to just size_t for all size
- and dimension types (e.g. shape, strides, indexing), instead of inflicting this
- upon the library user. */
-static_assert(sizeof(size_t) == sizeof(Py_intptr_t), "size_t != Py_intptr_t");
-
-NAMESPACE_BEGIN(pybind11)
-
-class array; // Forward declaration
-
-NAMESPACE_BEGIN(detail)
-template <typename type, typename SFINAE = void> struct npy_format_descriptor;
-
-struct PyArrayDescr_Proxy {
- PyObject_HEAD
- PyObject *typeobj;
- char kind;
- char type;
- char byteorder;
- char flags;
- int type_num;
- int elsize;
- int alignment;
- char *subarray;
- PyObject *fields;
- PyObject *names;
-};
-
-struct PyArray_Proxy {
- PyObject_HEAD
- char *data;
- int nd;
- ssize_t *dimensions;
- ssize_t *strides;
- PyObject *base;
- PyObject *descr;
- int flags;
-};
-
-struct PyVoidScalarObject_Proxy {
- PyObject_VAR_HEAD
- char *obval;
- PyArrayDescr_Proxy *descr;
- int flags;
- PyObject *base;
-};
-
-struct numpy_type_info {
- PyObject* dtype_ptr;
- std::string format_str;
-};
-
-struct numpy_internals {
- std::unordered_map<std::type_index, numpy_type_info> registered_dtypes;
-
- numpy_type_info *get_type_info(const std::type_info& tinfo, bool throw_if_missing = true) {
- auto it = registered_dtypes.find(std::type_index(tinfo));
- if (it != registered_dtypes.end())
- return &(it->second);
- if (throw_if_missing)
- pybind11_fail(std::string("NumPy type info missing for ") + tinfo.name());
- return nullptr;
- }
-
- template<typename T> numpy_type_info *get_type_info(bool throw_if_missing = true) {
- return get_type_info(typeid(typename std::remove_cv<T>::type), throw_if_missing);
- }
-};
-
-inline PYBIND11_NOINLINE void load_numpy_internals(numpy_internals* &ptr) {
- ptr = &get_or_create_shared_data<numpy_internals>("_numpy_internals");
-}
-
-inline numpy_internals& get_numpy_internals() {
- static numpy_internals* ptr = nullptr;
- if (!ptr)
- load_numpy_internals(ptr);
- return *ptr;
-}
-
-struct npy_api {
- enum constants {
- NPY_ARRAY_C_CONTIGUOUS_ = 0x0001,
- NPY_ARRAY_F_CONTIGUOUS_ = 0x0002,
- NPY_ARRAY_OWNDATA_ = 0x0004,
- NPY_ARRAY_FORCECAST_ = 0x0010,
- NPY_ARRAY_ENSUREARRAY_ = 0x0040,
- NPY_ARRAY_ALIGNED_ = 0x0100,
- NPY_ARRAY_WRITEABLE_ = 0x0400,
- NPY_BOOL_ = 0,
- NPY_BYTE_, NPY_UBYTE_,
- NPY_SHORT_, NPY_USHORT_,
- NPY_INT_, NPY_UINT_,
- NPY_LONG_, NPY_ULONG_,
- NPY_LONGLONG_, NPY_ULONGLONG_,
- NPY_FLOAT_, NPY_DOUBLE_, NPY_LONGDOUBLE_,
- NPY_CFLOAT_, NPY_CDOUBLE_, NPY_CLONGDOUBLE_,
- NPY_OBJECT_ = 17,
- NPY_STRING_, NPY_UNICODE_, NPY_VOID_
- };
-
- static npy_api& get() {
- static npy_api api = lookup();
- return api;
- }
-
- bool PyArray_Check_(PyObject *obj) const {
- return (bool) PyObject_TypeCheck(obj, PyArray_Type_);
- }
- bool PyArrayDescr_Check_(PyObject *obj) const {
- return (bool) PyObject_TypeCheck(obj, PyArrayDescr_Type_);
- }
-
- PyObject *(*PyArray_DescrFromType_)(int);
- PyObject *(*PyArray_NewFromDescr_)
- (PyTypeObject *, PyObject *, int, Py_intptr_t *,
- Py_intptr_t *, void *, int, PyObject *);
- PyObject *(*PyArray_DescrNewFromType_)(int);
- PyObject *(*PyArray_NewCopy_)(PyObject *, int);
- PyTypeObject *PyArray_Type_;
- PyTypeObject *PyVoidArrType_Type_;
- PyTypeObject *PyArrayDescr_Type_;
- PyObject *(*PyArray_DescrFromScalar_)(PyObject *);
- PyObject *(*PyArray_FromAny_) (PyObject *, PyObject *, int, int, int, PyObject *);
- int (*PyArray_DescrConverter_) (PyObject *, PyObject **);
- bool (*PyArray_EquivTypes_) (PyObject *, PyObject *);
- int (*PyArray_GetArrayParamsFromObject_)(PyObject *, PyObject *, char, PyObject **, int *,
- Py_ssize_t *, PyObject **, PyObject *);
- PyObject *(*PyArray_Squeeze_)(PyObject *);
- int (*PyArray_SetBaseObject_)(PyObject *, PyObject *);
-private:
- enum functions {
- API_PyArray_Type = 2,
- API_PyArrayDescr_Type = 3,
- API_PyVoidArrType_Type = 39,
- API_PyArray_DescrFromType = 45,
- API_PyArray_DescrFromScalar = 57,
- API_PyArray_FromAny = 69,
- API_PyArray_NewCopy = 85,
- API_PyArray_NewFromDescr = 94,
- API_PyArray_DescrNewFromType = 9,
- API_PyArray_DescrConverter = 174,
- API_PyArray_EquivTypes = 182,
- API_PyArray_GetArrayParamsFromObject = 278,
- API_PyArray_Squeeze = 136,
- API_PyArray_SetBaseObject = 282
- };
-
- static npy_api lookup() {
- module m = module::import("numpy.core.multiarray");
- auto c = m.attr("_ARRAY_API");
-#if PY_MAJOR_VERSION >= 3
- void **api_ptr = (void **) PyCapsule_GetPointer(c.ptr(), NULL);
-#else
- void **api_ptr = (void **) PyCObject_AsVoidPtr(c.ptr());
-#endif
- npy_api api;
-#define DECL_NPY_API(Func) api.Func##_ = (decltype(api.Func##_)) api_ptr[API_##Func];
- DECL_NPY_API(PyArray_Type);
- DECL_NPY_API(PyVoidArrType_Type);
- DECL_NPY_API(PyArrayDescr_Type);
- DECL_NPY_API(PyArray_DescrFromType);
- DECL_NPY_API(PyArray_DescrFromScalar);
- DECL_NPY_API(PyArray_FromAny);
- DECL_NPY_API(PyArray_NewCopy);
- DECL_NPY_API(PyArray_NewFromDescr);
- DECL_NPY_API(PyArray_DescrNewFromType);
- DECL_NPY_API(PyArray_DescrConverter);
- DECL_NPY_API(PyArray_EquivTypes);
- DECL_NPY_API(PyArray_GetArrayParamsFromObject);
- DECL_NPY_API(PyArray_Squeeze);
- DECL_NPY_API(PyArray_SetBaseObject);
-#undef DECL_NPY_API
- return api;
- }
-};
-
-inline PyArray_Proxy* array_proxy(void* ptr) {
- return reinterpret_cast<PyArray_Proxy*>(ptr);
-}
-
-inline const PyArray_Proxy* array_proxy(const void* ptr) {
- return reinterpret_cast<const PyArray_Proxy*>(ptr);
-}
-
-inline PyArrayDescr_Proxy* array_descriptor_proxy(PyObject* ptr) {
- return reinterpret_cast<PyArrayDescr_Proxy*>(ptr);
-}
-
-inline const PyArrayDescr_Proxy* array_descriptor_proxy(const PyObject* ptr) {
- return reinterpret_cast<const PyArrayDescr_Proxy*>(ptr);
-}
-
-inline bool check_flags(const void* ptr, int flag) {
- return (flag == (array_proxy(ptr)->flags & flag));
-}
-
-template <typename T> struct is_std_array : std::false_type { };
-template <typename T, size_t N> struct is_std_array<std::array<T, N>> : std::true_type { };
-template <typename T> struct is_complex : std::false_type { };
-template <typename T> struct is_complex<std::complex<T>> : std::true_type { };
-
-template <typename T> using is_pod_struct = all_of<
- std::is_pod<T>, // since we're accessing directly in memory we need a POD type
- satisfies_none_of<T, std::is_reference, std::is_array, is_std_array, std::is_arithmetic, is_complex, std::is_enum>
->;
-
-template <size_t Dim = 0, typename Strides> size_t byte_offset_unsafe(const Strides &) { return 0; }
-template <size_t Dim = 0, typename Strides, typename... Ix>
-size_t byte_offset_unsafe(const Strides &strides, size_t i, Ix... index) {
- return i * strides[Dim] + byte_offset_unsafe<Dim + 1>(strides, index...);
-}
-
-/** Proxy class providing unsafe, unchecked const access to array data. This is constructed through
- * the `unchecked<T, N>()` method of `array` or the `unchecked<N>()` method of `array_t<T>`. `Dims`
- * will be -1 for dimensions determined at runtime.
- */
-template <typename T, ssize_t Dims>
-class unchecked_reference {
-protected:
- static constexpr bool Dynamic = Dims < 0;
- const unsigned char *data_;
- // Storing the shape & strides in local variables (i.e. these arrays) allows the compiler to
- // make large performance gains on big, nested loops, but requires compile-time dimensions
- conditional_t<Dynamic, const size_t *, std::array<size_t, (size_t) Dims>>
- shape_, strides_;
- const size_t dims_;
-
- friend class pybind11::array;
- // Constructor for compile-time dimensions:
- template <bool Dyn = Dynamic>
- unchecked_reference(const void *data, const size_t *shape, const size_t *strides, enable_if_t<!Dyn, size_t>)
- : data_{reinterpret_cast<const unsigned char *>(data)}, dims_{Dims} {
- for (size_t i = 0; i < dims_; i++) {
- shape_[i] = shape[i];
- strides_[i] = strides[i];
- }
- }
- // Constructor for runtime dimensions:
- template <bool Dyn = Dynamic>
- unchecked_reference(const void *data, const size_t *shape, const size_t *strides, enable_if_t<Dyn, size_t> dims)
- : data_{reinterpret_cast<const unsigned char *>(data)}, shape_{shape}, strides_{strides}, dims_{dims} {}
-
-public:
- /** Unchecked const reference access to data at the given indices. For a compile-time known
- * number of dimensions, this requires the correct number of arguments; for run-time
- * dimensionality, this is not checked (and so is up to the caller to use safely).
- */
- template <typename... Ix> const T &operator()(Ix... index) const {
- static_assert(sizeof...(Ix) == Dims || Dynamic,
- "Invalid number of indices for unchecked array reference");
- return *reinterpret_cast<const T *>(data_ + byte_offset_unsafe(strides_, size_t(index)...));
- }
- /** Unchecked const reference access to data; this operator only participates if the reference
- * is to a 1-dimensional array. When present, this is exactly equivalent to `obj(index)`.
- */
- template <size_t D = Dims, typename = enable_if_t<D == 1 || Dynamic>>
- const T &operator[](size_t index) const { return operator()(index); }
-
- /// Pointer access to the data at the given indices.
- template <typename... Ix> const T *data(Ix... ix) const { return &operator()(size_t(ix)...); }
-
- /// Returns the item size, i.e. sizeof(T)
- constexpr static size_t itemsize() { return sizeof(T); }
-
- /// Returns the shape (i.e. size) of dimension `dim`
- size_t shape(size_t dim) const { return shape_[dim]; }
-
- /// Returns the number of dimensions of the array
- size_t ndim() const { return dims_; }
-
- /// Returns the total number of elements in the referenced array, i.e. the product of the shapes
- template <bool Dyn = Dynamic>
- enable_if_t<!Dyn, size_t> size() const {
- return std::accumulate(shape_.begin(), shape_.end(), (size_t) 1, std::multiplies<size_t>());
- }
- template <bool Dyn = Dynamic>
- enable_if_t<Dyn, size_t> size() const {
- return std::accumulate(shape_, shape_ + ndim(), (size_t) 1, std::multiplies<size_t>());
- }
-
- /// Returns the total number of bytes used by the referenced data. Note that the actual span in
- /// memory may be larger if the referenced array has non-contiguous strides (e.g. for a slice).
- size_t nbytes() const {
- return size() * itemsize();
- }
-};
-
-template <typename T, ssize_t Dims>
-class unchecked_mutable_reference : public unchecked_reference<T, Dims> {
- friend class pybind11::array;
- using ConstBase = unchecked_reference<T, Dims>;
- using ConstBase::ConstBase;
- using ConstBase::Dynamic;
-public:
- /// Mutable, unchecked access to data at the given indices.
- template <typename... Ix> T& operator()(Ix... index) {
- static_assert(sizeof...(Ix) == Dims || Dynamic,
- "Invalid number of indices for unchecked array reference");
- return const_cast<T &>(ConstBase::operator()(index...));
- }
- /** Mutable, unchecked access data at the given index; this operator only participates if the
- * reference is to a 1-dimensional array (or has runtime dimensions). When present, this is
- * exactly equivalent to `obj(index)`.
- */
- template <size_t D = Dims, typename = enable_if_t<D == 1 || Dynamic>>
- T &operator[](size_t index) { return operator()(index); }
-
- /// Mutable pointer access to the data at the given indices.
- template <typename... Ix> T *mutable_data(Ix... ix) { return &operator()(size_t(ix)...); }
-};
-
-template <typename T, size_t Dim>
-struct type_caster<unchecked_reference<T, Dim>> {
- static_assert(Dim == 0 && Dim > 0 /* always fail */, "unchecked array proxy object is not castable");
-};
-template <typename T, size_t Dim>
-struct type_caster<unchecked_mutable_reference<T, Dim>> : type_caster<unchecked_reference<T, Dim>> {};
-
-NAMESPACE_END(detail)
-
-class dtype : public object {
-public:
- PYBIND11_OBJECT_DEFAULT(dtype, object, detail::npy_api::get().PyArrayDescr_Check_);
-
- explicit dtype(const buffer_info &info) {
- dtype descr(_dtype_from_pep3118()(PYBIND11_STR_TYPE(info.format)));
- // If info.itemsize == 0, use the value calculated from the format string
- m_ptr = descr.strip_padding(info.itemsize ? info.itemsize : descr.itemsize()).release().ptr();
- }
-
- explicit dtype(const std::string &format) {
- m_ptr = from_args(pybind11::str(format)).release().ptr();
- }
-
- dtype(const char *format) : dtype(std::string(format)) { }
-
- dtype(list names, list formats, list offsets, size_t itemsize) {
- dict args;
- args["names"] = names;
- args["formats"] = formats;
- args["offsets"] = offsets;
- args["itemsize"] = pybind11::int_(itemsize);
- m_ptr = from_args(args).release().ptr();
- }
-
- /// This is essentially the same as calling numpy.dtype(args) in Python.
- static dtype from_args(object args) {
- PyObject *ptr = nullptr;
- if (!detail::npy_api::get().PyArray_DescrConverter_(args.release().ptr(), &ptr) || !ptr)
- throw error_already_set();
- return reinterpret_steal<dtype>(ptr);
- }
-
- /// Return dtype associated with a C++ type.
- template <typename T> static dtype of() {
- return detail::npy_format_descriptor<typename std::remove_cv<T>::type>::dtype();
- }
-
- /// Size of the data type in bytes.
- size_t itemsize() const {
- return (size_t) detail::array_descriptor_proxy(m_ptr)->elsize;
- }
-
- /// Returns true for structured data types.
- bool has_fields() const {
- return detail::array_descriptor_proxy(m_ptr)->names != nullptr;
- }
-
- /// Single-character type code.
- char kind() const {
- return detail::array_descriptor_proxy(m_ptr)->kind;
- }
-
-private:
- static object _dtype_from_pep3118() {
- static PyObject *obj = module::import("numpy.core._internal")
- .attr("_dtype_from_pep3118").cast<object>().release().ptr();
- return reinterpret_borrow<object>(obj);
- }
-
- dtype strip_padding(size_t itemsize) {
- // Recursively strip all void fields with empty names that are generated for
- // padding fields (as of NumPy v1.11).
- if (!has_fields())
- return *this;
-
- struct field_descr { PYBIND11_STR_TYPE name; object format; pybind11::int_ offset; };
- std::vector<field_descr> field_descriptors;
-
- for (auto field : attr("fields").attr("items")()) {
- auto spec = field.cast<tuple>();
- auto name = spec[0].cast<pybind11::str>();
- auto format = spec[1].cast<tuple>()[0].cast<dtype>();
- auto offset = spec[1].cast<tuple>()[1].cast<pybind11::int_>();
- if (!len(name) && format.kind() == 'V')
- continue;
- field_descriptors.push_back({(PYBIND11_STR_TYPE) name, format.strip_padding(format.itemsize()), offset});
- }
-
- std::sort(field_descriptors.begin(), field_descriptors.end(),
- [](const field_descr& a, const field_descr& b) {
- return a.offset.cast<int>() < b.offset.cast<int>();
- });
-
- list names, formats, offsets;
- for (auto& descr : field_descriptors) {
- names.append(descr.name);
- formats.append(descr.format);
- offsets.append(descr.offset);
- }
- return dtype(names, formats, offsets, itemsize);
- }
-};
-
-class array : public buffer {
-public:
- PYBIND11_OBJECT_CVT(array, buffer, detail::npy_api::get().PyArray_Check_, raw_array)
-
- enum {
- c_style = detail::npy_api::NPY_ARRAY_C_CONTIGUOUS_,
- f_style = detail::npy_api::NPY_ARRAY_F_CONTIGUOUS_,
- forcecast = detail::npy_api::NPY_ARRAY_FORCECAST_
- };
-
- array() : array(0, static_cast<const double *>(nullptr)) {}
-
- array(const pybind11::dtype &dt, const std::vector<size_t> &shape,
- const std::vector<size_t> &strides, const void *ptr = nullptr,
- handle base = handle()) {
- auto& api = detail::npy_api::get();
- auto ndim = shape.size();
- if (shape.size() != strides.size())
- pybind11_fail("NumPy: shape ndim doesn't match strides ndim");
- auto descr = dt;
-
- int flags = 0;
- if (base && ptr) {
- if (isinstance<array>(base))
- /* Copy flags from base (except ownership bit) */
- flags = reinterpret_borrow<array>(base).flags() & ~detail::npy_api::NPY_ARRAY_OWNDATA_;
- else
- /* Writable by default, easy to downgrade later on if needed */
- flags = detail::npy_api::NPY_ARRAY_WRITEABLE_;
- }
-
- auto tmp = reinterpret_steal<object>(api.PyArray_NewFromDescr_(
- api.PyArray_Type_, descr.release().ptr(), (int) ndim,
- reinterpret_cast<Py_intptr_t *>(const_cast<size_t*>(shape.data())),
- reinterpret_cast<Py_intptr_t *>(const_cast<size_t*>(strides.data())),
- const_cast<void *>(ptr), flags, nullptr));
- if (!tmp)
- pybind11_fail("NumPy: unable to create array!");
- if (ptr) {
- if (base) {
- api.PyArray_SetBaseObject_(tmp.ptr(), base.inc_ref().ptr());
- } else {
- tmp = reinterpret_steal<object>(api.PyArray_NewCopy_(tmp.ptr(), -1 /* any order */));
- }
- }
- m_ptr = tmp.release().ptr();
- }
-
- array(const pybind11::dtype &dt, const std::vector<size_t> &shape,
- const void *ptr = nullptr, handle base = handle())
- : array(dt, shape, default_strides(shape, dt.itemsize()), ptr, base) { }
-
- array(const pybind11::dtype &dt, size_t count, const void *ptr = nullptr,
- handle base = handle())
- : array(dt, std::vector<size_t>{ count }, ptr, base) { }
-
- template<typename T> array(const std::vector<size_t>& shape,
- const std::vector<size_t>& strides,
- const T* ptr, handle base = handle())
- : array(pybind11::dtype::of<T>(), shape, strides, (const void *) ptr, base) { }
-
- template <typename T>
- array(const std::vector<size_t> &shape, const T *ptr,
- handle base = handle())
- : array(shape, default_strides(shape, sizeof(T)), ptr, base) { }
-
- template <typename T>
- array(size_t count, const T *ptr, handle base = handle())
- : array(std::vector<size_t>{ count }, ptr, base) { }
-
- explicit array(const buffer_info &info)
- : array(pybind11::dtype(info), info.shape, info.strides, info.ptr) { }
-
- /// Array descriptor (dtype)
- pybind11::dtype dtype() const {
- return reinterpret_borrow<pybind11::dtype>(detail::array_proxy(m_ptr)->descr);
- }
-
- /// Total number of elements
- size_t size() const {
- return std::accumulate(shape(), shape() + ndim(), (size_t) 1, std::multiplies<size_t>());
- }
-
- /// Byte size of a single element
- size_t itemsize() const {
- return (size_t) detail::array_descriptor_proxy(detail::array_proxy(m_ptr)->descr)->elsize;
- }
-
- /// Total number of bytes
- size_t nbytes() const {
- return size() * itemsize();
- }
-
- /// Number of dimensions
- size_t ndim() const {
- return (size_t) detail::array_proxy(m_ptr)->nd;
- }
-
- /// Base object
- object base() const {
- return reinterpret_borrow<object>(detail::array_proxy(m_ptr)->base);
- }
-
- /// Dimensions of the array
- const size_t* shape() const {
- return reinterpret_cast<const size_t *>(detail::array_proxy(m_ptr)->dimensions);
- }
-
- /// Dimension along a given axis
- size_t shape(size_t dim) const {
- if (dim >= ndim())
- fail_dim_check(dim, "invalid axis");
- return shape()[dim];
- }
-
- /// Strides of the array
- const size_t* strides() const {
- return reinterpret_cast<const size_t *>(detail::array_proxy(m_ptr)->strides);
- }
-
- /// Stride along a given axis
- size_t strides(size_t dim) const {
- if (dim >= ndim())
- fail_dim_check(dim, "invalid axis");
- return strides()[dim];
- }
-
- /// Return the NumPy array flags
- int flags() const {
- return detail::array_proxy(m_ptr)->flags;
- }
-
- /// If set, the array is writeable (otherwise the buffer is read-only)
- bool writeable() const {
- return detail::check_flags(m_ptr, detail::npy_api::NPY_ARRAY_WRITEABLE_);
- }
-
- /// If set, the array owns the data (will be freed when the array is deleted)
- bool owndata() const {
- return detail::check_flags(m_ptr, detail::npy_api::NPY_ARRAY_OWNDATA_);
- }
-
- /// Pointer to the contained data. If index is not provided, points to the
- /// beginning of the buffer. May throw if the index would lead to out of bounds access.
- template<typename... Ix> const void* data(Ix... index) const {
- return static_cast<const void *>(detail::array_proxy(m_ptr)->data + offset_at(index...));
- }
-
- /// Mutable pointer to the contained data. If index is not provided, points to the
- /// beginning of the buffer. May throw if the index would lead to out of bounds access.
- /// May throw if the array is not writeable.
- template<typename... Ix> void* mutable_data(Ix... index) {
- check_writeable();
- return static_cast<void *>(detail::array_proxy(m_ptr)->data + offset_at(index...));
- }
-
- /// Byte offset from beginning of the array to a given index (full or partial).
- /// May throw if the index would lead to out of bounds access.
- template<typename... Ix> size_t offset_at(Ix... index) const {
- if (sizeof...(index) > ndim())
- fail_dim_check(sizeof...(index), "too many indices for an array");
- return byte_offset(size_t(index)...);
- }
-
- size_t offset_at() const { return 0; }
-
- /// Item count from beginning of the array to a given index (full or partial).
- /// May throw if the index would lead to out of bounds access.
- template<typename... Ix> size_t index_at(Ix... index) const {
- return offset_at(index...) / itemsize();
- }
-
- /** Returns a proxy object that provides access to the array's data without bounds or
- * dimensionality checking. Will throw if the array is missing the `writeable` flag. Use with
- * care: the array must not be destroyed or reshaped for the duration of the returned object,
- * and the caller must take care not to access invalid dimensions or dimension indices.
- */
- template <typename T, ssize_t Dims = -1> detail::unchecked_mutable_reference<T, Dims> mutable_unchecked() {
- if (Dims >= 0 && ndim() != (size_t) Dims)
- throw std::domain_error("array has incorrect number of dimensions: " + std::to_string(ndim()) +
- "; expected " + std::to_string(Dims));
- return detail::unchecked_mutable_reference<T, Dims>(mutable_data(), shape(), strides(), ndim());
- }
-
- /** Returns a proxy object that provides const access to the array's data without bounds or
- * dimensionality checking. Unlike `mutable_unchecked()`, this does not require that the
- * underlying array have the `writable` flag. Use with care: the array must not be destroyed or
- * reshaped for the duration of the returned object, and the caller must take care not to access
- * invalid dimensions or dimension indices.
- */
- template <typename T, ssize_t Dims = -1> detail::unchecked_reference<T, Dims> unchecked() const {
- if (Dims >= 0 && ndim() != (size_t) Dims)
- throw std::domain_error("array has incorrect number of dimensions: " + std::to_string(ndim()) +
- "; expected " + std::to_string(Dims));
- return detail::unchecked_reference<T, Dims>(data(), shape(), strides(), ndim());
- }
-
- /// Return a new view with all of the dimensions of length 1 removed
- array squeeze() {
- auto& api = detail::npy_api::get();
- return reinterpret_steal<array>(api.PyArray_Squeeze_(m_ptr));
- }
-
- /// Ensure that the argument is a NumPy array
- /// In case of an error, nullptr is returned and the Python error is cleared.
- static array ensure(handle h, int ExtraFlags = 0) {
- auto result = reinterpret_steal<array>(raw_array(h.ptr(), ExtraFlags));
- if (!result)
- PyErr_Clear();
- return result;
- }
-
-protected:
- template<typename, typename> friend struct detail::npy_format_descriptor;
-
- void fail_dim_check(size_t dim, const std::string& msg) const {
- throw index_error(msg + ": " + std::to_string(dim) +
- " (ndim = " + std::to_string(ndim()) + ")");
- }
-
- template<typename... Ix> size_t byte_offset(Ix... index) const {
- check_dimensions(index...);
- return detail::byte_offset_unsafe(strides(), size_t(index)...);
- }
-
- void check_writeable() const {
- if (!writeable())
- throw std::domain_error("array is not writeable");
- }
-
- static std::vector<size_t> default_strides(const std::vector<size_t>& shape, size_t itemsize) {
- auto ndim = shape.size();
- std::vector<size_t> strides(ndim);
- if (ndim) {
- std::fill(strides.begin(), strides.end(), itemsize);
- for (size_t i = 0; i < ndim - 1; i++)
- for (size_t j = 0; j < ndim - 1 - i; j++)
- strides[j] *= shape[ndim - 1 - i];
- }
- return strides;
- }
-
- template<typename... Ix> void check_dimensions(Ix... index) const {
- check_dimensions_impl(size_t(0), shape(), size_t(index)...);
- }
-
- void check_dimensions_impl(size_t, const size_t*) const { }
-
- template<typename... Ix> void check_dimensions_impl(size_t axis, const size_t* shape, size_t i, Ix... index) const {
- if (i >= *shape) {
- throw index_error(std::string("index ") + std::to_string(i) +
- " is out of bounds for axis " + std::to_string(axis) +
- " with size " + std::to_string(*shape));
- }
- check_dimensions_impl(axis + 1, shape + 1, index...);
- }
-
- /// Create array from any object -- always returns a new reference
- static PyObject *raw_array(PyObject *ptr, int ExtraFlags = 0) {
- if (ptr == nullptr)
- return nullptr;
- return detail::npy_api::get().PyArray_FromAny_(
- ptr, nullptr, 0, 0, detail::npy_api::NPY_ARRAY_ENSUREARRAY_ | ExtraFlags, nullptr);
- }
-};
-
-template <typename T, int ExtraFlags = array::forcecast> class array_t : public array {
-public:
- using value_type = T;
-
- array_t() : array(0, static_cast<const T *>(nullptr)) {}
- array_t(handle h, borrowed_t) : array(h, borrowed) { }
- array_t(handle h, stolen_t) : array(h, stolen) { }
-
- PYBIND11_DEPRECATED("Use array_t<T>::ensure() instead")
- array_t(handle h, bool is_borrowed) : array(raw_array_t(h.ptr()), stolen) {
- if (!m_ptr) PyErr_Clear();
- if (!is_borrowed) Py_XDECREF(h.ptr());
- }
-
- array_t(const object &o) : array(raw_array_t(o.ptr()), stolen) {
- if (!m_ptr) throw error_already_set();
- }
-
- explicit array_t(const buffer_info& info) : array(info) { }
-
- array_t(const std::vector<size_t> &shape,
- const std::vector<size_t> &strides, const T *ptr = nullptr,
- handle base = handle())
- : array(shape, strides, ptr, base) { }
-
- explicit array_t(const std::vector<size_t> &shape, const T *ptr = nullptr,
- handle base = handle())
- : array(shape, ptr, base) { }
-
- explicit array_t(size_t count, const T *ptr = nullptr, handle base = handle())
- : array(count, ptr, base) { }
-
- constexpr size_t itemsize() const {
- return sizeof(T);
- }
-
- template<typename... Ix> size_t index_at(Ix... index) const {
- return offset_at(index...) / itemsize();
- }
-
- template<typename... Ix> const T* data(Ix... index) const {
- return static_cast<const T*>(array::data(index...));
- }
-
- template<typename... Ix> T* mutable_data(Ix... index) {
- return static_cast<T*>(array::mutable_data(index...));
- }
-
- // Reference to element at a given index
- template<typename... Ix> const T& at(Ix... index) const {
- if (sizeof...(index) != ndim())
- fail_dim_check(sizeof...(index), "index dimension mismatch");
- return *(static_cast<const T*>(array::data()) + byte_offset(size_t(index)...) / itemsize());
- }
-
- // Mutable reference to element at a given index
- template<typename... Ix> T& mutable_at(Ix... index) {
- if (sizeof...(index) != ndim())
- fail_dim_check(sizeof...(index), "index dimension mismatch");
- return *(static_cast<T*>(array::mutable_data()) + byte_offset(size_t(index)...) / itemsize());
- }
-
- /** Returns a proxy object that provides access to the array's data without bounds or
- * dimensionality checking. Will throw if the array is missing the `writeable` flag. Use with
- * care: the array must not be destroyed or reshaped for the duration of the returned object,
- * and the caller must take care not to access invalid dimensions or dimension indices.
- */
- template <ssize_t Dims = -1> detail::unchecked_mutable_reference<T, Dims> mutable_unchecked() {
- return array::mutable_unchecked<T, Dims>();
- }
-
- /** Returns a proxy object that provides const access to the array's data without bounds or
- * dimensionality checking. Unlike `unchecked()`, this does not require that the underlying
- * array have the `writable` flag. Use with care: the array must not be destroyed or reshaped
- * for the duration of the returned object, and the caller must take care not to access invalid
- * dimensions or dimension indices.
- */
- template <ssize_t Dims = -1> detail::unchecked_reference<T, Dims> unchecked() const {
- return array::unchecked<T, Dims>();
- }
-
- /// Ensure that the argument is a NumPy array of the correct dtype (and if not, try to convert
- /// it). In case of an error, nullptr is returned and the Python error is cleared.
- static array_t ensure(handle h) {
- auto result = reinterpret_steal<array_t>(raw_array_t(h.ptr()));
- if (!result)
- PyErr_Clear();
- return result;
- }
-
- static bool check_(handle h) {
- const auto &api = detail::npy_api::get();
- return api.PyArray_Check_(h.ptr())
- && api.PyArray_EquivTypes_(detail::array_proxy(h.ptr())->descr, dtype::of<T>().ptr());
- }
-
-protected:
- /// Create array from any object -- always returns a new reference
- static PyObject *raw_array_t(PyObject *ptr) {
- if (ptr == nullptr)
- return nullptr;
- return detail::npy_api::get().PyArray_FromAny_(
- ptr, dtype::of<T>().release().ptr(), 0, 0,
- detail::npy_api::NPY_ARRAY_ENSUREARRAY_ | ExtraFlags, nullptr);
- }
-};
-
-template <typename T>
-struct format_descriptor<T, detail::enable_if_t<detail::is_pod_struct<T>::value>> {
- static std::string format() {
- return detail::npy_format_descriptor<typename std::remove_cv<T>::type>::format();
- }
-};
-
-template <size_t N> struct format_descriptor<char[N]> {
- static std::string format() { return std::to_string(N) + "s"; }
-};
-template <size_t N> struct format_descriptor<std::array<char, N>> {
- static std::string format() { return std::to_string(N) + "s"; }
-};
-
-template <typename T>
-struct format_descriptor<T, detail::enable_if_t<std::is_enum<T>::value>> {
- static std::string format() {
- return format_descriptor<
- typename std::remove_cv<typename std::underlying_type<T>::type>::type>::format();
- }
-};
-
-NAMESPACE_BEGIN(detail)
-template <typename T, int ExtraFlags>
-struct pyobject_caster<array_t<T, ExtraFlags>> {
- using type = array_t<T, ExtraFlags>;
-
- bool load(handle src, bool convert) {
- if (!convert && !type::check_(src))
- return false;
- value = type::ensure(src);
- return static_cast<bool>(value);
- }
-
- static handle cast(const handle &src, return_value_policy /* policy */, handle /* parent */) {
- return src.inc_ref();
- }
- PYBIND11_TYPE_CASTER(type, handle_type_name<type>::name());
-};
-
-template <typename T>
-struct compare_buffer_info<T, detail::enable_if_t<detail::is_pod_struct<T>::value>> {
- static bool compare(const buffer_info& b) {
- return npy_api::get().PyArray_EquivTypes_(dtype::of<T>().ptr(), dtype(b).ptr());
- }
-};
-
-template <typename T> struct npy_format_descriptor<T, enable_if_t<satisfies_any_of<T, std::is_arithmetic, is_complex>::value>> {
-private:
- // NB: the order here must match the one in common.h
- constexpr static const int values[15] = {
- npy_api::NPY_BOOL_,
- npy_api::NPY_BYTE_, npy_api::NPY_UBYTE_, npy_api::NPY_SHORT_, npy_api::NPY_USHORT_,
- npy_api::NPY_INT_, npy_api::NPY_UINT_, npy_api::NPY_LONGLONG_, npy_api::NPY_ULONGLONG_,
- npy_api::NPY_FLOAT_, npy_api::NPY_DOUBLE_, npy_api::NPY_LONGDOUBLE_,
- npy_api::NPY_CFLOAT_, npy_api::NPY_CDOUBLE_, npy_api::NPY_CLONGDOUBLE_
- };
-
-public:
- static constexpr int value = values[detail::is_fmt_numeric<T>::index];
-
- static pybind11::dtype dtype() {
- if (auto ptr = npy_api::get().PyArray_DescrFromType_(value))
- return reinterpret_borrow<pybind11::dtype>(ptr);
- pybind11_fail("Unsupported buffer format!");
- }
- template <typename T2 = T, enable_if_t<std::is_integral<T2>::value, int> = 0>
- static PYBIND11_DESCR name() {
- return _<std::is_same<T, bool>::value>(_("bool"),
- _<std::is_signed<T>::value>("int", "uint") + _<sizeof(T)*8>());
- }
- template <typename T2 = T, enable_if_t<std::is_floating_point<T2>::value, int> = 0>
- static PYBIND11_DESCR name() {
- return _<std::is_same<T, float>::value || std::is_same<T, double>::value>(
- _("float") + _<sizeof(T)*8>(), _("longdouble"));
- }
- template <typename T2 = T, enable_if_t<is_complex<T2>::value, int> = 0>
- static PYBIND11_DESCR name() {
- return _<std::is_same<typename T2::value_type, float>::value || std::is_same<typename T2::value_type, double>::value>(
- _("complex") + _<sizeof(typename T2::value_type)*16>(), _("longcomplex"));
- }
-};
-
-#define PYBIND11_DECL_CHAR_FMT \
- static PYBIND11_DESCR name() { return _("S") + _<N>(); } \
- static pybind11::dtype dtype() { return pybind11::dtype(std::string("S") + std::to_string(N)); }
-template <size_t N> struct npy_format_descriptor<char[N]> { PYBIND11_DECL_CHAR_FMT };
-template <size_t N> struct npy_format_descriptor<std::array<char, N>> { PYBIND11_DECL_CHAR_FMT };
-#undef PYBIND11_DECL_CHAR_FMT
-
-template<typename T> struct npy_format_descriptor<T, enable_if_t<std::is_enum<T>::value>> {
-private:
- using base_descr = npy_format_descriptor<typename std::underlying_type<T>::type>;
-public:
- static PYBIND11_DESCR name() { return base_descr::name(); }
- static pybind11::dtype dtype() { return base_descr::dtype(); }
-};
-
-struct field_descriptor {
- const char *name;
- size_t offset;
- size_t size;
- size_t alignment;
- std::string format;
- dtype descr;
-};
-
-inline PYBIND11_NOINLINE void register_structured_dtype(
- const std::initializer_list<field_descriptor>& fields,
- const std::type_info& tinfo, size_t itemsize,
- bool (*direct_converter)(PyObject *, void *&)) {
-
- auto& numpy_internals = get_numpy_internals();
- if (numpy_internals.get_type_info(tinfo, false))
- pybind11_fail("NumPy: dtype is already registered");
-
- list names, formats, offsets;
- for (auto field : fields) {
- if (!field.descr)
- pybind11_fail(std::string("NumPy: unsupported field dtype: `") +
- field.name + "` @ " + tinfo.name());
- names.append(PYBIND11_STR_TYPE(field.name));
- formats.append(field.descr);
- offsets.append(pybind11::int_(field.offset));
- }
- auto dtype_ptr = pybind11::dtype(names, formats, offsets, itemsize).release().ptr();
-
- // There is an existing bug in NumPy (as of v1.11): trailing bytes are
- // not encoded explicitly into the format string. This will supposedly
- // get fixed in v1.12; for further details, see these:
- // - https://github.com/numpy/numpy/issues/7797
- // - https://github.com/numpy/numpy/pull/7798
- // Because of this, we won't use numpy's logic to generate buffer format
- // strings and will just do it ourselves.
- std::vector<field_descriptor> ordered_fields(fields);
- std::sort(ordered_fields.begin(), ordered_fields.end(),
- [](const field_descriptor &a, const field_descriptor &b) { return a.offset < b.offset; });
- size_t offset = 0;
- std::ostringstream oss;
- oss << "T{";
- for (auto& field : ordered_fields) {
- if (field.offset > offset)
- oss << (field.offset - offset) << 'x';
- // mark unaligned fields with '^' (unaligned native type)
- if (field.offset % field.alignment)
- oss << '^';
- oss << field.format << ':' << field.name << ':';
- offset = field.offset + field.size;
- }
- if (itemsize > offset)
- oss << (itemsize - offset) << 'x';
- oss << '}';
- auto format_str = oss.str();
-
- // Sanity check: verify that NumPy properly parses our buffer format string
- auto& api = npy_api::get();
- auto arr = array(buffer_info(nullptr, itemsize, format_str, 1));
- if (!api.PyArray_EquivTypes_(dtype_ptr, arr.dtype().ptr()))
- pybind11_fail("NumPy: invalid buffer descriptor!");
-
- auto tindex = std::type_index(tinfo);
- numpy_internals.registered_dtypes[tindex] = { dtype_ptr, format_str };
- get_internals().direct_conversions[tindex].push_back(direct_converter);
-}
-
-template <typename T, typename SFINAE> struct npy_format_descriptor {
- static_assert(is_pod_struct<T>::value, "Attempt to use a non-POD or unimplemented POD type as a numpy dtype");
-
- static PYBIND11_DESCR name() { return make_caster<T>::name(); }
-
- static pybind11::dtype dtype() {
- return reinterpret_borrow<pybind11::dtype>(dtype_ptr());
- }
-
- static std::string format() {
- static auto format_str = get_numpy_internals().get_type_info<T>(true)->format_str;
- return format_str;
- }
-
- static void register_dtype(const std::initializer_list<field_descriptor>& fields) {
- register_structured_dtype(fields, typeid(typename std::remove_cv<T>::type),
- sizeof(T), &direct_converter);
- }
-
-private:
- static PyObject* dtype_ptr() {
- static PyObject* ptr = get_numpy_internals().get_type_info<T>(true)->dtype_ptr;
- return ptr;
- }
-
- static bool direct_converter(PyObject *obj, void*& value) {
- auto& api = npy_api::get();
- if (!PyObject_TypeCheck(obj, api.PyVoidArrType_Type_))
- return false;
- if (auto descr = reinterpret_steal<object>(api.PyArray_DescrFromScalar_(obj))) {
- if (api.PyArray_EquivTypes_(dtype_ptr(), descr.ptr())) {
- value = ((PyVoidScalarObject_Proxy *) obj)->obval;
- return true;
- }
- }
- return false;
- }
-};
-
-#define PYBIND11_FIELD_DESCRIPTOR_EX(T, Field, Name) \
- ::pybind11::detail::field_descriptor { \
- Name, offsetof(T, Field), sizeof(decltype(std::declval<T>().Field)), \
- alignof(decltype(std::declval<T>().Field)), \
- ::pybind11::format_descriptor<decltype(std::declval<T>().Field)>::format(), \
- ::pybind11::detail::npy_format_descriptor<decltype(std::declval<T>().Field)>::dtype() \
- }
-
-// Extract name, offset and format descriptor for a struct field
-#define PYBIND11_FIELD_DESCRIPTOR(T, Field) PYBIND11_FIELD_DESCRIPTOR_EX(T, Field, #Field)
-
-// The main idea of this macro is borrowed from https://github.com/swansontec/map-macro
-// (C) William Swanson, Paul Fultz
-#define PYBIND11_EVAL0(...) __VA_ARGS__
-#define PYBIND11_EVAL1(...) PYBIND11_EVAL0 (PYBIND11_EVAL0 (PYBIND11_EVAL0 (__VA_ARGS__)))
-#define PYBIND11_EVAL2(...) PYBIND11_EVAL1 (PYBIND11_EVAL1 (PYBIND11_EVAL1 (__VA_ARGS__)))
-#define PYBIND11_EVAL3(...) PYBIND11_EVAL2 (PYBIND11_EVAL2 (PYBIND11_EVAL2 (__VA_ARGS__)))
-#define PYBIND11_EVAL4(...) PYBIND11_EVAL3 (PYBIND11_EVAL3 (PYBIND11_EVAL3 (__VA_ARGS__)))
-#define PYBIND11_EVAL(...) PYBIND11_EVAL4 (PYBIND11_EVAL4 (PYBIND11_EVAL4 (__VA_ARGS__)))
-#define PYBIND11_MAP_END(...)
-#define PYBIND11_MAP_OUT
-#define PYBIND11_MAP_COMMA ,
-#define PYBIND11_MAP_GET_END() 0, PYBIND11_MAP_END
-#define PYBIND11_MAP_NEXT0(test, next, ...) next PYBIND11_MAP_OUT
-#define PYBIND11_MAP_NEXT1(test, next) PYBIND11_MAP_NEXT0 (test, next, 0)
-#define PYBIND11_MAP_NEXT(test, next) PYBIND11_MAP_NEXT1 (PYBIND11_MAP_GET_END test, next)
-#ifdef _MSC_VER // MSVC is not as eager to expand macros, hence this workaround
-#define PYBIND11_MAP_LIST_NEXT1(test, next) \
- PYBIND11_EVAL0 (PYBIND11_MAP_NEXT0 (test, PYBIND11_MAP_COMMA next, 0))
-#else
-#define PYBIND11_MAP_LIST_NEXT1(test, next) \
- PYBIND11_MAP_NEXT0 (test, PYBIND11_MAP_COMMA next, 0)
-#endif
-#define PYBIND11_MAP_LIST_NEXT(test, next) \
- PYBIND11_MAP_LIST_NEXT1 (PYBIND11_MAP_GET_END test, next)
-#define PYBIND11_MAP_LIST0(f, t, x, peek, ...) \
- f(t, x) PYBIND11_MAP_LIST_NEXT (peek, PYBIND11_MAP_LIST1) (f, t, peek, __VA_ARGS__)
-#define PYBIND11_MAP_LIST1(f, t, x, peek, ...) \
- f(t, x) PYBIND11_MAP_LIST_NEXT (peek, PYBIND11_MAP_LIST0) (f, t, peek, __VA_ARGS__)
-// PYBIND11_MAP_LIST(f, t, a1, a2, ...) expands to f(t, a1), f(t, a2), ...
-#define PYBIND11_MAP_LIST(f, t, ...) \
- PYBIND11_EVAL (PYBIND11_MAP_LIST1 (f, t, __VA_ARGS__, (), 0))
-
-#define PYBIND11_NUMPY_DTYPE(Type, ...) \
- ::pybind11::detail::npy_format_descriptor<Type>::register_dtype \
- ({PYBIND11_MAP_LIST (PYBIND11_FIELD_DESCRIPTOR, Type, __VA_ARGS__)})
-
-#ifdef _MSC_VER
-#define PYBIND11_MAP2_LIST_NEXT1(test, next) \
- PYBIND11_EVAL0 (PYBIND11_MAP_NEXT0 (test, PYBIND11_MAP_COMMA next, 0))
-#else
-#define PYBIND11_MAP2_LIST_NEXT1(test, next) \
- PYBIND11_MAP_NEXT0 (test, PYBIND11_MAP_COMMA next, 0)
-#endif
-#define PYBIND11_MAP2_LIST_NEXT(test, next) \
- PYBIND11_MAP2_LIST_NEXT1 (PYBIND11_MAP_GET_END test, next)
-#define PYBIND11_MAP2_LIST0(f, t, x1, x2, peek, ...) \
- f(t, x1, x2) PYBIND11_MAP2_LIST_NEXT (peek, PYBIND11_MAP2_LIST1) (f, t, peek, __VA_ARGS__)
-#define PYBIND11_MAP2_LIST1(f, t, x1, x2, peek, ...) \
- f(t, x1, x2) PYBIND11_MAP2_LIST_NEXT (peek, PYBIND11_MAP2_LIST0) (f, t, peek, __VA_ARGS__)
-// PYBIND11_MAP2_LIST(f, t, a1, a2, ...) expands to f(t, a1, a2), f(t, a3, a4), ...
-#define PYBIND11_MAP2_LIST(f, t, ...) \
- PYBIND11_EVAL (PYBIND11_MAP2_LIST1 (f, t, __VA_ARGS__, (), 0))
-
-#define PYBIND11_NUMPY_DTYPE_EX(Type, ...) \
- ::pybind11::detail::npy_format_descriptor<Type>::register_dtype \
- ({PYBIND11_MAP2_LIST (PYBIND11_FIELD_DESCRIPTOR_EX, Type, __VA_ARGS__)})
-
-template <class T>
-using array_iterator = typename std::add_pointer<T>::type;
-
-template <class T>
-array_iterator<T> array_begin(const buffer_info& buffer) {
- return array_iterator<T>(reinterpret_cast<T*>(buffer.ptr));
-}
-
-template <class T>
-array_iterator<T> array_end(const buffer_info& buffer) {
- return array_iterator<T>(reinterpret_cast<T*>(buffer.ptr) + buffer.size);
-}
-
-class common_iterator {
-public:
- using container_type = std::vector<size_t>;
- using value_type = container_type::value_type;
- using size_type = container_type::size_type;
-
- common_iterator() : p_ptr(0), m_strides() {}
-
- common_iterator(void* ptr, const container_type& strides, const std::vector<size_t>& shape)
- : p_ptr(reinterpret_cast<char*>(ptr)), m_strides(strides.size()) {
- m_strides.back() = static_cast<value_type>(strides.back());
- for (size_type i = m_strides.size() - 1; i != 0; --i) {
- size_type j = i - 1;
- value_type s = static_cast<value_type>(shape[i]);
- m_strides[j] = strides[j] + m_strides[i] - strides[i] * s;
- }
- }
-
- void increment(size_type dim) {
- p_ptr += m_strides[dim];
- }
-
- void* data() const {
- return p_ptr;
- }
-
-private:
- char* p_ptr;
- container_type m_strides;
-};
-
-template <size_t N> class multi_array_iterator {
-public:
- using container_type = std::vector<size_t>;
-
- multi_array_iterator(const std::array<buffer_info, N> &buffers,
- const std::vector<size_t> &shape)
- : m_shape(shape.size()), m_index(shape.size(), 0),
- m_common_iterator() {
-
- // Manual copy to avoid conversion warning if using std::copy
- for (size_t i = 0; i < shape.size(); ++i)
- m_shape[i] = static_cast<container_type::value_type>(shape[i]);
-
- container_type strides(shape.size());
- for (size_t i = 0; i < N; ++i)
- init_common_iterator(buffers[i], shape, m_common_iterator[i], strides);
- }
-
- multi_array_iterator& operator++() {
- for (size_t j = m_index.size(); j != 0; --j) {
- size_t i = j - 1;
- if (++m_index[i] != m_shape[i]) {
- increment_common_iterator(i);
- break;
- } else {
- m_index[i] = 0;
- }
- }
- return *this;
- }
-
- template <size_t K, class T> const T& data() const {
- return *reinterpret_cast<T*>(m_common_iterator[K].data());
- }
-
-private:
-
- using common_iter = common_iterator;
-
- void init_common_iterator(const buffer_info &buffer,
- const std::vector<size_t> &shape,
- common_iter &iterator, container_type &strides) {
- auto buffer_shape_iter = buffer.shape.rbegin();
- auto buffer_strides_iter = buffer.strides.rbegin();
- auto shape_iter = shape.rbegin();
- auto strides_iter = strides.rbegin();
-
- while (buffer_shape_iter != buffer.shape.rend()) {
- if (*shape_iter == *buffer_shape_iter)
- *strides_iter = static_cast<size_t>(*buffer_strides_iter);
- else
- *strides_iter = 0;
-
- ++buffer_shape_iter;
- ++buffer_strides_iter;
- ++shape_iter;
- ++strides_iter;
- }
-
- std::fill(strides_iter, strides.rend(), 0);
- iterator = common_iter(buffer.ptr, strides, shape);
- }
-
- void increment_common_iterator(size_t dim) {
- for (auto &iter : m_common_iterator)
- iter.increment(dim);
- }
-
- container_type m_shape;
- container_type m_index;
- std::array<common_iter, N> m_common_iterator;
-};
-
-enum class broadcast_trivial { non_trivial, c_trivial, f_trivial };
-
-// Populates the shape and number of dimensions for the set of buffers. Returns a broadcast_trivial
-// enum value indicating whether the broadcast is "trivial"--that is, has each buffer being either a
-// singleton or a full-size, C-contiguous (`c_trivial`) or Fortran-contiguous (`f_trivial`) storage
-// buffer; returns `non_trivial` otherwise.
-template <size_t N>
-broadcast_trivial broadcast(const std::array<buffer_info, N> &buffers, size_t &ndim, std::vector<size_t> &shape) {
- ndim = std::accumulate(buffers.begin(), buffers.end(), size_t(0), [](size_t res, const buffer_info& buf) {
- return std::max(res, buf.ndim);
- });
-
- shape.clear();
- shape.resize(ndim, 1);
-
- // Figure out the output size, and make sure all input arrays conform (i.e. are either size 1 or
- // the full size).
- for (size_t i = 0; i < N; ++i) {
- auto res_iter = shape.rbegin();
- auto end = buffers[i].shape.rend();
- for (auto shape_iter = buffers[i].shape.rbegin(); shape_iter != end; ++shape_iter, ++res_iter) {
- const auto &dim_size_in = *shape_iter;
- auto &dim_size_out = *res_iter;
-
- // Each input dimension can either be 1 or `n`, but `n` values must match across buffers
- if (dim_size_out == 1)
- dim_size_out = dim_size_in;
- else if (dim_size_in != 1 && dim_size_in != dim_size_out)
- pybind11_fail("pybind11::vectorize: incompatible size/dimension of inputs!");
- }
- }
-
- bool trivial_broadcast_c = true;
- bool trivial_broadcast_f = true;
- for (size_t i = 0; i < N && (trivial_broadcast_c || trivial_broadcast_f); ++i) {
- if (buffers[i].size == 1)
- continue;
-
- // Require the same number of dimensions:
- if (buffers[i].ndim != ndim)
- return broadcast_trivial::non_trivial;
-
- // Require all dimensions be full-size:
- if (!std::equal(buffers[i].shape.cbegin(), buffers[i].shape.cend(), shape.cbegin()))
- return broadcast_trivial::non_trivial;
-
- // Check for C contiguity (but only if previous inputs were also C contiguous)
- if (trivial_broadcast_c) {
- size_t expect_stride = buffers[i].itemsize;
- auto end = buffers[i].shape.crend();
- for (auto shape_iter = buffers[i].shape.crbegin(), stride_iter = buffers[i].strides.crbegin();
- trivial_broadcast_c && shape_iter != end; ++shape_iter, ++stride_iter) {
- if (expect_stride == *stride_iter)
- expect_stride *= *shape_iter;
- else
- trivial_broadcast_c = false;
- }
- }
-
- // Check for Fortran contiguity (if previous inputs were also F contiguous)
- if (trivial_broadcast_f) {
- size_t expect_stride = buffers[i].itemsize;
- auto end = buffers[i].shape.cend();
- for (auto shape_iter = buffers[i].shape.cbegin(), stride_iter = buffers[i].strides.cbegin();
- trivial_broadcast_f && shape_iter != end; ++shape_iter, ++stride_iter) {
- if (expect_stride == *stride_iter)
- expect_stride *= *shape_iter;
- else
- trivial_broadcast_f = false;
- }
- }
- }
-
- return
- trivial_broadcast_c ? broadcast_trivial::c_trivial :
- trivial_broadcast_f ? broadcast_trivial::f_trivial :
- broadcast_trivial::non_trivial;
-}
-
-template <typename Func, typename Return, typename... Args>
-struct vectorize_helper {
- typename std::remove_reference<Func>::type f;
- static constexpr size_t N = sizeof...(Args);
-
- template <typename T>
- explicit vectorize_helper(T&&f) : f(std::forward<T>(f)) { }
-
- object operator()(array_t<Args, array::forcecast>... args) {
- return run(args..., make_index_sequence<N>());
- }
-
- template <size_t ... Index> object run(array_t<Args, array::forcecast>&... args, index_sequence<Index...> index) {
- /* Request buffers from all parameters */
- std::array<buffer_info, N> buffers {{ args.request()... }};
-
- /* Determine dimensions parameters of output array */
- size_t ndim = 0;
- std::vector<size_t> shape(0);
- auto trivial = broadcast(buffers, ndim, shape);
-
- size_t size = 1;
- std::vector<size_t> strides(ndim);
- if (ndim > 0) {
- if (trivial == broadcast_trivial::f_trivial) {
- strides[0] = sizeof(Return);
- for (size_t i = 1; i < ndim; ++i) {
- strides[i] = strides[i - 1] * shape[i - 1];
- size *= shape[i - 1];
- }
- size *= shape[ndim - 1];
- }
- else {
- strides[ndim-1] = sizeof(Return);
- for (size_t i = ndim - 1; i > 0; --i) {
- strides[i - 1] = strides[i] * shape[i];
- size *= shape[i];
- }
- size *= shape[0];
- }
- }
-
- if (size == 1)
- return cast(f(*reinterpret_cast<Args *>(buffers[Index].ptr)...));
-
- array_t<Return> result(shape, strides);
- auto buf = result.request();
- auto output = (Return *) buf.ptr;
-
- /* Call the function */
- if (trivial == broadcast_trivial::non_trivial) {
- apply_broadcast<Index...>(buffers, buf, index);
- } else {
- for (size_t i = 0; i < size; ++i)
- output[i] = f((reinterpret_cast<Args *>(buffers[Index].ptr)[buffers[Index].size == 1 ? 0 : i])...);
- }
-
- return result;
- }
-
- template <size_t... Index>
- void apply_broadcast(const std::array<buffer_info, N> &buffers,
- buffer_info &output, index_sequence<Index...>) {
- using input_iterator = multi_array_iterator<N>;
- using output_iterator = array_iterator<Return>;
-
- input_iterator input_iter(buffers, output.shape);
- output_iterator output_end = array_end<Return>(output);
-
- for (output_iterator iter = array_begin<Return>(output);
- iter != output_end; ++iter, ++input_iter) {
- *iter = f((input_iter.template data<Index, Args>())...);
- }
- }
-};
-
-template <typename T, int Flags> struct handle_type_name<array_t<T, Flags>> {
- static PYBIND11_DESCR name() {
- return _("numpy.ndarray[") + npy_format_descriptor<T>::name() + _("]");
- }
-};
-
-NAMESPACE_END(detail)
-
-template <typename Func, typename Return, typename... Args>
-detail::vectorize_helper<Func, Return, Args...>
-vectorize(const Func &f, Return (*) (Args ...)) {
- return detail::vectorize_helper<Func, Return, Args...>(f);
-}
-
-template <typename Return, typename... Args>
-detail::vectorize_helper<Return (*) (Args ...), Return, Args...>
-vectorize(Return (*f) (Args ...)) {
- return vectorize<Return (*) (Args ...), Return, Args...>(f, f);
-}
-
-template <typename Func, typename FuncType = typename detail::remove_class<decltype(&std::remove_reference<Func>::type::operator())>::type>
-auto vectorize(Func &&f) -> decltype(
- vectorize(std::forward<Func>(f), (FuncType *) nullptr)) {
- return vectorize(std::forward<Func>(f), (FuncType *) nullptr);
-}
-
-NAMESPACE_END(pybind11)
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/operators.h b/thirdparty/pybind11/pybind11/include/pybind11/operators.h
deleted file mode 100644
index 2e78c01a3f88e99f96895a8f26faef22096571d2..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/operators.h
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- pybind11/operator.h: Metatemplates for operator overloading
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "pybind11.h"
-
-#if defined(__clang__) && !defined(__INTEL_COMPILER)
-# pragma clang diagnostic ignored "-Wunsequenced" // multiple unsequenced modifications to 'self' (when using def(py::self OP Type()))
-#endif
-
-NAMESPACE_BEGIN(pybind11)
-NAMESPACE_BEGIN(detail)
-
-/// Enumeration with all supported operator types
-enum op_id : int {
- op_add, op_sub, op_mul, op_div, op_mod, op_divmod, op_pow, op_lshift,
- op_rshift, op_and, op_xor, op_or, op_neg, op_pos, op_abs, op_invert,
- op_int, op_long, op_float, op_str, op_cmp, op_gt, op_ge, op_lt, op_le,
- op_eq, op_ne, op_iadd, op_isub, op_imul, op_idiv, op_imod, op_ilshift,
- op_irshift, op_iand, op_ixor, op_ior, op_complex, op_bool, op_nonzero,
- op_repr, op_truediv
-};
-
-enum op_type : int {
- op_l, /* base type on left */
- op_r, /* base type on right */
- op_u /* unary operator */
-};
-
-struct self_t { };
-static const self_t self = self_t();
-
-/// Type for an unused type slot
-struct undefined_t { };
-
-/// Don't warn about an unused variable
-inline self_t __self() { return self; }
-
-/// base template of operator implementations
-template <op_id, op_type, typename B, typename L, typename R> struct op_impl { };
-
-/// Operator implementation generator
-template <op_id id, op_type ot, typename L, typename R> struct op_ {
- template <typename Class, typename... Extra> void execute(Class &cl, const Extra&... extra) const {
- typedef typename Class::type Base;
- typedef typename std::conditional<std::is_same<L, self_t>::value, Base, L>::type L_type;
- typedef typename std::conditional<std::is_same<R, self_t>::value, Base, R>::type R_type;
- typedef op_impl<id, ot, Base, L_type, R_type> op;
- cl.def(op::name(), &op::execute, is_operator(), extra...);
- }
- template <typename Class, typename... Extra> void execute_cast(Class &cl, const Extra&... extra) const {
- typedef typename Class::type Base;
- typedef typename std::conditional<std::is_same<L, self_t>::value, Base, L>::type L_type;
- typedef typename std::conditional<std::is_same<R, self_t>::value, Base, R>::type R_type;
- typedef op_impl<id, ot, Base, L_type, R_type> op;
- cl.def(op::name(), &op::execute_cast, is_operator(), extra...);
- }
-};
-
-#define PYBIND11_BINARY_OPERATOR(id, rid, op, expr) \
-template <typename B, typename L, typename R> struct op_impl<op_##id, op_l, B, L, R> { \
- static char const* name() { return "__" #id "__"; } \
- static auto execute(const L &l, const R &r) -> decltype(expr) { return (expr); } \
- static B execute_cast(const L &l, const R &r) { return B(expr); } \
-}; \
-template <typename B, typename L, typename R> struct op_impl<op_##id, op_r, B, L, R> { \
- static char const* name() { return "__" #rid "__"; } \
- static auto execute(const R &r, const L &l) -> decltype(expr) { return (expr); } \
- static B execute_cast(const R &r, const L &l) { return B(expr); } \
-}; \
-inline op_<op_##id, op_l, self_t, self_t> op(const self_t &, const self_t &) { \
- return op_<op_##id, op_l, self_t, self_t>(); \
-} \
-template <typename T> op_<op_##id, op_l, self_t, T> op(const self_t &, const T &) { \
- return op_<op_##id, op_l, self_t, T>(); \
-} \
-template <typename T> op_<op_##id, op_r, T, self_t> op(const T &, const self_t &) { \
- return op_<op_##id, op_r, T, self_t>(); \
-}
-
-#define PYBIND11_INPLACE_OPERATOR(id, op, expr) \
-template <typename B, typename L, typename R> struct op_impl<op_##id, op_l, B, L, R> { \
- static char const* name() { return "__" #id "__"; } \
- static auto execute(L &l, const R &r) -> decltype(expr) { return expr; } \
- static B execute_cast(L &l, const R &r) { return B(expr); } \
-}; \
-template <typename T> op_<op_##id, op_l, self_t, T> op(const self_t &, const T &) { \
- return op_<op_##id, op_l, self_t, T>(); \
-}
-
-#define PYBIND11_UNARY_OPERATOR(id, op, expr) \
-template <typename B, typename L> struct op_impl<op_##id, op_u, B, L, undefined_t> { \
- static char const* name() { return "__" #id "__"; } \
- static auto execute(const L &l) -> decltype(expr) { return expr; } \
- static B execute_cast(const L &l) { return B(expr); } \
-}; \
-inline op_<op_##id, op_u, self_t, undefined_t> op(const self_t &) { \
- return op_<op_##id, op_u, self_t, undefined_t>(); \
-}
-
-PYBIND11_BINARY_OPERATOR(sub, rsub, operator-, l - r)
-PYBIND11_BINARY_OPERATOR(add, radd, operator+, l + r)
-PYBIND11_BINARY_OPERATOR(mul, rmul, operator*, l * r)
-#if PY_MAJOR_VERSION >= 3
-PYBIND11_BINARY_OPERATOR(truediv, rtruediv, operator/, l / r)
-#else
-PYBIND11_BINARY_OPERATOR(div, rdiv, operator/, l / r)
-#endif
-PYBIND11_BINARY_OPERATOR(mod, rmod, operator%, l % r)
-PYBIND11_BINARY_OPERATOR(lshift, rlshift, operator<<, l << r)
-PYBIND11_BINARY_OPERATOR(rshift, rrshift, operator>>, l >> r)
-PYBIND11_BINARY_OPERATOR(and, rand, operator&, l & r)
-PYBIND11_BINARY_OPERATOR(xor, rxor, operator^, l ^ r)
-PYBIND11_BINARY_OPERATOR(eq, eq, operator==, l == r)
-PYBIND11_BINARY_OPERATOR(ne, ne, operator!=, l != r)
-PYBIND11_BINARY_OPERATOR(or, ror, operator|, l | r)
-PYBIND11_BINARY_OPERATOR(gt, lt, operator>, l > r)
-PYBIND11_BINARY_OPERATOR(ge, le, operator>=, l >= r)
-PYBIND11_BINARY_OPERATOR(lt, gt, operator<, l < r)
-PYBIND11_BINARY_OPERATOR(le, ge, operator<=, l <= r)
-//PYBIND11_BINARY_OPERATOR(pow, rpow, pow, std::pow(l, r))
-PYBIND11_INPLACE_OPERATOR(iadd, operator+=, l += r)
-PYBIND11_INPLACE_OPERATOR(isub, operator-=, l -= r)
-PYBIND11_INPLACE_OPERATOR(imul, operator*=, l *= r)
-PYBIND11_INPLACE_OPERATOR(idiv, operator/=, l /= r)
-PYBIND11_INPLACE_OPERATOR(imod, operator%=, l %= r)
-PYBIND11_INPLACE_OPERATOR(ilshift, operator<<=, l <<= r)
-PYBIND11_INPLACE_OPERATOR(irshift, operator>>=, l >>= r)
-PYBIND11_INPLACE_OPERATOR(iand, operator&=, l &= r)
-PYBIND11_INPLACE_OPERATOR(ixor, operator^=, l ^= r)
-PYBIND11_INPLACE_OPERATOR(ior, operator|=, l |= r)
-PYBIND11_UNARY_OPERATOR(neg, operator-, -l)
-PYBIND11_UNARY_OPERATOR(pos, operator+, +l)
-PYBIND11_UNARY_OPERATOR(abs, abs, std::abs(l))
-PYBIND11_UNARY_OPERATOR(invert, operator~, (~l))
-PYBIND11_UNARY_OPERATOR(bool, operator!, !!l)
-PYBIND11_UNARY_OPERATOR(int, int_, (int) l)
-PYBIND11_UNARY_OPERATOR(float, float_, (double) l)
-
-#undef PYBIND11_BINARY_OPERATOR
-#undef PYBIND11_INPLACE_OPERATOR
-#undef PYBIND11_UNARY_OPERATOR
-NAMESPACE_END(detail)
-
-using detail::self;
-
-NAMESPACE_END(pybind11)
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/options.h b/thirdparty/pybind11/pybind11/include/pybind11/options.h
deleted file mode 100644
index 3105551ddd9b4ed7fdc31dea4a7af4af3e45be09..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/options.h
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- pybind11/options.h: global settings that are configurable at runtime.
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "common.h"
-
-NAMESPACE_BEGIN(pybind11)
-
-class options {
-public:
-
- // Default RAII constructor, which leaves settings as they currently are.
- options() : previous_state(global_state()) {}
-
- // Class is non-copyable.
- options(const options&) = delete;
- options& operator=(const options&) = delete;
-
- // Destructor, which restores settings that were in effect before.
- ~options() {
- global_state() = previous_state;
- }
-
- // Setter methods (affect the global state):
-
- options& disable_user_defined_docstrings() & { global_state().show_user_defined_docstrings = false; return *this; }
-
- options& enable_user_defined_docstrings() & { global_state().show_user_defined_docstrings = true; return *this; }
-
- options& disable_function_signatures() & { global_state().show_function_signatures = false; return *this; }
-
- options& enable_function_signatures() & { global_state().show_function_signatures = true; return *this; }
-
- // Getter methods (return the global state):
-
- static bool show_user_defined_docstrings() { return global_state().show_user_defined_docstrings; }
-
- static bool show_function_signatures() { return global_state().show_function_signatures; }
-
- // This type is not meant to be allocated on the heap.
- void* operator new(size_t) = delete;
-
-private:
-
- struct state {
- bool show_user_defined_docstrings = true; //< Include user-supplied texts in docstrings.
- bool show_function_signatures = true; //< Include auto-generated function signatures in docstrings.
- };
-
- static state &global_state() {
- static state instance;
- return instance;
- }
-
- state previous_state;
-};
-
-NAMESPACE_END(pybind11)
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/pybind11.h b/thirdparty/pybind11/pybind11/include/pybind11/pybind11.h
deleted file mode 100644
index 5976a36d81667db7a14858db60bad53d88b3df80..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/pybind11.h
+++ /dev/null
@@ -1,1741 +0,0 @@
-/*
- pybind11/pybind11.h: Main header file of the C++11 python
- binding generator library
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#if defined(_MSC_VER)
-# pragma warning(push)
-# pragma warning(disable: 4100) // warning C4100: Unreferenced formal parameter
-# pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
-# pragma warning(disable: 4512) // warning C4512: Assignment operator was implicitly defined as deleted
-# pragma warning(disable: 4800) // warning C4800: 'int': forcing value to bool 'true' or 'false' (performance warning)
-# pragma warning(disable: 4996) // warning C4996: The POSIX name for this item is deprecated. Instead, use the ISO C and C++ conformant name
-# pragma warning(disable: 4702) // warning C4702: unreachable code
-# pragma warning(disable: 4522) // warning C4522: multiple assignment operators specified
-#elif defined(__INTEL_COMPILER)
-# pragma warning(push)
-# pragma warning(disable: 186) // pointless comparison of unsigned integer with zero
-# pragma warning(disable: 1334) // the "template" keyword used for syntactic disambiguation may only be used within a template
-# pragma warning(disable: 2196) // warning #2196: routine is both "inline" and "noinline"
-#elif defined(__GNUG__) && !defined(__clang__)
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wunused-but-set-parameter"
-# pragma GCC diagnostic ignored "-Wunused-but-set-variable"
-# pragma GCC diagnostic ignored "-Wmissing-field-initializers"
-# pragma GCC diagnostic ignored "-Wstrict-aliasing"
-# pragma GCC diagnostic ignored "-Wattributes"
-#endif
-
-#include "attr.h"
-#include "options.h"
-#include "class_support.h"
-
-NAMESPACE_BEGIN(pybind11)
-
-/// Wraps an arbitrary C++ function/method/lambda function/.. into a callable Python object
-class cpp_function : public function {
-public:
- cpp_function() { }
-
- /// Construct a cpp_function from a vanilla function pointer
- template <typename Return, typename... Args, typename... Extra>
- cpp_function(Return (*f)(Args...), const Extra&... extra) {
- initialize(f, f, extra...);
- }
-
- /// Construct a cpp_function from a lambda function (possibly with internal state)
- template <typename Func, typename... Extra, typename = detail::enable_if_t<
- detail::satisfies_none_of<
- typename std::remove_reference<Func>::type,
- std::is_function, std::is_pointer, std::is_member_pointer
- >::value>
- >
- cpp_function(Func &&f, const Extra&... extra) {
- using FuncType = typename detail::remove_class<decltype(&std::remove_reference<Func>::type::operator())>::type;
- initialize(std::forward<Func>(f),
- (FuncType *) nullptr, extra...);
- }
-
- /// Construct a cpp_function from a class method (non-const)
- template <typename Return, typename Class, typename... Arg, typename... Extra>
- cpp_function(Return (Class::*f)(Arg...), const Extra&... extra) {
- initialize([f](Class *c, Arg... args) -> Return { return (c->*f)(args...); },
- (Return (*) (Class *, Arg...)) nullptr, extra...);
- }
-
- /// Construct a cpp_function from a class method (const)
- template <typename Return, typename Class, typename... Arg, typename... Extra>
- cpp_function(Return (Class::*f)(Arg...) const, const Extra&... extra) {
- initialize([f](const Class *c, Arg... args) -> Return { return (c->*f)(args...); },
- (Return (*)(const Class *, Arg ...)) nullptr, extra...);
- }
-
- /// Return the function name
- object name() const { return attr("__name__"); }
-
-protected:
- /// Space optimization: don't inline this frequently instantiated fragment
- PYBIND11_NOINLINE detail::function_record *make_function_record() {
- return new detail::function_record();
- }
-
- /// Special internal constructor for functors, lambda functions, etc.
- template <typename Func, typename Return, typename... Args, typename... Extra>
- void initialize(Func &&f, Return (*)(Args...), const Extra&... extra) {
-
- struct capture { typename std::remove_reference<Func>::type f; };
-
- /* Store the function including any extra state it might have (e.g. a lambda capture object) */
- auto rec = make_function_record();
-
- /* Store the capture object directly in the function record if there is enough space */
- if (sizeof(capture) <= sizeof(rec->data)) {
- /* Without these pragmas, GCC warns that there might not be
- enough space to use the placement new operator. However, the
- 'if' statement above ensures that this is the case. */
-#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
-# pragma GCC diagnostic push
-# pragma GCC diagnostic ignored "-Wplacement-new"
-#endif
- new ((capture *) &rec->data) capture { std::forward<Func>(f) };
-#if defined(__GNUG__) && !defined(__clang__) && __GNUC__ >= 6
-# pragma GCC diagnostic pop
-#endif
- if (!std::is_trivially_destructible<Func>::value)
- rec->free_data = [](detail::function_record *r) { ((capture *) &r->data)->~capture(); };
- } else {
- rec->data[0] = new capture { std::forward<Func>(f) };
- rec->free_data = [](detail::function_record *r) { delete ((capture *) r->data[0]); };
- }
-
- /* Type casters for the function arguments and return value */
- using cast_in = detail::argument_loader<Args...>;
- using cast_out = detail::make_caster<
- detail::conditional_t<std::is_void<Return>::value, detail::void_type, Return>
- >;
-
- static_assert(detail::expected_num_args<Extra...>(sizeof...(Args), cast_in::has_args, cast_in::has_kwargs),
- "The number of argument annotations does not match the number of function arguments");
-
- /* Dispatch code which converts function arguments and performs the actual function call */
- rec->impl = [](detail::function_call &call) -> handle {
- cast_in args_converter;
-
- /* Try to cast the function arguments into the C++ domain */
- if (!args_converter.load_args(call))
- return PYBIND11_TRY_NEXT_OVERLOAD;
-
- /* Invoke call policy pre-call hook */
- detail::process_attributes<Extra...>::precall(call);
-
- /* Get a pointer to the capture object */
- auto data = (sizeof(capture) <= sizeof(call.func.data)
- ? &call.func.data : call.func.data[0]);
- capture *cap = const_cast<capture *>(reinterpret_cast<const capture *>(data));
-
- /* Override policy for rvalues -- usually to enforce rvp::move on an rvalue */
- const auto policy = detail::return_value_policy_override<Return>::policy(call.func.policy);
-
- /* Perform the function call */
- handle result = cast_out::cast(args_converter.template call<Return>(cap->f),
- policy, call.parent);
-
- /* Invoke call policy post-call hook */
- detail::process_attributes<Extra...>::postcall(call, result);
-
- return result;
- };
-
- /* Process any user-provided function attributes */
- detail::process_attributes<Extra...>::init(extra..., rec);
-
- /* Generate a readable signature describing the function's arguments and return value types */
- using detail::descr; using detail::_;
- PYBIND11_DESCR signature = _("(") + cast_in::arg_names() + _(") -> ") + cast_out::name();
-
- /* Register the function with Python from generic (non-templated) code */
- initialize_generic(rec, signature.text(), signature.types(), sizeof...(Args));
-
- if (cast_in::has_args) rec->has_args = true;
- if (cast_in::has_kwargs) rec->has_kwargs = true;
-
- /* Stash some additional information used by an important optimization in 'functional.h' */
- using FunctionType = Return (*)(Args...);
- constexpr bool is_function_ptr =
- std::is_convertible<Func, FunctionType>::value &&
- sizeof(capture) == sizeof(void *);
- if (is_function_ptr) {
- rec->is_stateless = true;
- rec->data[1] = const_cast<void *>(reinterpret_cast<const void *>(&typeid(FunctionType)));
- }
- }
-
- /// Register a function call with Python (generic non-templated code goes here)
- void initialize_generic(detail::function_record *rec, const char *text,
- const std::type_info *const *types, size_t args) {
-
- /* Create copies of all referenced C-style strings */
- rec->name = strdup(rec->name ? rec->name : "");
- if (rec->doc) rec->doc = strdup(rec->doc);
- for (auto &a: rec->args) {
- if (a.name)
- a.name = strdup(a.name);
- if (a.descr)
- a.descr = strdup(a.descr);
- else if (a.value)
- a.descr = strdup(a.value.attr("__repr__")().cast<std::string>().c_str());
- }
-
- /* Generate a proper function signature */
- std::string signature;
- size_t type_depth = 0, char_index = 0, type_index = 0, arg_index = 0;
- while (true) {
- char c = text[char_index++];
- if (c == '\0')
- break;
-
- if (c == '{') {
- // Write arg name for everything except *args, **kwargs and return type.
- if (type_depth == 0 && text[char_index] != '*' && arg_index < args) {
- if (!rec->args.empty() && rec->args[arg_index].name) {
- signature += rec->args[arg_index].name;
- } else if (arg_index == 0 && rec->is_method) {
- signature += "self";
- } else {
- signature += "arg" + std::to_string(arg_index - (rec->is_method ? 1 : 0));
- }
- signature += ": ";
- }
- ++type_depth;
- } else if (c == '}') {
- --type_depth;
- if (type_depth == 0) {
- if (arg_index < rec->args.size() && rec->args[arg_index].descr) {
- signature += "=";
- signature += rec->args[arg_index].descr;
- }
- arg_index++;
- }
- } else if (c == '%') {
- const std::type_info *t = types[type_index++];
- if (!t)
- pybind11_fail("Internal error while parsing type signature (1)");
- if (auto tinfo = detail::get_type_info(*t)) {
-#if defined(PYPY_VERSION)
- signature += handle((PyObject *) tinfo->type)
- .attr("__module__")
- .cast<std::string>() + ".";
-#endif
- signature += tinfo->type->tp_name;
- } else {
- std::string tname(t->name());
- detail::clean_type_id(tname);
- signature += tname;
- }
- } else {
- signature += c;
- }
- }
- if (type_depth != 0 || types[type_index] != nullptr)
- pybind11_fail("Internal error while parsing type signature (2)");
-
- #if !defined(PYBIND11_CPP14)
- delete[] types;
- delete[] text;
- #endif
-
-#if PY_MAJOR_VERSION < 3
- if (strcmp(rec->name, "__next__") == 0) {
- std::free(rec->name);
- rec->name = strdup("next");
- } else if (strcmp(rec->name, "__bool__") == 0) {
- std::free(rec->name);
- rec->name = strdup("__nonzero__");
- }
-#endif
- rec->signature = strdup(signature.c_str());
- rec->args.shrink_to_fit();
- rec->is_constructor = !strcmp(rec->name, "__init__") || !strcmp(rec->name, "__setstate__");
- rec->nargs = (std::uint16_t) args;
-
-#if PY_MAJOR_VERSION < 3
- if (rec->sibling && PyMethod_Check(rec->sibling.ptr()))
- rec->sibling = PyMethod_GET_FUNCTION(rec->sibling.ptr());
-#endif
-
- detail::function_record *chain = nullptr, *chain_start = rec;
- if (rec->sibling) {
- if (PyCFunction_Check(rec->sibling.ptr())) {
- auto rec_capsule = reinterpret_borrow<capsule>(PyCFunction_GET_SELF(rec->sibling.ptr()));
- chain = (detail::function_record *) rec_capsule;
- /* Never append a method to an overload chain of a parent class;
- instead, hide the parent's overloads in this case */
- if (chain->scope != rec->scope)
- chain = nullptr;
- }
- // Don't trigger for things like the default __init__, which are wrapper_descriptors that we are intentionally replacing
- else if (!rec->sibling.is_none() && rec->name[0] != '_')
- pybind11_fail("Cannot overload existing non-function object \"" + std::string(rec->name) +
- "\" with a function of the same name");
- }
-
- if (!chain) {
- /* No existing overload was found, create a new function object */
- rec->def = new PyMethodDef();
- memset(rec->def, 0, sizeof(PyMethodDef));
- rec->def->ml_name = rec->name;
- rec->def->ml_meth = reinterpret_cast<PyCFunction>(*dispatcher);
- rec->def->ml_flags = METH_VARARGS | METH_KEYWORDS;
-
- capsule rec_capsule(rec, [](void *ptr) {
- destruct((detail::function_record *) ptr);
- });
-
- object scope_module;
- if (rec->scope) {
- if (hasattr(rec->scope, "__module__")) {
- scope_module = rec->scope.attr("__module__");
- } else if (hasattr(rec->scope, "__name__")) {
- scope_module = rec->scope.attr("__name__");
- }
- }
-
- m_ptr = PyCFunction_NewEx(rec->def, rec_capsule.ptr(), scope_module.ptr());
- if (!m_ptr)
- pybind11_fail("cpp_function::cpp_function(): Could not allocate function object");
- } else {
- /* Append at the end of the overload chain */
- m_ptr = rec->sibling.ptr();
- inc_ref();
- chain_start = chain;
- while (chain->next)
- chain = chain->next;
- chain->next = rec;
- }
-
- std::string signatures;
- int index = 0;
- /* Create a nice pydoc rec including all signatures and
- docstrings of the functions in the overload chain */
- if (chain && options::show_function_signatures()) {
- // First a generic signature
- signatures += rec->name;
- signatures += "(*args, **kwargs)\n";
- signatures += "Overloaded function.\n\n";
- }
- // Then specific overload signatures
- bool first_user_def = true;
- for (auto it = chain_start; it != nullptr; it = it->next) {
- if (options::show_function_signatures()) {
- if (index > 0) signatures += "\n";
- if (chain)
- signatures += std::to_string(++index) + ". ";
- signatures += rec->name;
- signatures += it->signature;
- signatures += "\n";
- }
- if (it->doc && strlen(it->doc) > 0 && options::show_user_defined_docstrings()) {
- // If we're appending another docstring, and aren't printing function signatures, we
- // need to append a newline first:
- if (!options::show_function_signatures()) {
- if (first_user_def) first_user_def = false;
- else signatures += "\n";
- }
- if (options::show_function_signatures()) signatures += "\n";
- signatures += it->doc;
- if (options::show_function_signatures()) signatures += "\n";
- }
- }
-
- /* Install docstring */
- PyCFunctionObject *func = (PyCFunctionObject *) m_ptr;
- if (func->m_ml->ml_doc)
- std::free(const_cast<char *>(func->m_ml->ml_doc));
- func->m_ml->ml_doc = strdup(signatures.c_str());
-
- if (rec->is_method) {
- m_ptr = PYBIND11_INSTANCE_METHOD_NEW(m_ptr, rec->scope.ptr());
- if (!m_ptr)
- pybind11_fail("cpp_function::cpp_function(): Could not allocate instance method object");
- Py_DECREF(func);
- }
- }
-
- /// When a cpp_function is GCed, release any memory allocated by pybind11
- static void destruct(detail::function_record *rec) {
- while (rec) {
- detail::function_record *next = rec->next;
- if (rec->free_data)
- rec->free_data(rec);
- std::free((char *) rec->name);
- std::free((char *) rec->doc);
- std::free((char *) rec->signature);
- for (auto &arg: rec->args) {
- std::free(const_cast<char *>(arg.name));
- std::free(const_cast<char *>(arg.descr));
- arg.value.dec_ref();
- }
- if (rec->def) {
- std::free(const_cast<char *>(rec->def->ml_doc));
- delete rec->def;
- }
- delete rec;
- rec = next;
- }
- }
-
- /// Main dispatch logic for calls to functions bound using pybind11
- static PyObject *dispatcher(PyObject *self, PyObject *args_in, PyObject *kwargs_in) {
- using namespace detail;
-
- /* Iterator over the list of potentially admissible overloads */
- function_record *overloads = (function_record *) PyCapsule_GetPointer(self, nullptr),
- *it = overloads;
-
- /* Need to know how many arguments + keyword arguments there are to pick the right overload */
- const size_t n_args_in = (size_t) PyTuple_GET_SIZE(args_in);
-
- handle parent = n_args_in > 0 ? PyTuple_GET_ITEM(args_in, 0) : nullptr,
- result = PYBIND11_TRY_NEXT_OVERLOAD;
-
- try {
- // We do this in two passes: in the first pass, we load arguments with `convert=false`;
- // in the second, we allow conversion (except for arguments with an explicit
- // py::arg().noconvert()). This lets us prefer calls without conversion, with
- // conversion as a fallback.
- std::vector<function_call> second_pass;
-
- // However, if there are no overloads, we can just skip the no-convert pass entirely
- const bool overloaded = it != nullptr && it->next != nullptr;
-
- for (; it != nullptr; it = it->next) {
-
- /* For each overload:
- 1. Copy all positional arguments we were given, also checking to make sure that
- named positional arguments weren't *also* specified via kwarg.
- 2. If we weren't given enough, try to make up the omitted ones by checking
- whether they were provided by a kwarg matching the `py::arg("name")` name. If
- so, use it (and remove it from kwargs; if not, see if the function binding
- provided a default that we can use.
- 3. Ensure that either all keyword arguments were "consumed", or that the function
- takes a kwargs argument to accept unconsumed kwargs.
- 4. Any positional arguments still left get put into a tuple (for args), and any
- leftover kwargs get put into a dict.
- 5. Pack everything into a vector; if we have py::args or py::kwargs, they are an
- extra tuple or dict at the end of the positional arguments.
- 6. Call the function call dispatcher (function_record::impl)
-
- If one of these fail, move on to the next overload and keep trying until we get a
- result other than PYBIND11_TRY_NEXT_OVERLOAD.
- */
-
- function_record &func = *it;
- size_t pos_args = func.nargs; // Number of positional arguments that we need
- if (func.has_args) --pos_args; // (but don't count py::args
- if (func.has_kwargs) --pos_args; // or py::kwargs)
-
- if (!func.has_args && n_args_in > pos_args)
- continue; // Too many arguments for this overload
-
- if (n_args_in < pos_args && func.args.size() < pos_args)
- continue; // Not enough arguments given, and not enough defaults to fill in the blanks
-
- function_call call(func, parent);
-
- size_t args_to_copy = std::min(pos_args, n_args_in);
- size_t args_copied = 0;
-
- // 1. Copy any position arguments given.
- bool bad_kwarg = false;
- for (; args_copied < args_to_copy; ++args_copied) {
- if (kwargs_in && args_copied < func.args.size() && func.args[args_copied].name
- && PyDict_GetItemString(kwargs_in, func.args[args_copied].name)) {
- bad_kwarg = true;
- break;
- }
-
- call.args.push_back(PyTuple_GET_ITEM(args_in, args_copied));
- call.args_convert.push_back(args_copied < func.args.size() ? func.args[args_copied].convert : true);
- }
- if (bad_kwarg)
- continue; // Maybe it was meant for another overload (issue #688)
-
- // We'll need to copy this if we steal some kwargs for defaults
- dict kwargs = reinterpret_borrow<dict>(kwargs_in);
-
- // 2. Check kwargs and, failing that, defaults that may help complete the list
- if (args_copied < pos_args) {
- bool copied_kwargs = false;
-
- for (; args_copied < pos_args; ++args_copied) {
- const auto &arg = func.args[args_copied];
-
- handle value;
- if (kwargs_in && arg.name)
- value = PyDict_GetItemString(kwargs.ptr(), arg.name);
-
- if (value) {
- // Consume a kwargs value
- if (!copied_kwargs) {
- kwargs = reinterpret_steal<dict>(PyDict_Copy(kwargs.ptr()));
- copied_kwargs = true;
- }
- PyDict_DelItemString(kwargs.ptr(), arg.name);
- } else if (arg.value) {
- value = arg.value;
- }
-
- if (value) {
- call.args.push_back(value);
- call.args_convert.push_back(arg.convert);
- }
- else
- break;
- }
-
- if (args_copied < pos_args)
- continue; // Not enough arguments, defaults, or kwargs to fill the positional arguments
- }
-
- // 3. Check everything was consumed (unless we have a kwargs arg)
- if (kwargs && kwargs.size() > 0 && !func.has_kwargs)
- continue; // Unconsumed kwargs, but no py::kwargs argument to accept them
-
- // 4a. If we have a py::args argument, create a new tuple with leftovers
- tuple extra_args;
- if (func.has_args) {
- if (args_to_copy == 0) {
- // We didn't copy out any position arguments from the args_in tuple, so we
- // can reuse it directly without copying:
- extra_args = reinterpret_borrow<tuple>(args_in);
- } else if (args_copied >= n_args_in) {
- extra_args = tuple(0);
- } else {
- size_t args_size = n_args_in - args_copied;
- extra_args = tuple(args_size);
- for (size_t i = 0; i < args_size; ++i) {
- handle item = PyTuple_GET_ITEM(args_in, args_copied + i);
- extra_args[i] = item.inc_ref().ptr();
- }
- }
- call.args.push_back(extra_args);
- call.args_convert.push_back(false);
- }
-
- // 4b. If we have a py::kwargs, pass on any remaining kwargs
- if (func.has_kwargs) {
- if (!kwargs.ptr())
- kwargs = dict(); // If we didn't get one, send an empty one
- call.args.push_back(kwargs);
- call.args_convert.push_back(false);
- }
-
- // 5. Put everything in a vector. Not technically step 5, we've been building it
- // in `call.args` all along.
- #if !defined(NDEBUG)
- if (call.args.size() != func.nargs || call.args_convert.size() != func.nargs)
- pybind11_fail("Internal error: function call dispatcher inserted wrong number of arguments!");
- #endif
-
- std::vector<bool> second_pass_convert;
- if (overloaded) {
- // We're in the first no-convert pass, so swap out the conversion flags for a
- // set of all-false flags. If the call fails, we'll swap the flags back in for
- // the conversion-allowed call below.
- second_pass_convert.resize(func.nargs, false);
- call.args_convert.swap(second_pass_convert);
- }
-
- // 6. Call the function.
- try {
- result = func.impl(call);
- } catch (reference_cast_error &) {
- result = PYBIND11_TRY_NEXT_OVERLOAD;
- }
-
- if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD)
- break;
-
- if (overloaded) {
- // The (overloaded) call failed; if the call has at least one argument that
- // permits conversion (i.e. it hasn't been explicitly specified `.noconvert()`)
- // then add this call to the list of second pass overloads to try.
- for (size_t i = func.is_method ? 1 : 0; i < pos_args; i++) {
- if (second_pass_convert[i]) {
- // Found one: swap the converting flags back in and store the call for
- // the second pass.
- call.args_convert.swap(second_pass_convert);
- second_pass.push_back(std::move(call));
- break;
- }
- }
- }
- }
-
- if (overloaded && !second_pass.empty() && result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) {
- // The no-conversion pass finished without success, try again with conversion allowed
- for (auto &call : second_pass) {
- try {
- result = call.func.impl(call);
- } catch (reference_cast_error &) {
- result = PYBIND11_TRY_NEXT_OVERLOAD;
- }
-
- if (result.ptr() != PYBIND11_TRY_NEXT_OVERLOAD)
- break;
- }
- }
- } catch (error_already_set &e) {
- e.restore();
- return nullptr;
- } catch (...) {
- /* When an exception is caught, give each registered exception
- translator a chance to translate it to a Python exception
- in reverse order of registration.
-
- A translator may choose to do one of the following:
-
- - catch the exception and call PyErr_SetString or PyErr_SetObject
- to set a standard (or custom) Python exception, or
- - do nothing and let the exception fall through to the next translator, or
- - delegate translation to the next translator by throwing a new type of exception. */
-
- auto last_exception = std::current_exception();
- auto ®istered_exception_translators = get_internals().registered_exception_translators;
- for (auto& translator : registered_exception_translators) {
- try {
- translator(last_exception);
- } catch (...) {
- last_exception = std::current_exception();
- continue;
- }
- return nullptr;
- }
- PyErr_SetString(PyExc_SystemError, "Exception escaped from default exception translator!");
- return nullptr;
- }
-
- if (result.ptr() == PYBIND11_TRY_NEXT_OVERLOAD) {
- if (overloads->is_operator)
- return handle(Py_NotImplemented).inc_ref().ptr();
-
- std::string msg = std::string(overloads->name) + "(): incompatible " +
- std::string(overloads->is_constructor ? "constructor" : "function") +
- " arguments. The following argument types are supported:\n";
-
- int ctr = 0;
- for (function_record *it2 = overloads; it2 != nullptr; it2 = it2->next) {
- msg += " "+ std::to_string(++ctr) + ". ";
-
- bool wrote_sig = false;
- if (overloads->is_constructor) {
- // For a constructor, rewrite `(self: Object, arg0, ...) -> NoneType` as `Object(arg0, ...)`
- std::string sig = it2->signature;
- size_t start = sig.find('(') + 7; // skip "(self: "
- if (start < sig.size()) {
- // End at the , for the next argument
- size_t end = sig.find(", "), next = end + 2;
- size_t ret = sig.rfind(" -> ");
- // Or the ), if there is no comma:
- if (end >= sig.size()) next = end = sig.find(')');
- if (start < end && next < sig.size()) {
- msg.append(sig, start, end - start);
- msg += '(';
- msg.append(sig, next, ret - next);
- wrote_sig = true;
- }
- }
- }
- if (!wrote_sig) msg += it2->signature;
-
- msg += "\n";
- }
- msg += "\nInvoked with: ";
- auto args_ = reinterpret_borrow<tuple>(args_in);
- bool some_args = false;
- for (size_t ti = overloads->is_constructor ? 1 : 0; ti < args_.size(); ++ti) {
- if (!some_args) some_args = true;
- else msg += ", ";
- msg += pybind11::repr(args_[ti]);
- }
- if (kwargs_in) {
- auto kwargs = reinterpret_borrow<dict>(kwargs_in);
- if (kwargs.size() > 0) {
- if (some_args) msg += "; ";
- msg += "kwargs: ";
- bool first = true;
- for (auto kwarg : kwargs) {
- if (first) first = false;
- else msg += ", ";
- msg += pybind11::str("{}={!r}").format(kwarg.first, kwarg.second);
- }
- }
- }
-
- PyErr_SetString(PyExc_TypeError, msg.c_str());
- return nullptr;
- } else if (!result) {
- std::string msg = "Unable to convert function return value to a "
- "Python type! The signature was\n\t";
- msg += it->signature;
- PyErr_SetString(PyExc_TypeError, msg.c_str());
- return nullptr;
- } else {
- if (overloads->is_constructor) {
- /* When a constructor ran successfully, the corresponding
- holder type (e.g. std::unique_ptr) must still be initialized. */
- auto tinfo = get_type_info(Py_TYPE(parent.ptr()));
- tinfo->init_holder(parent.ptr(), nullptr);
- }
- return result.ptr();
- }
- }
-};
-
-/// Wrapper for Python extension modules
-class module : public object {
-public:
- PYBIND11_OBJECT_DEFAULT(module, object, PyModule_Check)
-
- /// Create a new top-level Python module with the given name and docstring
- explicit module(const char *name, const char *doc = nullptr) {
- if (!options::show_user_defined_docstrings()) doc = nullptr;
-#if PY_MAJOR_VERSION >= 3
- PyModuleDef *def = new PyModuleDef();
- memset(def, 0, sizeof(PyModuleDef));
- def->m_name = name;
- def->m_doc = doc;
- def->m_size = -1;
- Py_INCREF(def);
- m_ptr = PyModule_Create(def);
-#else
- m_ptr = Py_InitModule3(name, nullptr, doc);
-#endif
- if (m_ptr == nullptr)
- pybind11_fail("Internal error in module::module()");
- inc_ref();
- }
-
- /** \rst
- Create Python binding for a new function within the module scope. ``Func``
- can be a plain C++ function, a function pointer, or a lambda function. For
- details on the ``Extra&& ... extra`` argument, see section :ref:`extras`.
- \endrst */
- template <typename Func, typename... Extra>
- module &def(const char *name_, Func &&f, const Extra& ... extra) {
- cpp_function func(std::forward<Func>(f), name(name_), scope(*this),
- sibling(getattr(*this, name_, none())), extra...);
- // NB: allow overwriting here because cpp_function sets up a chain with the intention of
- // overwriting (and has already checked internally that it isn't overwriting non-functions).
- add_object(name_, func, true /* overwrite */);
- return *this;
- }
-
- /** \rst
- Create and return a new Python submodule with the given name and docstring.
- This also works recursively, i.e.
-
- .. code-block:: cpp
-
- py::module m("example", "pybind11 example plugin");
- py::module m2 = m.def_submodule("sub", "A submodule of 'example'");
- py::module m3 = m2.def_submodule("subsub", "A submodule of 'example.sub'");
- \endrst */
- module def_submodule(const char *name, const char *doc = nullptr) {
- std::string full_name = std::string(PyModule_GetName(m_ptr))
- + std::string(".") + std::string(name);
- auto result = reinterpret_borrow<module>(PyImport_AddModule(full_name.c_str()));
- if (doc && options::show_user_defined_docstrings())
- result.attr("__doc__") = pybind11::str(doc);
- attr(name) = result;
- return result;
- }
-
- /// Import and return a module or throws `error_already_set`.
- static module import(const char *name) {
- PyObject *obj = PyImport_ImportModule(name);
- if (!obj)
- throw error_already_set();
- return reinterpret_steal<module>(obj);
- }
-
- // Adds an object to the module using the given name. Throws if an object with the given name
- // already exists.
- //
- // overwrite should almost always be false: attempting to overwrite objects that pybind11 has
- // established will, in most cases, break things.
- PYBIND11_NOINLINE void add_object(const char *name, object &obj, bool overwrite = false) {
- if (!overwrite && hasattr(*this, name))
- pybind11_fail("Error during initialization: multiple incompatible definitions with name \"" +
- std::string(name) + "\"");
-
- obj.inc_ref(); // PyModule_AddObject() steals a reference
- PyModule_AddObject(ptr(), name, obj.ptr());
- }
-};
-
-NAMESPACE_BEGIN(detail)
-/// Generic support for creating new Python heap types
-class generic_type : public object {
- template <typename...> friend class class_;
-public:
- PYBIND11_OBJECT_DEFAULT(generic_type, object, PyType_Check)
-protected:
- void initialize(const type_record &rec) {
- if (rec.scope && hasattr(rec.scope, rec.name))
- pybind11_fail("generic_type: cannot initialize type \"" + std::string(rec.name) +
- "\": an object with that name is already defined");
-
- if (get_type_info(*rec.type))
- pybind11_fail("generic_type: type \"" + std::string(rec.name) +
- "\" is already registered!");
-
- m_ptr = make_new_python_type(rec);
-
- /* Register supplemental type information in C++ dict */
- auto *tinfo = new detail::type_info();
- tinfo->type = (PyTypeObject *) m_ptr;
- tinfo->type_size = rec.type_size;
- tinfo->operator_new = rec.operator_new;
- tinfo->init_holder = rec.init_holder;
- tinfo->dealloc = rec.dealloc;
-
- auto &internals = get_internals();
- auto tindex = std::type_index(*rec.type);
- tinfo->direct_conversions = &internals.direct_conversions[tindex];
- tinfo->default_holder = rec.default_holder;
- internals.registered_types_cpp[tindex] = tinfo;
- internals.registered_types_py[m_ptr] = tinfo;
-
- if (rec.bases.size() > 1 || rec.multiple_inheritance)
- mark_parents_nonsimple(tinfo->type);
- }
-
- /// Helper function which tags all parents of a type using mult. inheritance
- void mark_parents_nonsimple(PyTypeObject *value) {
- auto t = reinterpret_borrow<tuple>(value->tp_bases);
- for (handle h : t) {
- auto tinfo2 = get_type_info((PyTypeObject *) h.ptr());
- if (tinfo2)
- tinfo2->simple_type = false;
- mark_parents_nonsimple((PyTypeObject *) h.ptr());
- }
- }
-
- void install_buffer_funcs(
- buffer_info *(*get_buffer)(PyObject *, void *),
- void *get_buffer_data) {
- PyHeapTypeObject *type = (PyHeapTypeObject*) m_ptr;
- auto tinfo = detail::get_type_info(&type->ht_type);
-
- if (!type->ht_type.tp_as_buffer)
- pybind11_fail(
- "To be able to register buffer protocol support for the type '" +
- std::string(tinfo->type->tp_name) +
- "' the associated class<>(..) invocation must "
- "include the pybind11::buffer_protocol() annotation!");
-
- tinfo->get_buffer = get_buffer;
- tinfo->get_buffer_data = get_buffer_data;
- }
-
- void def_property_static_impl(const char *name,
- handle fget, handle fset,
- detail::function_record *rec_fget) {
- const auto is_static = !(rec_fget->is_method && rec_fget->scope);
- const auto has_doc = rec_fget->doc && pybind11::options::show_user_defined_docstrings();
-
- auto property = handle((PyObject *) (is_static ? get_internals().static_property_type
- : &PyProperty_Type));
- attr(name) = property(fget.ptr() ? fget : none(),
- fset.ptr() ? fset : none(),
- /*deleter*/none(),
- pybind11::str(has_doc ? rec_fget->doc : ""));
- }
-};
-
-/// Set the pointer to operator new if it exists. The cast is needed because it can be overloaded.
-template <typename T, typename = void_t<decltype(static_cast<void *(*)(size_t)>(T::operator new))>>
-void set_operator_new(type_record *r) { r->operator_new = &T::operator new; }
-
-template <typename> void set_operator_new(...) { }
-
-/// Call class-specific delete if it exists or global otherwise. Can also be an overload set.
-template <typename T, typename = void_t<decltype(static_cast<void (*)(void *)>(T::operator delete))>>
-void call_operator_delete(T *p) { T::operator delete(p); }
-
-inline void call_operator_delete(void *p) { ::operator delete(p); }
-
-NAMESPACE_END(detail)
-
-template <typename type_, typename... options>
-class class_ : public detail::generic_type {
- template <typename T> using is_holder = detail::is_holder_type<type_, T>;
- template <typename T> using is_subtype = detail::bool_constant<std::is_base_of<type_, T>::value && !std::is_same<T, type_>::value>;
- template <typename T> using is_base = detail::bool_constant<std::is_base_of<T, type_>::value && !std::is_same<T, type_>::value>;
- // struct instead of using here to help MSVC:
- template <typename T> struct is_valid_class_option :
- detail::any_of<is_holder<T>, is_subtype<T>, is_base<T>> {};
-
-public:
- using type = type_;
- using type_alias = detail::first_of_t<is_subtype, void, options...>;
- constexpr static bool has_alias = !std::is_void<type_alias>::value;
- using holder_type = detail::first_of_t<is_holder, std::unique_ptr<type>, options...>;
- using instance_type = detail::instance<type, holder_type>;
-
- static_assert(detail::all_of<is_valid_class_option<options>...>::value,
- "Unknown/invalid class_ template parameters provided");
-
- PYBIND11_OBJECT(class_, generic_type, PyType_Check)
-
- template <typename... Extra>
- class_(handle scope, const char *name, const Extra &... extra) {
- using namespace detail;
-
- // MI can only be specified via class_ template options, not constructor parameters
- static_assert(
- none_of<is_pyobject<Extra>...>::value || // no base class arguments, or:
- ( constexpr_sum(is_pyobject<Extra>::value...) == 1 && // Exactly one base
- constexpr_sum(is_base<options>::value...) == 0 && // no template option bases
- none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
- "Error: multiple inheritance bases must be specified via class_ template options");
-
- type_record record;
- record.scope = scope;
- record.name = name;
- record.type = &typeid(type);
- record.type_size = sizeof(conditional_t<has_alias, type_alias, type>);
- record.instance_size = sizeof(instance_type);
- record.init_holder = init_holder;
- record.dealloc = dealloc;
- record.default_holder = std::is_same<holder_type, std::unique_ptr<type>>::value;
-
- set_operator_new<type>(&record);
-
- /* Register base classes specified via template arguments to class_, if any */
- bool unused[] = { (add_base<options>(record), false)..., false };
- (void) unused;
-
- /* Process optional arguments, if any */
- process_attributes<Extra...>::init(extra..., &record);
-
- generic_type::initialize(record);
-
- if (has_alias) {
- auto &instances = get_internals().registered_types_cpp;
- instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))];
- }
- }
-
- template <typename Base, detail::enable_if_t<is_base<Base>::value, int> = 0>
- static void add_base(detail::type_record &rec) {
- rec.add_base(&typeid(Base), [](void *src) -> void * {
- return static_cast<Base *>(reinterpret_cast<type *>(src));
- });
- }
-
- template <typename Base, detail::enable_if_t<!is_base<Base>::value, int> = 0>
- static void add_base(detail::type_record &) { }
-
- template <typename Func, typename... Extra>
- class_ &def(const char *name_, Func&& f, const Extra&... extra) {
- cpp_function cf(std::forward<Func>(f), name(name_), is_method(*this),
- sibling(getattr(*this, name_, none())), extra...);
- attr(cf.name()) = cf;
- return *this;
- }
-
- template <typename Func, typename... Extra> class_ &
- def_static(const char *name_, Func &&f, const Extra&... extra) {
- static_assert(!std::is_member_function_pointer<Func>::value,
- "def_static(...) called with a non-static member function pointer");
- cpp_function cf(std::forward<Func>(f), name(name_), scope(*this),
- sibling(getattr(*this, name_, none())), extra...);
- attr(cf.name()) = cf;
- return *this;
- }
-
- template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
- class_ &def(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
- op.execute(*this, extra...);
- return *this;
- }
-
- template <detail::op_id id, detail::op_type ot, typename L, typename R, typename... Extra>
- class_ & def_cast(const detail::op_<id, ot, L, R> &op, const Extra&... extra) {
- op.execute_cast(*this, extra...);
- return *this;
- }
-
- template <typename... Args, typename... Extra>
- class_ &def(const detail::init<Args...> &init, const Extra&... extra) {
- init.execute(*this, extra...);
- return *this;
- }
-
- template <typename... Args, typename... Extra>
- class_ &def(const detail::init_alias<Args...> &init, const Extra&... extra) {
- init.execute(*this, extra...);
- return *this;
- }
-
- template <typename Func> class_& def_buffer(Func &&func) {
- struct capture { Func func; };
- capture *ptr = new capture { std::forward<Func>(func) };
- install_buffer_funcs([](PyObject *obj, void *ptr) -> buffer_info* {
- detail::make_caster<type> caster;
- if (!caster.load(obj, false))
- return nullptr;
- return new buffer_info(((capture *) ptr)->func(caster));
- }, ptr);
- return *this;
- }
-
- template <typename C, typename D, typename... Extra>
- class_ &def_readwrite(const char *name, D C::*pm, const Extra&... extra) {
- cpp_function fget([pm](const C &c) -> const D &{ return c.*pm; }, is_method(*this)),
- fset([pm](C &c, const D &value) { c.*pm = value; }, is_method(*this));
- def_property(name, fget, fset, return_value_policy::reference_internal, extra...);
- return *this;
- }
-
- template <typename C, typename D, typename... Extra>
- class_ &def_readonly(const char *name, const D C::*pm, const Extra& ...extra) {
- cpp_function fget([pm](const C &c) -> const D &{ return c.*pm; }, is_method(*this));
- def_property_readonly(name, fget, return_value_policy::reference_internal, extra...);
- return *this;
- }
-
- template <typename D, typename... Extra>
- class_ &def_readwrite_static(const char *name, D *pm, const Extra& ...extra) {
- cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this)),
- fset([pm](object, const D &value) { *pm = value; }, scope(*this));
- def_property_static(name, fget, fset, return_value_policy::reference, extra...);
- return *this;
- }
-
- template <typename D, typename... Extra>
- class_ &def_readonly_static(const char *name, const D *pm, const Extra& ...extra) {
- cpp_function fget([pm](object) -> const D &{ return *pm; }, scope(*this));
- def_property_readonly_static(name, fget, return_value_policy::reference, extra...);
- return *this;
- }
-
- /// Uses return_value_policy::reference_internal by default
- template <typename Getter, typename... Extra>
- class_ &def_property_readonly(const char *name, const Getter &fget, const Extra& ...extra) {
- return def_property_readonly(name, cpp_function(fget), return_value_policy::reference_internal, extra...);
- }
-
- /// Uses cpp_function's return_value_policy by default
- template <typename... Extra>
- class_ &def_property_readonly(const char *name, const cpp_function &fget, const Extra& ...extra) {
- return def_property(name, fget, cpp_function(), extra...);
- }
-
- /// Uses return_value_policy::reference by default
- template <typename Getter, typename... Extra>
- class_ &def_property_readonly_static(const char *name, const Getter &fget, const Extra& ...extra) {
- return def_property_readonly_static(name, cpp_function(fget), return_value_policy::reference, extra...);
- }
-
- /// Uses cpp_function's return_value_policy by default
- template <typename... Extra>
- class_ &def_property_readonly_static(const char *name, const cpp_function &fget, const Extra& ...extra) {
- return def_property_static(name, fget, cpp_function(), extra...);
- }
-
- /// Uses return_value_policy::reference_internal by default
- template <typename Getter, typename... Extra>
- class_ &def_property(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
- return def_property(name, cpp_function(fget), fset, return_value_policy::reference_internal, extra...);
- }
-
- /// Uses cpp_function's return_value_policy by default
- template <typename... Extra>
- class_ &def_property(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
- return def_property_static(name, fget, fset, is_method(*this), extra...);
- }
-
- /// Uses return_value_policy::reference by default
- template <typename Getter, typename... Extra>
- class_ &def_property_static(const char *name, const Getter &fget, const cpp_function &fset, const Extra& ...extra) {
- return def_property_static(name, cpp_function(fget), fset, return_value_policy::reference, extra...);
- }
-
- /// Uses cpp_function's return_value_policy by default
- template <typename... Extra>
- class_ &def_property_static(const char *name, const cpp_function &fget, const cpp_function &fset, const Extra& ...extra) {
- auto rec_fget = get_function_record(fget), rec_fset = get_function_record(fset);
- char *doc_prev = rec_fget->doc; /* 'extra' field may include a property-specific documentation string */
- detail::process_attributes<Extra...>::init(extra..., rec_fget);
- if (rec_fget->doc && rec_fget->doc != doc_prev) {
- free(doc_prev);
- rec_fget->doc = strdup(rec_fget->doc);
- }
- if (rec_fset) {
- doc_prev = rec_fset->doc;
- detail::process_attributes<Extra...>::init(extra..., rec_fset);
- if (rec_fset->doc && rec_fset->doc != doc_prev) {
- free(doc_prev);
- rec_fset->doc = strdup(rec_fset->doc);
- }
- }
- def_property_static_impl(name, fget, fset, rec_fget);
- return *this;
- }
-
-private:
- /// Initialize holder object, variant 1: object derives from enable_shared_from_this
- template <typename T>
- static void init_holder_helper(instance_type *inst, const holder_type * /* unused */, const std::enable_shared_from_this<T> * /* dummy */) {
- try {
- new (&inst->holder) holder_type(std::static_pointer_cast<typename holder_type::element_type>(inst->value->shared_from_this()));
- inst->holder_constructed = true;
- } catch (const std::bad_weak_ptr &) {
- if (inst->owned) {
- new (&inst->holder) holder_type(inst->value);
- inst->holder_constructed = true;
- }
- }
- }
-
- static void init_holder_from_existing(instance_type *inst, const holder_type *holder_ptr,
- std::true_type /*is_copy_constructible*/) {
- new (&inst->holder) holder_type(*holder_ptr);
- }
-
- static void init_holder_from_existing(instance_type *inst, const holder_type *holder_ptr,
- std::false_type /*is_copy_constructible*/) {
- new (&inst->holder) holder_type(std::move(*const_cast<holder_type *>(holder_ptr)));
- }
-
- /// Initialize holder object, variant 2: try to construct from existing holder object, if possible
- static void init_holder_helper(instance_type *inst, const holder_type *holder_ptr, const void * /* dummy */) {
- if (holder_ptr) {
- init_holder_from_existing(inst, holder_ptr, std::is_copy_constructible<holder_type>());
- inst->holder_constructed = true;
- } else if (inst->owned || detail::always_construct_holder<holder_type>::value) {
- new (&inst->holder) holder_type(inst->value);
- inst->holder_constructed = true;
- }
- }
-
- /// Initialize holder object of an instance, possibly given a pointer to an existing holder
- static void init_holder(PyObject *inst_, const void *holder_ptr) {
- auto inst = (instance_type *) inst_;
- init_holder_helper(inst, (const holder_type *) holder_ptr, inst->value);
- }
-
- static void dealloc(PyObject *inst_) {
- instance_type *inst = (instance_type *) inst_;
- if (inst->holder_constructed)
- inst->holder.~holder_type();
- else if (inst->owned)
- detail::call_operator_delete(inst->value);
- }
-
- static detail::function_record *get_function_record(handle h) {
- h = detail::get_function(h);
- return h ? (detail::function_record *) reinterpret_borrow<capsule>(PyCFunction_GET_SELF(h.ptr()))
- : nullptr;
- }
-};
-
-/// Binds C++ enumerations and enumeration classes to Python
-template <typename Type> class enum_ : public class_<Type> {
-public:
- using class_<Type>::def;
- using class_<Type>::def_property_readonly_static;
- using Scalar = typename std::underlying_type<Type>::type;
- template <typename T> using arithmetic_tag = std::is_same<T, arithmetic>;
-
- template <typename... Extra>
- enum_(const handle &scope, const char *name, const Extra&... extra)
- : class_<Type>(scope, name, extra...), m_entries(), m_parent(scope) {
-
- constexpr bool is_arithmetic =
- !std::is_same<detail::first_of_t<arithmetic_tag, void, Extra...>,
- void>::value;
-
- auto m_entries_ptr = m_entries.inc_ref().ptr();
- def("__repr__", [name, m_entries_ptr](Type value) -> pybind11::str {
- for (const auto &kv : reinterpret_borrow<dict>(m_entries_ptr)) {
- if (pybind11::cast<Type>(kv.second) == value)
- return pybind11::str("{}.{}").format(name, kv.first);
- }
- return pybind11::str("{}.???").format(name);
- });
- def_property_readonly_static("__members__", [m_entries_ptr](object /* self */) {
- dict m;
- for (const auto &kv : reinterpret_borrow<dict>(m_entries_ptr))
- m[kv.first] = kv.second;
- return m;
- }, return_value_policy::copy);
- def("__init__", [](Type& value, Scalar i) { value = (Type)i; });
- def("__int__", [](Type value) { return (Scalar) value; });
- def("__eq__", [](const Type &value, Type *value2) { return value2 && value == *value2; });
- def("__ne__", [](const Type &value, Type *value2) { return !value2 || value != *value2; });
- if (is_arithmetic) {
- def("__lt__", [](const Type &value, Type *value2) { return value2 && value < *value2; });
- def("__gt__", [](const Type &value, Type *value2) { return value2 && value > *value2; });
- def("__le__", [](const Type &value, Type *value2) { return value2 && value <= *value2; });
- def("__ge__", [](const Type &value, Type *value2) { return value2 && value >= *value2; });
- }
- if (std::is_convertible<Type, Scalar>::value) {
- // Don't provide comparison with the underlying type if the enum isn't convertible,
- // i.e. if Type is a scoped enum, mirroring the C++ behaviour. (NB: we explicitly
- // convert Type to Scalar below anyway because this needs to compile).
- def("__eq__", [](const Type &value, Scalar value2) { return (Scalar) value == value2; });
- def("__ne__", [](const Type &value, Scalar value2) { return (Scalar) value != value2; });
- if (is_arithmetic) {
- def("__lt__", [](const Type &value, Scalar value2) { return (Scalar) value < value2; });
- def("__gt__", [](const Type &value, Scalar value2) { return (Scalar) value > value2; });
- def("__le__", [](const Type &value, Scalar value2) { return (Scalar) value <= value2; });
- def("__ge__", [](const Type &value, Scalar value2) { return (Scalar) value >= value2; });
- def("__invert__", [](const Type &value) { return ~((Scalar) value); });
- def("__and__", [](const Type &value, Scalar value2) { return (Scalar) value & value2; });
- def("__or__", [](const Type &value, Scalar value2) { return (Scalar) value | value2; });
- def("__xor__", [](const Type &value, Scalar value2) { return (Scalar) value ^ value2; });
- def("__rand__", [](const Type &value, Scalar value2) { return (Scalar) value & value2; });
- def("__ror__", [](const Type &value, Scalar value2) { return (Scalar) value | value2; });
- def("__rxor__", [](const Type &value, Scalar value2) { return (Scalar) value ^ value2; });
- def("__and__", [](const Type &value, const Type &value2) { return (Scalar) value & (Scalar) value2; });
- def("__or__", [](const Type &value, const Type &value2) { return (Scalar) value | (Scalar) value2; });
- def("__xor__", [](const Type &value, const Type &value2) { return (Scalar) value ^ (Scalar) value2; });
- }
- }
- def("__hash__", [](const Type &value) { return (Scalar) value; });
- // Pickling and unpickling -- needed for use with the 'multiprocessing' module
- def("__getstate__", [](const Type &value) { return pybind11::make_tuple((Scalar) value); });
- def("__setstate__", [](Type &p, tuple t) { new (&p) Type((Type) t[0].cast<Scalar>()); });
- }
-
- /// Export enumeration entries into the parent scope
- enum_& export_values() {
- for (const auto &kv : m_entries)
- m_parent.attr(kv.first) = kv.second;
- return *this;
- }
-
- /// Add an enumeration entry
- enum_& value(char const* name, Type value) {
- auto v = pybind11::cast(value, return_value_policy::copy);
- this->attr(name) = v;
- m_entries[pybind11::str(name)] = v;
- return *this;
- }
-
-private:
- dict m_entries;
- handle m_parent;
-};
-
-NAMESPACE_BEGIN(detail)
-template <typename... Args> struct init {
- template <typename Class, typename... Extra, enable_if_t<!Class::has_alias, int> = 0>
- static void execute(Class &cl, const Extra&... extra) {
- using Base = typename Class::type;
- /// Function which calls a specific C++ in-place constructor
- cl.def("__init__", [](Base *self_, Args... args) { new (self_) Base(args...); }, extra...);
- }
-
- template <typename Class, typename... Extra,
- enable_if_t<Class::has_alias &&
- std::is_constructible<typename Class::type, Args...>::value, int> = 0>
- static void execute(Class &cl, const Extra&... extra) {
- using Base = typename Class::type;
- using Alias = typename Class::type_alias;
- handle cl_type = cl;
- cl.def("__init__", [cl_type](handle self_, Args... args) {
- if (self_.get_type() == cl_type)
- new (self_.cast<Base *>()) Base(args...);
- else
- new (self_.cast<Alias *>()) Alias(args...);
- }, extra...);
- }
-
- template <typename Class, typename... Extra,
- enable_if_t<Class::has_alias &&
- !std::is_constructible<typename Class::type, Args...>::value, int> = 0>
- static void execute(Class &cl, const Extra&... extra) {
- init_alias<Args...>::execute(cl, extra...);
- }
-};
-template <typename... Args> struct init_alias {
- template <typename Class, typename... Extra,
- enable_if_t<Class::has_alias && std::is_constructible<typename Class::type_alias, Args...>::value, int> = 0>
- static void execute(Class &cl, const Extra&... extra) {
- using Alias = typename Class::type_alias;
- cl.def("__init__", [](Alias *self_, Args... args) { new (self_) Alias(args...); }, extra...);
- }
-};
-
-
-inline void keep_alive_impl(handle nurse, handle patient) {
- /* Clever approach based on weak references taken from Boost.Python */
- if (!nurse || !patient)
- pybind11_fail("Could not activate keep_alive!");
-
- if (patient.is_none() || nurse.is_none())
- return; /* Nothing to keep alive or nothing to be kept alive by */
-
- cpp_function disable_lifesupport(
- [patient](handle weakref) { patient.dec_ref(); weakref.dec_ref(); });
-
- weakref wr(nurse, disable_lifesupport);
-
- patient.inc_ref(); /* reference patient and leak the weak reference */
- (void) wr.release();
-}
-
-PYBIND11_NOINLINE inline void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret) {
- keep_alive_impl(
- Nurse == 0 ? ret : Nurse <= call.args.size() ? call.args[Nurse - 1] : handle(),
- Patient == 0 ? ret : Patient <= call.args.size() ? call.args[Patient - 1] : handle()
- );
-}
-
-template <typename Iterator, typename Sentinel, bool KeyIterator, return_value_policy Policy>
-struct iterator_state {
- Iterator it;
- Sentinel end;
- bool first;
-};
-
-NAMESPACE_END(detail)
-
-template <typename... Args> detail::init<Args...> init() { return detail::init<Args...>(); }
-template <typename... Args> detail::init_alias<Args...> init_alias() { return detail::init_alias<Args...>(); }
-
-/// Makes a python iterator from a first and past-the-end C++ InputIterator.
-template <return_value_policy Policy = return_value_policy::reference_internal,
- typename Iterator,
- typename Sentinel,
- typename ValueType = decltype(*std::declval<Iterator>()),
- typename... Extra>
-iterator make_iterator(Iterator first, Sentinel last, Extra &&... extra) {
- typedef detail::iterator_state<Iterator, Sentinel, false, Policy> state;
-
- if (!detail::get_type_info(typeid(state), false)) {
- class_<state>(handle(), "iterator")
- .def("__iter__", [](state &s) -> state& { return s; })
- .def("__next__", [](state &s) -> ValueType {
- if (!s.first)
- ++s.it;
- else
- s.first = false;
- if (s.it == s.end)
- throw stop_iteration();
- return *s.it;
- }, std::forward<Extra>(extra)..., Policy);
- }
-
- return (iterator) cast(state { first, last, true });
-}
-
-/// Makes an python iterator over the keys (`.first`) of a iterator over pairs from a
-/// first and past-the-end InputIterator.
-template <return_value_policy Policy = return_value_policy::reference_internal,
- typename Iterator,
- typename Sentinel,
- typename KeyType = decltype((*std::declval<Iterator>()).first),
- typename... Extra>
-iterator make_key_iterator(Iterator first, Sentinel last, Extra &&... extra) {
- typedef detail::iterator_state<Iterator, Sentinel, true, Policy> state;
-
- if (!detail::get_type_info(typeid(state), false)) {
- class_<state>(handle(), "iterator")
- .def("__iter__", [](state &s) -> state& { return s; })
- .def("__next__", [](state &s) -> KeyType {
- if (!s.first)
- ++s.it;
- else
- s.first = false;
- if (s.it == s.end)
- throw stop_iteration();
- return (*s.it).first;
- }, std::forward<Extra>(extra)..., Policy);
- }
-
- return (iterator) cast(state { first, last, true });
-}
-
-/// Makes an iterator over values of an stl container or other container supporting
-/// `std::begin()`/`std::end()`
-template <return_value_policy Policy = return_value_policy::reference_internal,
- typename Type, typename... Extra> iterator make_iterator(Type &value, Extra&&... extra) {
- return make_iterator<Policy>(std::begin(value), std::end(value), extra...);
-}
-
-/// Makes an iterator over the keys (`.first`) of a stl map-like container supporting
-/// `std::begin()`/`std::end()`
-template <return_value_policy Policy = return_value_policy::reference_internal,
- typename Type, typename... Extra> iterator make_key_iterator(Type &value, Extra&&... extra) {
- return make_key_iterator<Policy>(std::begin(value), std::end(value), extra...);
-}
-
-template <typename InputType, typename OutputType> void implicitly_convertible() {
- auto implicit_caster = [](PyObject *obj, PyTypeObject *type) -> PyObject * {
- if (!detail::make_caster<InputType>().load(obj, false))
- return nullptr;
- tuple args(1);
- args[0] = obj;
- PyObject *result = PyObject_Call((PyObject *) type, args.ptr(), nullptr);
- if (result == nullptr)
- PyErr_Clear();
- return result;
- };
-
- if (auto tinfo = detail::get_type_info(typeid(OutputType)))
- tinfo->implicit_conversions.push_back(implicit_caster);
- else
- pybind11_fail("implicitly_convertible: Unable to find type " + type_id<OutputType>());
-}
-
-template <typename ExceptionTranslator>
-void register_exception_translator(ExceptionTranslator&& translator) {
- detail::get_internals().registered_exception_translators.push_front(
- std::forward<ExceptionTranslator>(translator));
-}
-
-/* Wrapper to generate a new Python exception type.
- *
- * This should only be used with PyErr_SetString for now.
- * It is not (yet) possible to use as a py::base.
- * Template type argument is reserved for future use.
- */
-template <typename type>
-class exception : public object {
-public:
- exception(handle scope, const char *name, PyObject *base = PyExc_Exception) {
- std::string full_name = scope.attr("__name__").cast<std::string>() +
- std::string(".") + name;
- m_ptr = PyErr_NewException(const_cast<char *>(full_name.c_str()), base, NULL);
- if (hasattr(scope, name))
- pybind11_fail("Error during initialization: multiple incompatible "
- "definitions with name \"" + std::string(name) + "\"");
- scope.attr(name) = *this;
- }
-
- // Sets the current python exception to this exception object with the given message
- void operator()(const char *message) {
- PyErr_SetString(m_ptr, message);
- }
-};
-
-/** Registers a Python exception in `m` of the given `name` and installs an exception translator to
- * translate the C++ exception to the created Python exception using the exceptions what() method.
- * This is intended for simple exception translations; for more complex translation, register the
- * exception object and translator directly.
- */
-template <typename CppException>
-exception<CppException> ®ister_exception(handle scope,
- const char *name,
- PyObject *base = PyExc_Exception) {
- static exception<CppException> ex(scope, name, base);
- register_exception_translator([](std::exception_ptr p) {
- if (!p) return;
- try {
- std::rethrow_exception(p);
- } catch (const CppException &e) {
- ex(e.what());
- }
- });
- return ex;
-}
-
-NAMESPACE_BEGIN(detail)
-PYBIND11_NOINLINE inline void print(tuple args, dict kwargs) {
- auto strings = tuple(args.size());
- for (size_t i = 0; i < args.size(); ++i) {
- strings[i] = str(args[i]);
- }
- auto sep = kwargs.contains("sep") ? kwargs["sep"] : cast(" ");
- auto line = sep.attr("join")(strings);
-
- object file;
- if (kwargs.contains("file")) {
- file = kwargs["file"].cast<object>();
- } else {
- try {
- file = module::import("sys").attr("stdout");
- } catch (const error_already_set &) {
- /* If print() is called from code that is executed as
- part of garbage collection during interpreter shutdown,
- importing 'sys' can fail. Give up rather than crashing the
- interpreter in this case. */
- return;
- }
- }
-
- auto write = file.attr("write");
- write(line);
- write(kwargs.contains("end") ? kwargs["end"] : cast("\n"));
-
- if (kwargs.contains("flush") && kwargs["flush"].cast<bool>())
- file.attr("flush")();
-}
-NAMESPACE_END(detail)
-
-template <return_value_policy policy = return_value_policy::automatic_reference, typename... Args>
-void print(Args &&...args) {
- auto c = detail::collect_arguments<policy>(std::forward<Args>(args)...);
- detail::print(c.args(), c.kwargs());
-}
-
-#if defined(WITH_THREAD) && !defined(PYPY_VERSION)
-
-/* The functions below essentially reproduce the PyGILState_* API using a RAII
- * pattern, but there are a few important differences:
- *
- * 1. When acquiring the GIL from an non-main thread during the finalization
- * phase, the GILState API blindly terminates the calling thread, which
- * is often not what is wanted. This API does not do this.
- *
- * 2. The gil_scoped_release function can optionally cut the relationship
- * of a PyThreadState and its associated thread, which allows moving it to
- * another thread (this is a fairly rare/advanced use case).
- *
- * 3. The reference count of an acquired thread state can be controlled. This
- * can be handy to prevent cases where callbacks issued from an external
- * thread would otherwise constantly construct and destroy thread state data
- * structures.
- *
- * See the Python bindings of NanoGUI (http://github.com/wjakob/nanogui) for an
- * example which uses features 2 and 3 to migrate the Python thread of
- * execution to another thread (to run the event loop on the original thread,
- * in this case).
- */
-
-class gil_scoped_acquire {
-public:
- PYBIND11_NOINLINE gil_scoped_acquire() {
- auto const &internals = detail::get_internals();
- tstate = (PyThreadState *) PyThread_get_key_value(internals.tstate);
-
- if (!tstate) {
- tstate = PyThreadState_New(internals.istate);
- #if !defined(NDEBUG)
- if (!tstate)
- pybind11_fail("scoped_acquire: could not create thread state!");
- #endif
- tstate->gilstate_counter = 0;
- #if PY_MAJOR_VERSION < 3
- PyThread_delete_key_value(internals.tstate);
- #endif
- PyThread_set_key_value(internals.tstate, tstate);
- } else {
- release = detail::get_thread_state_unchecked() != tstate;
- }
-
- if (release) {
- /* Work around an annoying assertion in PyThreadState_Swap */
- #if defined(Py_DEBUG)
- PyInterpreterState *interp = tstate->interp;
- tstate->interp = nullptr;
- #endif
- PyEval_AcquireThread(tstate);
- #if defined(Py_DEBUG)
- tstate->interp = interp;
- #endif
- }
-
- inc_ref();
- }
-
- void inc_ref() {
- ++tstate->gilstate_counter;
- }
-
- PYBIND11_NOINLINE void dec_ref() {
- --tstate->gilstate_counter;
- #if !defined(NDEBUG)
- if (detail::get_thread_state_unchecked() != tstate)
- pybind11_fail("scoped_acquire::dec_ref(): thread state must be current!");
- if (tstate->gilstate_counter < 0)
- pybind11_fail("scoped_acquire::dec_ref(): reference count underflow!");
- #endif
- if (tstate->gilstate_counter == 0) {
- #if !defined(NDEBUG)
- if (!release)
- pybind11_fail("scoped_acquire::dec_ref(): internal error!");
- #endif
- PyThreadState_Clear(tstate);
- PyThreadState_DeleteCurrent();
- PyThread_delete_key_value(detail::get_internals().tstate);
- release = false;
- }
- }
-
- PYBIND11_NOINLINE ~gil_scoped_acquire() {
- dec_ref();
- if (release)
- PyEval_SaveThread();
- }
-private:
- PyThreadState *tstate = nullptr;
- bool release = true;
-};
-
-class gil_scoped_release {
-public:
- explicit gil_scoped_release(bool disassoc = false) : disassoc(disassoc) {
- tstate = PyEval_SaveThread();
- if (disassoc) {
- auto key = detail::get_internals().tstate;
- #if PY_MAJOR_VERSION < 3
- PyThread_delete_key_value(key);
- #else
- PyThread_set_key_value(key, nullptr);
- #endif
- }
- }
- ~gil_scoped_release() {
- if (!tstate)
- return;
- PyEval_RestoreThread(tstate);
- if (disassoc) {
- auto key = detail::get_internals().tstate;
- #if PY_MAJOR_VERSION < 3
- PyThread_delete_key_value(key);
- #endif
- PyThread_set_key_value(key, tstate);
- }
- }
-private:
- PyThreadState *tstate;
- bool disassoc;
-};
-#elif defined(PYPY_VERSION)
-class gil_scoped_acquire {
- PyGILState_STATE state;
-public:
- gil_scoped_acquire() { state = PyGILState_Ensure(); }
- ~gil_scoped_acquire() { PyGILState_Release(state); }
-};
-
-class gil_scoped_release {
- PyThreadState *state;
-public:
- gil_scoped_release() { state = PyEval_SaveThread(); }
- ~gil_scoped_release() { PyEval_RestoreThread(state); }
-};
-#else
-class gil_scoped_acquire { };
-class gil_scoped_release { };
-#endif
-
-error_already_set::~error_already_set() {
- if (value) {
- gil_scoped_acquire gil;
- clear();
- }
-}
-
-inline function get_type_overload(const void *this_ptr, const detail::type_info *this_type, const char *name) {
- handle self = detail::get_object_handle(this_ptr, this_type);
- if (!self)
- return function();
- handle type = self.get_type();
- auto key = std::make_pair(type.ptr(), name);
-
- /* Cache functions that aren't overloaded in Python to avoid
- many costly Python dictionary lookups below */
- auto &cache = detail::get_internals().inactive_overload_cache;
- if (cache.find(key) != cache.end())
- return function();
-
- function overload = getattr(self, name, function());
- if (overload.is_cpp_function()) {
- cache.insert(key);
- return function();
- }
-
- /* Don't call dispatch code if invoked from overridden function.
- Unfortunately this doesn't work on PyPy. */
-#if !defined(PYPY_VERSION)
- PyFrameObject *frame = PyThreadState_Get()->frame;
- if (frame && (std::string) str(frame->f_code->co_name) == name &&
- frame->f_code->co_argcount > 0) {
- PyFrame_FastToLocals(frame);
- PyObject *self_caller = PyDict_GetItem(
- frame->f_locals, PyTuple_GET_ITEM(frame->f_code->co_varnames, 0));
- if (self_caller == self.ptr())
- return function();
- }
-#else
- /* PyPy currently doesn't provide a detailed cpyext emulation of
- frame objects, so we have to emulate this using Python. This
- is going to be slow..*/
- dict d; d["self"] = self; d["name"] = pybind11::str(name);
- PyObject *result = PyRun_String(
- "import inspect\n"
- "frame = inspect.currentframe()\n"
- "if frame is not None:\n"
- " frame = frame.f_back\n"
- " if frame is not None and str(frame.f_code.co_name) == name and "
- "frame.f_code.co_argcount > 0:\n"
- " self_caller = frame.f_locals[frame.f_code.co_varnames[0]]\n"
- " if self_caller == self:\n"
- " self = None\n",
- Py_file_input, d.ptr(), d.ptr());
- if (result == nullptr)
- throw error_already_set();
- if ((handle) d["self"] == Py_None)
- return function();
- Py_DECREF(result);
-#endif
-
- return overload;
-}
-
-template <class T> function get_overload(const T *this_ptr, const char *name) {
- auto tinfo = detail::get_type_info(typeid(T));
- return tinfo ? get_type_overload(this_ptr, tinfo, name) : function();
-}
-
-#define PYBIND11_OVERLOAD_INT(ret_type, cname, name, ...) { \
- pybind11::gil_scoped_acquire gil; \
- pybind11::function overload = pybind11::get_overload(static_cast<const cname *>(this), name); \
- if (overload) { \
- auto o = overload(__VA_ARGS__); \
- if (pybind11::detail::cast_is_temporary_value_reference<ret_type>::value) { \
- static pybind11::detail::overload_caster_t<ret_type> caster; \
- return pybind11::detail::cast_ref<ret_type>(std::move(o), caster); \
- } \
- else return pybind11::detail::cast_safe<ret_type>(std::move(o)); \
- } \
- }
-
-#define PYBIND11_OVERLOAD_NAME(ret_type, cname, name, fn, ...) \
- PYBIND11_OVERLOAD_INT(ret_type, cname, name, __VA_ARGS__) \
- return cname::fn(__VA_ARGS__)
-
-#define PYBIND11_OVERLOAD_PURE_NAME(ret_type, cname, name, fn, ...) \
- PYBIND11_OVERLOAD_INT(ret_type, cname, name, __VA_ARGS__) \
- pybind11::pybind11_fail("Tried to call pure virtual function \"" #cname "::" name "\"");
-
-#define PYBIND11_OVERLOAD(ret_type, cname, fn, ...) \
- PYBIND11_OVERLOAD_NAME(ret_type, cname, #fn, fn, __VA_ARGS__)
-
-#define PYBIND11_OVERLOAD_PURE(ret_type, cname, fn, ...) \
- PYBIND11_OVERLOAD_PURE_NAME(ret_type, cname, #fn, fn, __VA_ARGS__)
-
-NAMESPACE_END(pybind11)
-
-#if defined(_MSC_VER)
-# pragma warning(pop)
-#elif defined(__INTEL_COMPILER)
-/* Leave ignored warnings on */
-#elif defined(__GNUG__) && !defined(__clang__)
-# pragma GCC diagnostic pop
-#endif
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/pytypes.h b/thirdparty/pybind11/pybind11/include/pybind11/pytypes.h
deleted file mode 100644
index 900c57564ed9b75f52d2412bf3209db27463a46e..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/pytypes.h
+++ /dev/null
@@ -1,1244 +0,0 @@
-/*
- pybind11/typeid.h: Convenience wrapper classes for basic Python types
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "common.h"
-#include <utility>
-#include <type_traits>
-
-NAMESPACE_BEGIN(pybind11)
-
-/* A few forward declarations */
-class handle; class object;
-class str; class iterator;
-struct arg; struct arg_v;
-
-NAMESPACE_BEGIN(detail)
-class args_proxy;
-inline bool isinstance_generic(handle obj, const std::type_info &tp);
-
-// Accessor forward declarations
-template <typename Policy> class accessor;
-namespace accessor_policies {
- struct obj_attr;
- struct str_attr;
- struct generic_item;
- struct sequence_item;
- struct list_item;
- struct tuple_item;
-}
-using obj_attr_accessor = accessor<accessor_policies::obj_attr>;
-using str_attr_accessor = accessor<accessor_policies::str_attr>;
-using item_accessor = accessor<accessor_policies::generic_item>;
-using sequence_accessor = accessor<accessor_policies::sequence_item>;
-using list_accessor = accessor<accessor_policies::list_item>;
-using tuple_accessor = accessor<accessor_policies::tuple_item>;
-
-/// Tag and check to identify a class which implements the Python object API
-class pyobject_tag { };
-template <typename T> using is_pyobject = std::is_base_of<pyobject_tag, typename std::remove_reference<T>::type>;
-
-/** \rst
- A mixin class which adds common functions to `handle`, `object` and various accessors.
- The only requirement for `Derived` is to implement ``PyObject *Derived::ptr() const``.
-\endrst */
-template <typename Derived>
-class object_api : public pyobject_tag {
- const Derived &derived() const { return static_cast<const Derived &>(*this); }
-
-public:
- /** \rst
- Return an iterator equivalent to calling ``iter()`` in Python. The object
- must be a collection which supports the iteration protocol.
- \endrst */
- iterator begin() const;
- /// Return a sentinel which ends iteration.
- iterator end() const;
-
- /** \rst
- Return an internal functor to invoke the object's sequence protocol. Casting
- the returned ``detail::item_accessor`` instance to a `handle` or `object`
- subclass causes a corresponding call to ``__getitem__``. Assigning a `handle`
- or `object` subclass causes a call to ``__setitem__``.
- \endrst */
- item_accessor operator[](handle key) const;
- /// See above (the only difference is that they key is provided as a string literal)
- item_accessor operator[](const char *key) const;
-
- /** \rst
- Return an internal functor to access the object's attributes. Casting the
- returned ``detail::obj_attr_accessor`` instance to a `handle` or `object`
- subclass causes a corresponding call to ``getattr``. Assigning a `handle`
- or `object` subclass causes a call to ``setattr``.
- \endrst */
- obj_attr_accessor attr(handle key) const;
- /// See above (the only difference is that they key is provided as a string literal)
- str_attr_accessor attr(const char *key) const;
-
- /** \rst
- Matches * unpacking in Python, e.g. to unpack arguments out of a ``tuple``
- or ``list`` for a function call. Applying another * to the result yields
- ** unpacking, e.g. to unpack a dict as function keyword arguments.
- See :ref:`calling_python_functions`.
- \endrst */
- args_proxy operator*() const;
-
- /// Check if the given item is contained within this object, i.e. ``item in obj``.
- template <typename T> bool contains(T &&item) const;
-
- /** \rst
- Assuming the Python object is a function or implements the ``__call__``
- protocol, ``operator()`` invokes the underlying function, passing an
- arbitrary set of parameters. The result is returned as a `object` and
- may need to be converted back into a Python object using `handle::cast()`.
-
- When some of the arguments cannot be converted to Python objects, the
- function will throw a `cast_error` exception. When the Python function
- call fails, a `error_already_set` exception is thrown.
- \endrst */
- template <return_value_policy policy = return_value_policy::automatic_reference, typename... Args>
- object operator()(Args &&...args) const;
- template <return_value_policy policy = return_value_policy::automatic_reference, typename... Args>
- PYBIND11_DEPRECATED("call(...) was deprecated in favor of operator()(...)")
- object call(Args&&... args) const;
-
- /// Equivalent to ``obj is None`` in Python.
- bool is_none() const { return derived().ptr() == Py_None; }
- PYBIND11_DEPRECATED("Use py::str(obj) instead")
- pybind11::str str() const;
-
- /// Return the object's current reference count
- int ref_count() const { return static_cast<int>(Py_REFCNT(derived().ptr())); }
- /// Return a handle to the Python type object underlying the instance
- handle get_type() const;
-};
-
-NAMESPACE_END(detail)
-
-/** \rst
- Holds a reference to a Python object (no reference counting)
-
- The `handle` class is a thin wrapper around an arbitrary Python object (i.e. a
- ``PyObject *`` in Python's C API). It does not perform any automatic reference
- counting and merely provides a basic C++ interface to various Python API functions.
-
- .. seealso::
- The `object` class inherits from `handle` and adds automatic reference
- counting features.
-\endrst */
-class handle : public detail::object_api<handle> {
-public:
- /// The default constructor creates a handle with a ``nullptr``-valued pointer
- handle() = default;
- /// Creates a ``handle`` from the given raw Python object pointer
- handle(PyObject *ptr) : m_ptr(ptr) { } // Allow implicit conversion from PyObject*
-
- /// Return the underlying ``PyObject *`` pointer
- PyObject *ptr() const { return m_ptr; }
- PyObject *&ptr() { return m_ptr; }
-
- /** \rst
- Manually increase the reference count of the Python object. Usually, it is
- preferable to use the `object` class which derives from `handle` and calls
- this function automatically. Returns a reference to itself.
- \endrst */
- const handle& inc_ref() const & { Py_XINCREF(m_ptr); return *this; }
-
- /** \rst
- Manually decrease the reference count of the Python object. Usually, it is
- preferable to use the `object` class which derives from `handle` and calls
- this function automatically. Returns a reference to itself.
- \endrst */
- const handle& dec_ref() const & { Py_XDECREF(m_ptr); return *this; }
-
- /** \rst
- Attempt to cast the Python object into the given C++ type. A `cast_error`
- will be throw upon failure.
- \endrst */
- template <typename T> T cast() const;
- /// Return ``true`` when the `handle` wraps a valid Python object
- explicit operator bool() const { return m_ptr != nullptr; }
- /** \rst
- Check that the underlying pointers are the same.
- Equivalent to ``obj1 is obj2`` in Python.
- \endrst */
- bool operator==(const handle &h) const { return m_ptr == h.m_ptr; }
- bool operator!=(const handle &h) const { return m_ptr != h.m_ptr; }
- PYBIND11_DEPRECATED("Use handle::operator bool() instead")
- bool check() const { return m_ptr != nullptr; }
-protected:
- PyObject *m_ptr = nullptr;
-};
-
-/** \rst
- Holds a reference to a Python object (with reference counting)
-
- Like `handle`, the `object` class is a thin wrapper around an arbitrary Python
- object (i.e. a ``PyObject *`` in Python's C API). In contrast to `handle`, it
- optionally increases the object's reference count upon construction, and it
- *always* decreases the reference count when the `object` instance goes out of
- scope and is destructed. When using `object` instances consistently, it is much
- easier to get reference counting right at the first attempt.
-\endrst */
-class object : public handle {
-public:
- object() = default;
- PYBIND11_DEPRECATED("Use reinterpret_borrow<object>() or reinterpret_steal<object>()")
- object(handle h, bool is_borrowed) : handle(h) { if (is_borrowed) inc_ref(); }
- /// Copy constructor; always increases the reference count
- object(const object &o) : handle(o) { inc_ref(); }
- /// Move constructor; steals the object from ``other`` and preserves its reference count
- object(object &&other) noexcept { m_ptr = other.m_ptr; other.m_ptr = nullptr; }
- /// Destructor; automatically calls `handle::dec_ref()`
- ~object() { dec_ref(); }
-
- /** \rst
- Resets the internal pointer to ``nullptr`` without without decreasing the
- object's reference count. The function returns a raw handle to the original
- Python object.
- \endrst */
- handle release() {
- PyObject *tmp = m_ptr;
- m_ptr = nullptr;
- return handle(tmp);
- }
-
- object& operator=(const object &other) {
- other.inc_ref();
- dec_ref();
- m_ptr = other.m_ptr;
- return *this;
- }
-
- object& operator=(object &&other) noexcept {
- if (this != &other) {
- handle temp(m_ptr);
- m_ptr = other.m_ptr;
- other.m_ptr = nullptr;
- temp.dec_ref();
- }
- return *this;
- }
-
- // Calling cast() on an object lvalue just copies (via handle::cast)
- template <typename T> T cast() const &;
- // Calling on an object rvalue does a move, if needed and/or possible
- template <typename T> T cast() &&;
-
-protected:
- // Tags for choosing constructors from raw PyObject *
- struct borrowed_t { }; static constexpr borrowed_t borrowed{};
- struct stolen_t { }; static constexpr stolen_t stolen{};
-
- template <typename T> friend T reinterpret_borrow(handle);
- template <typename T> friend T reinterpret_steal(handle);
-
-public:
- // Only accessible from derived classes and the reinterpret_* functions
- object(handle h, borrowed_t) : handle(h) { inc_ref(); }
- object(handle h, stolen_t) : handle(h) { }
-};
-
-/** \rst
- Declare that a `handle` or ``PyObject *`` is a certain type and borrow the reference.
- The target type ``T`` must be `object` or one of its derived classes. The function
- doesn't do any conversions or checks. It's up to the user to make sure that the
- target type is correct.
-
- .. code-block:: cpp
-
- PyObject *p = PyList_GetItem(obj, index);
- py::object o = reinterpret_borrow<py::object>(p);
- // or
- py::tuple t = reinterpret_borrow<py::tuple>(p); // <-- `p` must be already be a `tuple`
-\endrst */
-template <typename T> T reinterpret_borrow(handle h) { return {h, object::borrowed}; }
-
-/** \rst
- Like `reinterpret_borrow`, but steals the reference.
-
- .. code-block:: cpp
-
- PyObject *p = PyObject_Str(obj);
- py::str s = reinterpret_steal<py::str>(p); // <-- `p` must be already be a `str`
-\endrst */
-template <typename T> T reinterpret_steal(handle h) { return {h, object::stolen}; }
-
-/** \defgroup python_builtins _
- Unless stated otherwise, the following C++ functions behave the same
- as their Python counterparts.
- */
-
-/** \ingroup python_builtins
- \rst
- Return true if ``obj`` is an instance of ``T``. Type ``T`` must be a subclass of
- `object` or a class which was exposed to Python as ``py::class_<T>``.
-\endrst */
-template <typename T, detail::enable_if_t<std::is_base_of<object, T>::value, int> = 0>
-bool isinstance(handle obj) { return T::check_(obj); }
-
-template <typename T, detail::enable_if_t<!std::is_base_of<object, T>::value, int> = 0>
-bool isinstance(handle obj) { return detail::isinstance_generic(obj, typeid(T)); }
-
-template <> inline bool isinstance<handle>(handle obj) = delete;
-template <> inline bool isinstance<object>(handle obj) { return obj.ptr() != nullptr; }
-
-/// \ingroup python_builtins
-/// Return true if ``obj`` is an instance of the ``type``.
-inline bool isinstance(handle obj, handle type) {
- const auto result = PyObject_IsInstance(obj.ptr(), type.ptr());
- if (result == -1)
- throw error_already_set();
- return result != 0;
-}
-
-/// \addtogroup python_builtins
-/// @{
-inline bool hasattr(handle obj, handle name) {
- return PyObject_HasAttr(obj.ptr(), name.ptr()) == 1;
-}
-
-inline bool hasattr(handle obj, const char *name) {
- return PyObject_HasAttrString(obj.ptr(), name) == 1;
-}
-
-inline object getattr(handle obj, handle name) {
- PyObject *result = PyObject_GetAttr(obj.ptr(), name.ptr());
- if (!result) { throw error_already_set(); }
- return reinterpret_steal<object>(result);
-}
-
-inline object getattr(handle obj, const char *name) {
- PyObject *result = PyObject_GetAttrString(obj.ptr(), name);
- if (!result) { throw error_already_set(); }
- return reinterpret_steal<object>(result);
-}
-
-inline object getattr(handle obj, handle name, handle default_) {
- if (PyObject *result = PyObject_GetAttr(obj.ptr(), name.ptr())) {
- return reinterpret_steal<object>(result);
- } else {
- PyErr_Clear();
- return reinterpret_borrow<object>(default_);
- }
-}
-
-inline object getattr(handle obj, const char *name, handle default_) {
- if (PyObject *result = PyObject_GetAttrString(obj.ptr(), name)) {
- return reinterpret_steal<object>(result);
- } else {
- PyErr_Clear();
- return reinterpret_borrow<object>(default_);
- }
-}
-
-inline void setattr(handle obj, handle name, handle value) {
- if (PyObject_SetAttr(obj.ptr(), name.ptr(), value.ptr()) != 0) { throw error_already_set(); }
-}
-
-inline void setattr(handle obj, const char *name, handle value) {
- if (PyObject_SetAttrString(obj.ptr(), name, value.ptr()) != 0) { throw error_already_set(); }
-}
-/// @} python_builtins
-
-NAMESPACE_BEGIN(detail)
-inline handle get_function(handle value) {
- if (value) {
-#if PY_MAJOR_VERSION >= 3
- if (PyInstanceMethod_Check(value.ptr()))
- value = PyInstanceMethod_GET_FUNCTION(value.ptr());
-#endif
- if (PyMethod_Check(value.ptr()))
- value = PyMethod_GET_FUNCTION(value.ptr());
- }
- return value;
-}
-
-// Helper aliases/functions to support implicit casting of values given to python accessors/methods.
-// When given a pyobject, this simply returns the pyobject as-is; for other C++ type, the value goes
-// through pybind11::cast(obj) to convert it to an `object`.
-template <typename T, enable_if_t<is_pyobject<T>::value, int> = 0>
-auto object_or_cast(T &&o) -> decltype(std::forward<T>(o)) { return std::forward<T>(o); }
-// The following casting version is implemented in cast.h:
-template <typename T, enable_if_t<!is_pyobject<T>::value, int> = 0>
-object object_or_cast(T &&o);
-// Match a PyObject*, which we want to convert directly to handle via its converting constructor
-inline handle object_or_cast(PyObject *ptr) { return ptr; }
-
-
-template <typename Policy>
-class accessor : public object_api<accessor<Policy>> {
- using key_type = typename Policy::key_type;
-
-public:
- accessor(handle obj, key_type key) : obj(obj), key(std::move(key)) { }
-
- // accessor overload required to override default assignment operator (templates are not allowed
- // to replace default compiler-generated assignments).
- void operator=(const accessor &a) && { std::move(*this).operator=(handle(a)); }
- void operator=(const accessor &a) & { operator=(handle(a)); }
-
- template <typename T> void operator=(T &&value) && {
- Policy::set(obj, key, object_or_cast(std::forward<T>(value)));
- }
- template <typename T> void operator=(T &&value) & {
- get_cache() = reinterpret_borrow<object>(object_or_cast(std::forward<T>(value)));
- }
-
- template <typename T = Policy>
- PYBIND11_DEPRECATED("Use of obj.attr(...) as bool is deprecated in favor of pybind11::hasattr(obj, ...)")
- explicit operator enable_if_t<std::is_same<T, accessor_policies::str_attr>::value ||
- std::is_same<T, accessor_policies::obj_attr>::value, bool>() const {
- return hasattr(obj, key);
- }
- template <typename T = Policy>
- PYBIND11_DEPRECATED("Use of obj[key] as bool is deprecated in favor of obj.contains(key)")
- explicit operator enable_if_t<std::is_same<T, accessor_policies::generic_item>::value, bool>() const {
- return obj.contains(key);
- }
-
- operator object() const { return get_cache(); }
- PyObject *ptr() const { return get_cache().ptr(); }
- template <typename T> T cast() const { return get_cache().template cast<T>(); }
-
-private:
- object &get_cache() const {
- if (!cache) { cache = Policy::get(obj, key); }
- return cache;
- }
-
-private:
- handle obj;
- key_type key;
- mutable object cache;
-};
-
-NAMESPACE_BEGIN(accessor_policies)
-struct obj_attr {
- using key_type = object;
- static object get(handle obj, handle key) { return getattr(obj, key); }
- static void set(handle obj, handle key, handle val) { setattr(obj, key, val); }
-};
-
-struct str_attr {
- using key_type = const char *;
- static object get(handle obj, const char *key) { return getattr(obj, key); }
- static void set(handle obj, const char *key, handle val) { setattr(obj, key, val); }
-};
-
-struct generic_item {
- using key_type = object;
-
- static object get(handle obj, handle key) {
- PyObject *result = PyObject_GetItem(obj.ptr(), key.ptr());
- if (!result) { throw error_already_set(); }
- return reinterpret_steal<object>(result);
- }
-
- static void set(handle obj, handle key, handle val) {
- if (PyObject_SetItem(obj.ptr(), key.ptr(), val.ptr()) != 0) { throw error_already_set(); }
- }
-};
-
-struct sequence_item {
- using key_type = size_t;
-
- static object get(handle obj, size_t index) {
- PyObject *result = PySequence_GetItem(obj.ptr(), static_cast<ssize_t>(index));
- if (!result) { throw error_already_set(); }
- return reinterpret_steal<object>(result);
- }
-
- static void set(handle obj, size_t index, handle val) {
- // PySequence_SetItem does not steal a reference to 'val'
- if (PySequence_SetItem(obj.ptr(), static_cast<ssize_t>(index), val.ptr()) != 0) {
- throw error_already_set();
- }
- }
-};
-
-struct list_item {
- using key_type = size_t;
-
- static object get(handle obj, size_t index) {
- PyObject *result = PyList_GetItem(obj.ptr(), static_cast<ssize_t>(index));
- if (!result) { throw error_already_set(); }
- return reinterpret_borrow<object>(result);
- }
-
- static void set(handle obj, size_t index, handle val) {
- // PyList_SetItem steals a reference to 'val'
- if (PyList_SetItem(obj.ptr(), static_cast<ssize_t>(index), val.inc_ref().ptr()) != 0) {
- throw error_already_set();
- }
- }
-};
-
-struct tuple_item {
- using key_type = size_t;
-
- static object get(handle obj, size_t index) {
- PyObject *result = PyTuple_GetItem(obj.ptr(), static_cast<ssize_t>(index));
- if (!result) { throw error_already_set(); }
- return reinterpret_borrow<object>(result);
- }
-
- static void set(handle obj, size_t index, handle val) {
- // PyTuple_SetItem steals a reference to 'val'
- if (PyTuple_SetItem(obj.ptr(), static_cast<ssize_t>(index), val.inc_ref().ptr()) != 0) {
- throw error_already_set();
- }
- }
-};
-NAMESPACE_END(accessor_policies)
-
-/// STL iterator template used for tuple, list, sequence and dict
-template <typename Policy>
-class generic_iterator : public Policy {
- using It = generic_iterator;
-
-public:
- using difference_type = ssize_t;
- using iterator_category = typename Policy::iterator_category;
- using value_type = typename Policy::value_type;
- using reference = typename Policy::reference;
- using pointer = typename Policy::pointer;
-
- generic_iterator() = default;
- generic_iterator(handle seq, ssize_t index) : Policy(seq, index) { }
-
- reference operator*() const { return Policy::dereference(); }
- reference operator[](difference_type n) const { return *(*this + n); }
- pointer operator->() const { return **this; }
-
- It &operator++() { Policy::increment(); return *this; }
- It operator++(int) { auto copy = *this; Policy::increment(); return copy; }
- It &operator--() { Policy::decrement(); return *this; }
- It operator--(int) { auto copy = *this; Policy::decrement(); return copy; }
- It &operator+=(difference_type n) { Policy::advance(n); return *this; }
- It &operator-=(difference_type n) { Policy::advance(-n); return *this; }
-
- friend It operator+(const It &a, difference_type n) { auto copy = a; return copy += n; }
- friend It operator+(difference_type n, const It &b) { return b + n; }
- friend It operator-(const It &a, difference_type n) { auto copy = a; return copy -= n; }
- friend difference_type operator-(const It &a, const It &b) { return a.distance_to(b); }
-
- friend bool operator==(const It &a, const It &b) { return a.equal(b); }
- friend bool operator!=(const It &a, const It &b) { return !(a == b); }
- friend bool operator< (const It &a, const It &b) { return b - a > 0; }
- friend bool operator> (const It &a, const It &b) { return b < a; }
- friend bool operator>=(const It &a, const It &b) { return !(a < b); }
- friend bool operator<=(const It &a, const It &b) { return !(a > b); }
-};
-
-NAMESPACE_BEGIN(iterator_policies)
-/// Quick proxy class needed to implement ``operator->`` for iterators which can't return pointers
-template <typename T>
-struct arrow_proxy {
- T value;
-
- arrow_proxy(T &&value) : value(std::move(value)) { }
- T *operator->() const { return &value; }
-};
-
-/// Lightweight iterator policy using just a simple pointer: see ``PySequence_Fast_ITEMS``
-class sequence_fast_readonly {
-protected:
- using iterator_category = std::random_access_iterator_tag;
- using value_type = handle;
- using reference = const handle;
- using pointer = arrow_proxy<const handle>;
-
- sequence_fast_readonly(handle obj, ssize_t n) : ptr(PySequence_Fast_ITEMS(obj.ptr()) + n) { }
-
- reference dereference() const { return *ptr; }
- void increment() { ++ptr; }
- void decrement() { --ptr; }
- void advance(ssize_t n) { ptr += n; }
- bool equal(const sequence_fast_readonly &b) const { return ptr == b.ptr; }
- ssize_t distance_to(const sequence_fast_readonly &b) const { return ptr - b.ptr; }
-
-private:
- PyObject **ptr;
-};
-
-/// Full read and write access using the sequence protocol: see ``detail::sequence_accessor``
-class sequence_slow_readwrite {
-protected:
- using iterator_category = std::random_access_iterator_tag;
- using value_type = object;
- using reference = sequence_accessor;
- using pointer = arrow_proxy<const sequence_accessor>;
-
- sequence_slow_readwrite(handle obj, ssize_t index) : obj(obj), index(index) { }
-
- reference dereference() const { return {obj, static_cast<size_t>(index)}; }
- void increment() { ++index; }
- void decrement() { --index; }
- void advance(ssize_t n) { index += n; }
- bool equal(const sequence_slow_readwrite &b) const { return index == b.index; }
- ssize_t distance_to(const sequence_slow_readwrite &b) const { return index - b.index; }
-
-private:
- handle obj;
- ssize_t index;
-};
-
-/// Python's dictionary protocol permits this to be a forward iterator
-class dict_readonly {
-protected:
- using iterator_category = std::forward_iterator_tag;
- using value_type = std::pair<handle, handle>;
- using reference = const value_type;
- using pointer = arrow_proxy<const value_type>;
-
- dict_readonly() = default;
- dict_readonly(handle obj, ssize_t pos) : obj(obj), pos(pos) { increment(); }
-
- reference dereference() const { return {key, value}; }
- void increment() { if (!PyDict_Next(obj.ptr(), &pos, &key, &value)) { pos = -1; } }
- bool equal(const dict_readonly &b) const { return pos == b.pos; }
-
-private:
- handle obj;
- PyObject *key, *value;
- ssize_t pos = -1;
-};
-NAMESPACE_END(iterator_policies)
-
-#if !defined(PYPY_VERSION)
-using tuple_iterator = generic_iterator<iterator_policies::sequence_fast_readonly>;
-using list_iterator = generic_iterator<iterator_policies::sequence_fast_readonly>;
-#else
-using tuple_iterator = generic_iterator<iterator_policies::sequence_slow_readwrite>;
-using list_iterator = generic_iterator<iterator_policies::sequence_slow_readwrite>;
-#endif
-
-using sequence_iterator = generic_iterator<iterator_policies::sequence_slow_readwrite>;
-using dict_iterator = generic_iterator<iterator_policies::dict_readonly>;
-
-inline bool PyIterable_Check(PyObject *obj) {
- PyObject *iter = PyObject_GetIter(obj);
- if (iter) {
- Py_DECREF(iter);
- return true;
- } else {
- PyErr_Clear();
- return false;
- }
-}
-
-inline bool PyNone_Check(PyObject *o) { return o == Py_None; }
-
-inline bool PyUnicode_Check_Permissive(PyObject *o) { return PyUnicode_Check(o) || PYBIND11_BYTES_CHECK(o); }
-
-class kwargs_proxy : public handle {
-public:
- explicit kwargs_proxy(handle h) : handle(h) { }
-};
-
-class args_proxy : public handle {
-public:
- explicit args_proxy(handle h) : handle(h) { }
- kwargs_proxy operator*() const { return kwargs_proxy(*this); }
-};
-
-/// Python argument categories (using PEP 448 terms)
-template <typename T> using is_keyword = std::is_base_of<arg, T>;
-template <typename T> using is_s_unpacking = std::is_same<args_proxy, T>; // * unpacking
-template <typename T> using is_ds_unpacking = std::is_same<kwargs_proxy, T>; // ** unpacking
-template <typename T> using is_positional = satisfies_none_of<T,
- is_keyword, is_s_unpacking, is_ds_unpacking
->;
-template <typename T> using is_keyword_or_ds = satisfies_any_of<T, is_keyword, is_ds_unpacking>;
-
-// Call argument collector forward declarations
-template <return_value_policy policy = return_value_policy::automatic_reference>
-class simple_collector;
-template <return_value_policy policy = return_value_policy::automatic_reference>
-class unpacking_collector;
-
-NAMESPACE_END(detail)
-
-// TODO: After the deprecated constructors are removed, this macro can be simplified by
-// inheriting ctors: `using Parent::Parent`. It's not an option right now because
-// the `using` statement triggers the parent deprecation warning even if the ctor
-// isn't even used.
-#define PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun) \
- public: \
- PYBIND11_DEPRECATED("Use reinterpret_borrow<"#Name">() or reinterpret_steal<"#Name">()") \
- Name(handle h, bool is_borrowed) : Parent(is_borrowed ? Parent(h, borrowed) : Parent(h, stolen)) { } \
- Name(handle h, borrowed_t) : Parent(h, borrowed) { } \
- Name(handle h, stolen_t) : Parent(h, stolen) { } \
- PYBIND11_DEPRECATED("Use py::isinstance<py::python_type>(obj) instead") \
- bool check() const { return m_ptr != nullptr && (bool) CheckFun(m_ptr); } \
- static bool check_(handle h) { return h.ptr() != nullptr && CheckFun(h.ptr()); }
-
-#define PYBIND11_OBJECT_CVT(Name, Parent, CheckFun, ConvertFun) \
- PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun) \
- /* This is deliberately not 'explicit' to allow implicit conversion from object: */ \
- Name(const object &o) : Parent(ConvertFun(o.ptr()), stolen) { if (!m_ptr) throw error_already_set(); }
-
-#define PYBIND11_OBJECT(Name, Parent, CheckFun) \
- PYBIND11_OBJECT_COMMON(Name, Parent, CheckFun) \
- /* This is deliberately not 'explicit' to allow implicit conversion from object: */ \
- Name(const object &o) : Parent(o) { } \
- Name(object &&o) : Parent(std::move(o)) { }
-
-#define PYBIND11_OBJECT_DEFAULT(Name, Parent, CheckFun) \
- PYBIND11_OBJECT(Name, Parent, CheckFun) \
- Name() : Parent() { }
-
-/// \addtogroup pytypes
-/// @{
-
-/** \rst
- Wraps a Python iterator so that it can also be used as a C++ input iterator
-
- Caveat: copying an iterator does not (and cannot) clone the internal
- state of the Python iterable. This also applies to the post-increment
- operator. This iterator should only be used to retrieve the current
- value using ``operator*()``.
-\endrst */
-class iterator : public object {
-public:
- using iterator_category = std::input_iterator_tag;
- using difference_type = ssize_t;
- using value_type = handle;
- using reference = const handle;
- using pointer = const handle *;
-
- PYBIND11_OBJECT_DEFAULT(iterator, object, PyIter_Check)
-
- iterator& operator++() {
- advance();
- return *this;
- }
-
- iterator operator++(int) {
- auto rv = *this;
- advance();
- return rv;
- }
-
- reference operator*() const {
- if (m_ptr && !value.ptr()) {
- auto& self = const_cast<iterator &>(*this);
- self.advance();
- }
- return value;
- }
-
- pointer operator->() const { operator*(); return &value; }
-
- /** \rst
- The value which marks the end of the iteration. ``it == iterator::sentinel()``
- is equivalent to catching ``StopIteration`` in Python.
-
- .. code-block:: cpp
-
- void foo(py::iterator it) {
- while (it != py::iterator::sentinel()) {
- // use `*it`
- ++it;
- }
- }
- \endrst */
- static iterator sentinel() { return {}; }
-
- friend bool operator==(const iterator &a, const iterator &b) { return a->ptr() == b->ptr(); }
- friend bool operator!=(const iterator &a, const iterator &b) { return a->ptr() != b->ptr(); }
-
-private:
- void advance() {
- value = reinterpret_steal<object>(PyIter_Next(m_ptr));
- if (PyErr_Occurred()) { throw error_already_set(); }
- }
-
-private:
- object value = {};
-};
-
-class iterable : public object {
-public:
- PYBIND11_OBJECT_DEFAULT(iterable, object, detail::PyIterable_Check)
-};
-
-class bytes;
-
-class str : public object {
-public:
- PYBIND11_OBJECT_CVT(str, object, detail::PyUnicode_Check_Permissive, raw_str)
-
- str(const char *c, size_t n)
- : object(PyUnicode_FromStringAndSize(c, (ssize_t) n), stolen) {
- if (!m_ptr) pybind11_fail("Could not allocate string object!");
- }
-
- // 'explicit' is explicitly omitted from the following constructors to allow implicit conversion to py::str from C++ string-like objects
- str(const char *c = "")
- : object(PyUnicode_FromString(c), stolen) {
- if (!m_ptr) pybind11_fail("Could not allocate string object!");
- }
-
- str(const std::string &s) : str(s.data(), s.size()) { }
-
- explicit str(const bytes &b);
-
- /** \rst
- Return a string representation of the object. This is analogous to
- the ``str()`` function in Python.
- \endrst */
- explicit str(handle h) : object(raw_str(h.ptr()), stolen) { }
-
- operator std::string() const {
- object temp = *this;
- if (PyUnicode_Check(m_ptr)) {
- temp = reinterpret_steal<object>(PyUnicode_AsUTF8String(m_ptr));
- if (!temp)
- pybind11_fail("Unable to extract string contents! (encoding issue)");
- }
- char *buffer;
- ssize_t length;
- if (PYBIND11_BYTES_AS_STRING_AND_SIZE(temp.ptr(), &buffer, &length))
- pybind11_fail("Unable to extract string contents! (invalid type)");
- return std::string(buffer, (size_t) length);
- }
-
- template <typename... Args>
- str format(Args &&...args) const {
- return attr("format")(std::forward<Args>(args)...);
- }
-
-private:
- /// Return string representation -- always returns a new reference, even if already a str
- static PyObject *raw_str(PyObject *op) {
- PyObject *str_value = PyObject_Str(op);
-#if PY_MAJOR_VERSION < 3
- if (!str_value) throw error_already_set();
- PyObject *unicode = PyUnicode_FromEncodedObject(str_value, "utf-8", nullptr);
- Py_XDECREF(str_value); str_value = unicode;
-#endif
- return str_value;
- }
-};
-/// @} pytypes
-
-inline namespace literals {
-/** \rst
- String literal version of `str`
- \endrst */
-inline str operator"" _s(const char *s, size_t size) { return {s, size}; }
-}
-
-/// \addtogroup pytypes
-/// @{
-class bytes : public object {
-public:
- PYBIND11_OBJECT(bytes, object, PYBIND11_BYTES_CHECK)
-
- // Allow implicit conversion:
- bytes(const char *c = "")
- : object(PYBIND11_BYTES_FROM_STRING(c), stolen) {
- if (!m_ptr) pybind11_fail("Could not allocate bytes object!");
- }
-
- bytes(const char *c, size_t n)
- : object(PYBIND11_BYTES_FROM_STRING_AND_SIZE(c, (ssize_t) n), stolen) {
- if (!m_ptr) pybind11_fail("Could not allocate bytes object!");
- }
-
- // Allow implicit conversion:
- bytes(const std::string &s) : bytes(s.data(), s.size()) { }
-
- explicit bytes(const pybind11::str &s);
-
- operator std::string() const {
- char *buffer;
- ssize_t length;
- if (PYBIND11_BYTES_AS_STRING_AND_SIZE(m_ptr, &buffer, &length))
- pybind11_fail("Unable to extract bytes contents!");
- return std::string(buffer, (size_t) length);
- }
-};
-
-inline bytes::bytes(const pybind11::str &s) {
- object temp = s;
- if (PyUnicode_Check(s.ptr())) {
- temp = reinterpret_steal<object>(PyUnicode_AsUTF8String(s.ptr()));
- if (!temp)
- pybind11_fail("Unable to extract string contents! (encoding issue)");
- }
- char *buffer;
- ssize_t length;
- if (PYBIND11_BYTES_AS_STRING_AND_SIZE(temp.ptr(), &buffer, &length))
- pybind11_fail("Unable to extract string contents! (invalid type)");
- auto obj = reinterpret_steal<object>(PYBIND11_BYTES_FROM_STRING_AND_SIZE(buffer, length));
- if (!obj)
- pybind11_fail("Could not allocate bytes object!");
- m_ptr = obj.release().ptr();
-}
-
-inline str::str(const bytes& b) {
- char *buffer;
- ssize_t length;
- if (PYBIND11_BYTES_AS_STRING_AND_SIZE(b.ptr(), &buffer, &length))
- pybind11_fail("Unable to extract bytes contents!");
- auto obj = reinterpret_steal<object>(PyUnicode_FromStringAndSize(buffer, (ssize_t) length));
- if (!obj)
- pybind11_fail("Could not allocate string object!");
- m_ptr = obj.release().ptr();
-}
-
-class none : public object {
-public:
- PYBIND11_OBJECT(none, object, detail::PyNone_Check)
- none() : object(Py_None, borrowed) { }
-};
-
-class bool_ : public object {
-public:
- PYBIND11_OBJECT_CVT(bool_, object, PyBool_Check, raw_bool)
- bool_() : object(Py_False, borrowed) { }
- // Allow implicit conversion from and to `bool`:
- bool_(bool value) : object(value ? Py_True : Py_False, borrowed) { }
- operator bool() const { return m_ptr && PyLong_AsLong(m_ptr) != 0; }
-
-private:
- /// Return the truth value of an object -- always returns a new reference
- static PyObject *raw_bool(PyObject *op) {
- const auto value = PyObject_IsTrue(op);
- if (value == -1) return nullptr;
- return handle(value ? Py_True : Py_False).inc_ref().ptr();
- }
-};
-
-class int_ : public object {
-public:
- PYBIND11_OBJECT_CVT(int_, object, PYBIND11_LONG_CHECK, PyNumber_Long)
- int_() : object(PyLong_FromLong(0), stolen) { }
- // Allow implicit conversion from C++ integral types:
- template <typename T,
- detail::enable_if_t<std::is_integral<T>::value, int> = 0>
- int_(T value) {
- if (sizeof(T) <= sizeof(long)) {
- if (std::is_signed<T>::value)
- m_ptr = PyLong_FromLong((long) value);
- else
- m_ptr = PyLong_FromUnsignedLong((unsigned long) value);
- } else {
- if (std::is_signed<T>::value)
- m_ptr = PyLong_FromLongLong((long long) value);
- else
- m_ptr = PyLong_FromUnsignedLongLong((unsigned long long) value);
- }
- if (!m_ptr) pybind11_fail("Could not allocate int object!");
- }
-
- template <typename T,
- detail::enable_if_t<std::is_integral<T>::value, int> = 0>
- operator T() const {
- if (sizeof(T) <= sizeof(long)) {
- if (std::is_signed<T>::value)
- return (T) PyLong_AsLong(m_ptr);
- else
- return (T) PyLong_AsUnsignedLong(m_ptr);
- } else {
- if (std::is_signed<T>::value)
- return (T) PYBIND11_LONG_AS_LONGLONG(m_ptr);
- else
- return (T) PYBIND11_LONG_AS_UNSIGNED_LONGLONG(m_ptr);
- }
- }
-};
-
-class float_ : public object {
-public:
- PYBIND11_OBJECT_CVT(float_, object, PyFloat_Check, PyNumber_Float)
- // Allow implicit conversion from float/double:
- float_(float value) : object(PyFloat_FromDouble((double) value), stolen) {
- if (!m_ptr) pybind11_fail("Could not allocate float object!");
- }
- float_(double value = .0) : object(PyFloat_FromDouble((double) value), stolen) {
- if (!m_ptr) pybind11_fail("Could not allocate float object!");
- }
- operator float() const { return (float) PyFloat_AsDouble(m_ptr); }
- operator double() const { return (double) PyFloat_AsDouble(m_ptr); }
-};
-
-class weakref : public object {
-public:
- PYBIND11_OBJECT_DEFAULT(weakref, object, PyWeakref_Check)
- explicit weakref(handle obj, handle callback = {})
- : object(PyWeakref_NewRef(obj.ptr(), callback.ptr()), stolen) {
- if (!m_ptr) pybind11_fail("Could not allocate weak reference!");
- }
-};
-
-class slice : public object {
-public:
- PYBIND11_OBJECT_DEFAULT(slice, object, PySlice_Check)
- slice(ssize_t start_, ssize_t stop_, ssize_t step_) {
- int_ start(start_), stop(stop_), step(step_);
- m_ptr = PySlice_New(start.ptr(), stop.ptr(), step.ptr());
- if (!m_ptr) pybind11_fail("Could not allocate slice object!");
- }
- bool compute(size_t length, size_t *start, size_t *stop, size_t *step,
- size_t *slicelength) const {
- return PySlice_GetIndicesEx((PYBIND11_SLICE_OBJECT *) m_ptr,
- (ssize_t) length, (ssize_t *) start,
- (ssize_t *) stop, (ssize_t *) step,
- (ssize_t *) slicelength) == 0;
- }
-};
-
-class capsule : public object {
-public:
- PYBIND11_OBJECT_DEFAULT(capsule, object, PyCapsule_CheckExact)
- PYBIND11_DEPRECATED("Use reinterpret_borrow<capsule>() or reinterpret_steal<capsule>()")
- capsule(PyObject *ptr, bool is_borrowed) : object(is_borrowed ? object(ptr, borrowed) : object(ptr, stolen)) { }
-
- explicit capsule(const void *value)
- : object(PyCapsule_New(const_cast<void *>(value), nullptr, nullptr), stolen) {
- if (!m_ptr)
- pybind11_fail("Could not allocate capsule object!");
- }
-
- PYBIND11_DEPRECATED("Please pass a destructor that takes a void pointer as input")
- capsule(const void *value, void (*destruct)(PyObject *))
- : object(PyCapsule_New(const_cast<void*>(value), nullptr, destruct), stolen) {
- if (!m_ptr)
- pybind11_fail("Could not allocate capsule object!");
- }
-
- capsule(const void *value, void (*destructor)(void *)) {
- m_ptr = PyCapsule_New(const_cast<void *>(value), nullptr, [](PyObject *o) {
- auto destructor = reinterpret_cast<void (*)(void *)>(PyCapsule_GetContext(o));
- void *ptr = PyCapsule_GetPointer(o, nullptr);
- destructor(ptr);
- });
-
- if (!m_ptr)
- pybind11_fail("Could not allocate capsule object!");
-
- if (PyCapsule_SetContext(m_ptr, (void *) destructor) != 0)
- pybind11_fail("Could not set capsule context!");
- }
-
- capsule(void (*destructor)()) {
- m_ptr = PyCapsule_New(reinterpret_cast<void *>(destructor), nullptr, [](PyObject *o) {
- auto destructor = reinterpret_cast<void (*)()>(PyCapsule_GetPointer(o, nullptr));
- destructor();
- });
-
- if (!m_ptr)
- pybind11_fail("Could not allocate capsule object!");
- }
-
- template <typename T> operator T *() const {
- T * result = static_cast<T *>(PyCapsule_GetPointer(m_ptr, nullptr));
- if (!result) pybind11_fail("Unable to extract capsule contents!");
- return result;
- }
-};
-
-class tuple : public object {
-public:
- PYBIND11_OBJECT_CVT(tuple, object, PyTuple_Check, PySequence_Tuple)
- explicit tuple(size_t size = 0) : object(PyTuple_New((ssize_t) size), stolen) {
- if (!m_ptr) pybind11_fail("Could not allocate tuple object!");
- }
- size_t size() const { return (size_t) PyTuple_Size(m_ptr); }
- detail::tuple_accessor operator[](size_t index) const { return {*this, index}; }
- detail::tuple_iterator begin() const { return {*this, 0}; }
- detail::tuple_iterator end() const { return {*this, PyTuple_GET_SIZE(m_ptr)}; }
-};
-
-class dict : public object {
-public:
- PYBIND11_OBJECT_CVT(dict, object, PyDict_Check, raw_dict)
- dict() : object(PyDict_New(), stolen) {
- if (!m_ptr) pybind11_fail("Could not allocate dict object!");
- }
- template <typename... Args,
- typename = detail::enable_if_t<detail::all_of<detail::is_keyword_or_ds<Args>...>::value>,
- // MSVC workaround: it can't compile an out-of-line definition, so defer the collector
- typename collector = detail::deferred_t<detail::unpacking_collector<>, Args...>>
- explicit dict(Args &&...args) : dict(collector(std::forward<Args>(args)...).kwargs()) { }
-
- size_t size() const { return (size_t) PyDict_Size(m_ptr); }
- detail::dict_iterator begin() const { return {*this, 0}; }
- detail::dict_iterator end() const { return {}; }
- void clear() const { PyDict_Clear(ptr()); }
- bool contains(handle key) const { return PyDict_Contains(ptr(), key.ptr()) == 1; }
- bool contains(const char *key) const { return PyDict_Contains(ptr(), pybind11::str(key).ptr()) == 1; }
-
-private:
- /// Call the `dict` Python type -- always returns a new reference
- static PyObject *raw_dict(PyObject *op) {
- if (PyDict_Check(op))
- return handle(op).inc_ref().ptr();
- return PyObject_CallFunctionObjArgs((PyObject *) &PyDict_Type, op, nullptr);
- }
-};
-
-class sequence : public object {
-public:
- PYBIND11_OBJECT_DEFAULT(sequence, object, PySequence_Check)
- size_t size() const { return (size_t) PySequence_Size(m_ptr); }
- detail::sequence_accessor operator[](size_t index) const { return {*this, index}; }
- detail::sequence_iterator begin() const { return {*this, 0}; }
- detail::sequence_iterator end() const { return {*this, PySequence_Size(m_ptr)}; }
-};
-
-class list : public object {
-public:
- PYBIND11_OBJECT_CVT(list, object, PyList_Check, PySequence_List)
- explicit list(size_t size = 0) : object(PyList_New((ssize_t) size), stolen) {
- if (!m_ptr) pybind11_fail("Could not allocate list object!");
- }
- size_t size() const { return (size_t) PyList_Size(m_ptr); }
- detail::list_accessor operator[](size_t index) const { return {*this, index}; }
- detail::list_iterator begin() const { return {*this, 0}; }
- detail::list_iterator end() const { return {*this, PyList_GET_SIZE(m_ptr)}; }
- template <typename T> void append(T &&val) const {
- PyList_Append(m_ptr, detail::object_or_cast(std::forward<T>(val)).ptr());
- }
-};
-
-class args : public tuple { PYBIND11_OBJECT_DEFAULT(args, tuple, PyTuple_Check) };
-class kwargs : public dict { PYBIND11_OBJECT_DEFAULT(kwargs, dict, PyDict_Check) };
-
-class set : public object {
-public:
- PYBIND11_OBJECT_CVT(set, object, PySet_Check, PySet_New)
- set() : object(PySet_New(nullptr), stolen) {
- if (!m_ptr) pybind11_fail("Could not allocate set object!");
- }
- size_t size() const { return (size_t) PySet_Size(m_ptr); }
- template <typename T> bool add(T &&val) const {
- return PySet_Add(m_ptr, detail::object_or_cast(std::forward<T>(val)).ptr()) == 0;
- }
- void clear() const { PySet_Clear(m_ptr); }
-};
-
-class function : public object {
-public:
- PYBIND11_OBJECT_DEFAULT(function, object, PyCallable_Check)
- bool is_cpp_function() const {
- handle fun = detail::get_function(m_ptr);
- return fun && PyCFunction_Check(fun.ptr());
- }
-};
-
-class buffer : public object {
-public:
- PYBIND11_OBJECT_DEFAULT(buffer, object, PyObject_CheckBuffer)
-
- buffer_info request(bool writable = false) {
- int flags = PyBUF_STRIDES | PyBUF_FORMAT;
- if (writable) flags |= PyBUF_WRITABLE;
- Py_buffer *view = new Py_buffer();
- if (PyObject_GetBuffer(m_ptr, view, flags) != 0)
- throw error_already_set();
- return buffer_info(view);
- }
-};
-
-class memoryview : public object {
-public:
- explicit memoryview(const buffer_info& info) {
- static Py_buffer buf { };
- // Py_buffer uses signed sizes, strides and shape!..
- static std::vector<Py_ssize_t> py_strides { };
- static std::vector<Py_ssize_t> py_shape { };
- buf.buf = info.ptr;
- buf.itemsize = (Py_ssize_t) info.itemsize;
- buf.format = const_cast<char *>(info.format.c_str());
- buf.ndim = (int) info.ndim;
- buf.len = (Py_ssize_t) info.size;
- py_strides.clear();
- py_shape.clear();
- for (size_t i = 0; i < info.ndim; ++i) {
- py_strides.push_back((Py_ssize_t) info.strides[i]);
- py_shape.push_back((Py_ssize_t) info.shape[i]);
- }
- buf.strides = py_strides.data();
- buf.shape = py_shape.data();
- buf.suboffsets = nullptr;
- buf.readonly = false;
- buf.internal = nullptr;
-
- m_ptr = PyMemoryView_FromBuffer(&buf);
- if (!m_ptr)
- pybind11_fail("Unable to create memoryview from buffer descriptor");
- }
-
- PYBIND11_OBJECT_CVT(memoryview, object, PyMemoryView_Check, PyMemoryView_FromObject)
-};
-/// @} pytypes
-
-/// \addtogroup python_builtins
-/// @{
-inline size_t len(handle h) {
- ssize_t result = PyObject_Length(h.ptr());
- if (result < 0)
- pybind11_fail("Unable to compute length of object");
- return (size_t) result;
-}
-
-inline str repr(handle h) {
- PyObject *str_value = PyObject_Repr(h.ptr());
- if (!str_value) throw error_already_set();
-#if PY_MAJOR_VERSION < 3
- PyObject *unicode = PyUnicode_FromEncodedObject(str_value, "utf-8", nullptr);
- Py_XDECREF(str_value); str_value = unicode;
- if (!str_value) throw error_already_set();
-#endif
- return reinterpret_steal<str>(str_value);
-}
-
-inline iterator iter(handle obj) {
- PyObject *result = PyObject_GetIter(obj.ptr());
- if (!result) { throw error_already_set(); }
- return reinterpret_steal<iterator>(result);
-}
-/// @} python_builtins
-
-NAMESPACE_BEGIN(detail)
-template <typename D> iterator object_api<D>::begin() const { return iter(derived()); }
-template <typename D> iterator object_api<D>::end() const { return iterator::sentinel(); }
-template <typename D> item_accessor object_api<D>::operator[](handle key) const {
- return {derived(), reinterpret_borrow<object>(key)};
-}
-template <typename D> item_accessor object_api<D>::operator[](const char *key) const {
- return {derived(), pybind11::str(key)};
-}
-template <typename D> obj_attr_accessor object_api<D>::attr(handle key) const {
- return {derived(), reinterpret_borrow<object>(key)};
-}
-template <typename D> str_attr_accessor object_api<D>::attr(const char *key) const {
- return {derived(), key};
-}
-template <typename D> args_proxy object_api<D>::operator*() const {
- return args_proxy(derived().ptr());
-}
-template <typename D> template <typename T> bool object_api<D>::contains(T &&item) const {
- return attr("__contains__")(std::forward<T>(item)).template cast<bool>();
-}
-
-template <typename D>
-pybind11::str object_api<D>::str() const { return pybind11::str(derived()); }
-
-template <typename D>
-handle object_api<D>::get_type() const { return (PyObject *) Py_TYPE(derived().ptr()); }
-
-NAMESPACE_END(detail)
-NAMESPACE_END(pybind11)
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/stl.h b/thirdparty/pybind11/pybind11/include/pybind11/stl.h
deleted file mode 100644
index 4b557bd16f8e4125be4545e8faad479793137356..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/stl.h
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
- pybind11/stl.h: Transparent conversion for STL data types
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "pybind11.h"
-#include <set>
-#include <unordered_set>
-#include <map>
-#include <unordered_map>
-#include <iostream>
-#include <list>
-#include <valarray>
-
-#if defined(_MSC_VER)
-#pragma warning(push)
-#pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
-#endif
-
-#ifdef __has_include
-// std::optional (but including it in c++14 mode isn't allowed)
-# if defined(PYBIND11_CPP17) && __has_include(<optional>)
-# include <optional>
-# define PYBIND11_HAS_OPTIONAL 1
-# endif
-// std::experimental::optional (but not allowed in c++11 mode)
-# if defined(PYBIND11_CPP14) && __has_include(<experimental/optional>)
-# include <experimental/optional>
-# if __cpp_lib_experimental_optional // just in case
-# define PYBIND11_HAS_EXP_OPTIONAL 1
-# endif
-# endif
-#endif
-
-NAMESPACE_BEGIN(pybind11)
-NAMESPACE_BEGIN(detail)
-
-template <typename Type, typename Key> struct set_caster {
- using type = Type;
- using key_conv = make_caster<Key>;
-
- bool load(handle src, bool convert) {
- if (!isinstance<pybind11::set>(src))
- return false;
- auto s = reinterpret_borrow<pybind11::set>(src);
- value.clear();
- key_conv conv;
- for (auto entry : s) {
- if (!conv.load(entry, convert))
- return false;
- value.insert(cast_op<Key>(conv));
- }
- return true;
- }
-
- static handle cast(const type &src, return_value_policy policy, handle parent) {
- pybind11::set s;
- for (auto const &value: src) {
- auto value_ = reinterpret_steal<object>(key_conv::cast(value, policy, parent));
- if (!value_ || !s.add(value_))
- return handle();
- }
- return s.release();
- }
-
- PYBIND11_TYPE_CASTER(type, _("Set[") + key_conv::name() + _("]"));
-};
-
-template <typename Type, typename Key, typename Value> struct map_caster {
- using key_conv = make_caster<Key>;
- using value_conv = make_caster<Value>;
-
- bool load(handle src, bool convert) {
- if (!isinstance<dict>(src))
- return false;
- auto d = reinterpret_borrow<dict>(src);
- key_conv kconv;
- value_conv vconv;
- value.clear();
- for (auto it : d) {
- if (!kconv.load(it.first.ptr(), convert) ||
- !vconv.load(it.second.ptr(), convert))
- return false;
- value.emplace(cast_op<Key>(kconv), cast_op<Value>(vconv));
- }
- return true;
- }
-
- static handle cast(const Type &src, return_value_policy policy, handle parent) {
- dict d;
- for (auto const &kv: src) {
- auto key = reinterpret_steal<object>(key_conv::cast(kv.first, policy, parent));
- auto value = reinterpret_steal<object>(value_conv::cast(kv.second, policy, parent));
- if (!key || !value)
- return handle();
- d[key] = value;
- }
- return d.release();
- }
-
- PYBIND11_TYPE_CASTER(Type, _("Dict[") + key_conv::name() + _(", ") + value_conv::name() + _("]"));
-};
-
-template <typename Type, typename Value> struct list_caster {
- using value_conv = make_caster<Value>;
-
- bool load(handle src, bool convert) {
- if (!isinstance<sequence>(src))
- return false;
- auto s = reinterpret_borrow<sequence>(src);
- value_conv conv;
- value.clear();
- reserve_maybe(s, &value);
- for (auto it : s) {
- if (!conv.load(it, convert))
- return false;
- value.push_back(cast_op<Value>(conv));
- }
- return true;
- }
-
-private:
- template <typename T = Type,
- enable_if_t<std::is_same<decltype(std::declval<T>().reserve(0)), void>::value, int> = 0>
- void reserve_maybe(sequence s, Type *) { value.reserve(s.size()); }
- void reserve_maybe(sequence, void *) { }
-
-public:
- static handle cast(const Type &src, return_value_policy policy, handle parent) {
- list l(src.size());
- size_t index = 0;
- for (auto const &value: src) {
- auto value_ = reinterpret_steal<object>(value_conv::cast(value, policy, parent));
- if (!value_)
- return handle();
- PyList_SET_ITEM(l.ptr(), (ssize_t) index++, value_.release().ptr()); // steals a reference
- }
- return l.release();
- }
-
- PYBIND11_TYPE_CASTER(Type, _("List[") + value_conv::name() + _("]"));
-};
-
-template <typename Type, typename Alloc> struct type_caster<std::vector<Type, Alloc>>
- : list_caster<std::vector<Type, Alloc>, Type> { };
-
-template <typename Type, typename Alloc> struct type_caster<std::list<Type, Alloc>>
- : list_caster<std::list<Type, Alloc>, Type> { };
-
-template <typename ArrayType, typename Value, bool Resizable, size_t Size = 0> struct array_caster {
- using value_conv = make_caster<Value>;
-
-private:
- template <bool R = Resizable>
- bool require_size(enable_if_t<R, size_t> size) {
- if (value.size() != size)
- value.resize(size);
- return true;
- }
- template <bool R = Resizable>
- bool require_size(enable_if_t<!R, size_t> size) {
- return size == Size;
- }
-
-public:
- bool load(handle src, bool convert) {
- if (!isinstance<list>(src))
- return false;
- auto l = reinterpret_borrow<list>(src);
- if (!require_size(l.size()))
- return false;
- value_conv conv;
- size_t ctr = 0;
- for (auto it : l) {
- if (!conv.load(it, convert))
- return false;
- value[ctr++] = cast_op<Value>(conv);
- }
- return true;
- }
-
- static handle cast(const ArrayType &src, return_value_policy policy, handle parent) {
- list l(src.size());
- size_t index = 0;
- for (auto const &value: src) {
- auto value_ = reinterpret_steal<object>(value_conv::cast(value, policy, parent));
- if (!value_)
- return handle();
- PyList_SET_ITEM(l.ptr(), (ssize_t) index++, value_.release().ptr()); // steals a reference
- }
- return l.release();
- }
-
- PYBIND11_TYPE_CASTER(ArrayType, _("List[") + value_conv::name() + _<Resizable>(_(""), _("[") + _<Size>() + _("]")) + _("]"));
-};
-
-template <typename Type, size_t Size> struct type_caster<std::array<Type, Size>>
- : array_caster<std::array<Type, Size>, Type, false, Size> { };
-
-template <typename Type> struct type_caster<std::valarray<Type>>
- : array_caster<std::valarray<Type>, Type, true> { };
-
-template <typename Key, typename Compare, typename Alloc> struct type_caster<std::set<Key, Compare, Alloc>>
- : set_caster<std::set<Key, Compare, Alloc>, Key> { };
-
-template <typename Key, typename Hash, typename Equal, typename Alloc> struct type_caster<std::unordered_set<Key, Hash, Equal, Alloc>>
- : set_caster<std::unordered_set<Key, Hash, Equal, Alloc>, Key> { };
-
-template <typename Key, typename Value, typename Compare, typename Alloc> struct type_caster<std::map<Key, Value, Compare, Alloc>>
- : map_caster<std::map<Key, Value, Compare, Alloc>, Key, Value> { };
-
-template <typename Key, typename Value, typename Hash, typename Equal, typename Alloc> struct type_caster<std::unordered_map<Key, Value, Hash, Equal, Alloc>>
- : map_caster<std::unordered_map<Key, Value, Hash, Equal, Alloc>, Key, Value> { };
-
-// This type caster is intended to be used for std::optional and std::experimental::optional
-template<typename T> struct optional_caster {
- using value_conv = make_caster<typename T::value_type>;
-
- static handle cast(const T& src, return_value_policy policy, handle parent) {
- if (!src)
- return none().inc_ref();
- return value_conv::cast(*src, policy, parent);
- }
-
- bool load(handle src, bool convert) {
- if (!src) {
- return false;
- } else if (src.is_none()) {
- value = {}; // nullopt
- return true;
- }
- value_conv inner_caster;
- if (!inner_caster.load(src, convert))
- return false;
-
- value.emplace(cast_op<typename T::value_type>(inner_caster));
- return true;
- }
-
- PYBIND11_TYPE_CASTER(T, _("Optional[") + value_conv::name() + _("]"));
-};
-
-#if PYBIND11_HAS_OPTIONAL
-template<typename T> struct type_caster<std::optional<T>>
- : public optional_caster<std::optional<T>> {};
-
-template<> struct type_caster<std::nullopt_t>
- : public void_caster<std::nullopt_t> {};
-#endif
-
-#if PYBIND11_HAS_EXP_OPTIONAL
-template<typename T> struct type_caster<std::experimental::optional<T>>
- : public optional_caster<std::experimental::optional<T>> {};
-
-template<> struct type_caster<std::experimental::nullopt_t>
- : public void_caster<std::experimental::nullopt_t> {};
-#endif
-
-NAMESPACE_END(detail)
-
-inline std::ostream &operator<<(std::ostream &os, const handle &obj) {
- os << (std::string) str(obj);
- return os;
-}
-
-NAMESPACE_END(pybind11)
-
-#if defined(_MSC_VER)
-#pragma warning(pop)
-#endif
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/stl_bind.h b/thirdparty/pybind11/pybind11/include/pybind11/stl_bind.h
deleted file mode 100644
index 8971882203ba8ac7822e6803cdffe9e82b22d651..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/stl_bind.h
+++ /dev/null
@@ -1,587 +0,0 @@
-/*
- pybind11/std_bind.h: Binding generators for STL data types
-
- Copyright (c) 2016 Sergey Lyskov and Wenzel Jakob
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include "common.h"
-#include "operators.h"
-
-#include <algorithm>
-#include <sstream>
-
-NAMESPACE_BEGIN(pybind11)
-NAMESPACE_BEGIN(detail)
-
-/* SFINAE helper class used by 'is_comparable */
-template <typename T> struct container_traits {
- template <typename T2> static std::true_type test_comparable(decltype(std::declval<const T2 &>() == std::declval<const T2 &>())*);
- template <typename T2> static std::false_type test_comparable(...);
- template <typename T2> static std::true_type test_value(typename T2::value_type *);
- template <typename T2> static std::false_type test_value(...);
- template <typename T2> static std::true_type test_pair(typename T2::first_type *, typename T2::second_type *);
- template <typename T2> static std::false_type test_pair(...);
-
- static constexpr const bool is_comparable = std::is_same<std::true_type, decltype(test_comparable<T>(nullptr))>::value;
- static constexpr const bool is_pair = std::is_same<std::true_type, decltype(test_pair<T>(nullptr, nullptr))>::value;
- static constexpr const bool is_vector = std::is_same<std::true_type, decltype(test_value<T>(nullptr))>::value;
- static constexpr const bool is_element = !is_pair && !is_vector;
-};
-
-/* Default: is_comparable -> std::false_type */
-template <typename T, typename SFINAE = void>
-struct is_comparable : std::false_type { };
-
-/* For non-map data structures, check whether operator== can be instantiated */
-template <typename T>
-struct is_comparable<
- T, enable_if_t<container_traits<T>::is_element &&
- container_traits<T>::is_comparable>>
- : std::true_type { };
-
-/* For a vector/map data structure, recursively check the value type (which is std::pair for maps) */
-template <typename T>
-struct is_comparable<T, enable_if_t<container_traits<T>::is_vector>> {
- static constexpr const bool value =
- is_comparable<typename T::value_type>::value;
-};
-
-/* For pairs, recursively check the two data types */
-template <typename T>
-struct is_comparable<T, enable_if_t<container_traits<T>::is_pair>> {
- static constexpr const bool value =
- is_comparable<typename T::first_type>::value &&
- is_comparable<typename T::second_type>::value;
-};
-
-/* Fallback functions */
-template <typename, typename, typename... Args> void vector_if_copy_constructible(const Args &...) { }
-template <typename, typename, typename... Args> void vector_if_equal_operator(const Args &...) { }
-template <typename, typename, typename... Args> void vector_if_insertion_operator(const Args &...) { }
-template <typename, typename, typename... Args> void vector_modifiers(const Args &...) { }
-
-template<typename Vector, typename Class_>
-void vector_if_copy_constructible(enable_if_t<
- std::is_copy_constructible<Vector>::value &&
- std::is_copy_constructible<typename Vector::value_type>::value, Class_> &cl) {
-
- cl.def(init<const Vector &>(), "Copy constructor");
-}
-
-template<typename Vector, typename Class_>
-void vector_if_equal_operator(enable_if_t<is_comparable<Vector>::value, Class_> &cl) {
- using T = typename Vector::value_type;
-
- cl.def(self == self);
- cl.def(self != self);
-
- cl.def("count",
- [](const Vector &v, const T &x) {
- return std::count(v.begin(), v.end(), x);
- },
- arg("x"),
- "Return the number of times ``x`` appears in the list"
- );
-
- cl.def("remove", [](Vector &v, const T &x) {
- auto p = std::find(v.begin(), v.end(), x);
- if (p != v.end())
- v.erase(p);
- else
- throw value_error();
- },
- arg("x"),
- "Remove the first item from the list whose value is x. "
- "It is an error if there is no such item."
- );
-
- cl.def("__contains__",
- [](const Vector &v, const T &x) {
- return std::find(v.begin(), v.end(), x) != v.end();
- },
- arg("x"),
- "Return true the container contains ``x``"
- );
-}
-
-// Vector modifiers -- requires a copyable vector_type:
-// (Technically, some of these (pop and __delitem__) don't actually require copyability, but it seems
-// silly to allow deletion but not insertion, so include them here too.)
-template <typename Vector, typename Class_>
-void vector_modifiers(enable_if_t<std::is_copy_constructible<typename Vector::value_type>::value, Class_> &cl) {
- using T = typename Vector::value_type;
- using SizeType = typename Vector::size_type;
- using DiffType = typename Vector::difference_type;
-
- cl.def("append",
- [](Vector &v, const T &value) { v.push_back(value); },
- arg("x"),
- "Add an item to the end of the list");
-
- cl.def("__init__", [](Vector &v, iterable it) {
- new (&v) Vector();
- try {
- v.reserve(len(it));
- for (handle h : it)
- v.push_back(h.cast<T>());
- } catch (...) {
- v.~Vector();
- throw;
- }
- });
-
- cl.def("extend",
- [](Vector &v, const Vector &src) {
- v.reserve(v.size() + src.size());
- v.insert(v.end(), src.begin(), src.end());
- },
- arg("L"),
- "Extend the list by appending all the items in the given list"
- );
-
- cl.def("insert",
- [](Vector &v, SizeType i, const T &x) {
- v.insert(v.begin() + (DiffType) i, x);
- },
- arg("i") , arg("x"),
- "Insert an item at a given position."
- );
-
- cl.def("pop",
- [](Vector &v) {
- if (v.empty())
- throw index_error();
- T t = v.back();
- v.pop_back();
- return t;
- },
- "Remove and return the last item"
- );
-
- cl.def("pop",
- [](Vector &v, SizeType i) {
- if (i >= v.size())
- throw index_error();
- T t = v[i];
- v.erase(v.begin() + (DiffType) i);
- return t;
- },
- arg("i"),
- "Remove and return the item at index ``i``"
- );
-
- cl.def("__setitem__",
- [](Vector &v, SizeType i, const T &t) {
- if (i >= v.size())
- throw index_error();
- v[i] = t;
- }
- );
-
- /// Slicing protocol
- cl.def("__getitem__",
- [](const Vector &v, slice slice) -> Vector * {
- size_t start, stop, step, slicelength;
-
- if (!slice.compute(v.size(), &start, &stop, &step, &slicelength))
- throw error_already_set();
-
- Vector *seq = new Vector();
- seq->reserve((size_t) slicelength);
-
- for (size_t i=0; i<slicelength; ++i) {
- seq->push_back(v[start]);
- start += step;
- }
- return seq;
- },
- arg("s"),
- "Retrieve list elements using a slice object"
- );
-
- cl.def("__setitem__",
- [](Vector &v, slice slice, const Vector &value) {
- size_t start, stop, step, slicelength;
- if (!slice.compute(v.size(), &start, &stop, &step, &slicelength))
- throw error_already_set();
-
- if (slicelength != value.size())
- throw std::runtime_error("Left and right hand size of slice assignment have different sizes!");
-
- for (size_t i=0; i<slicelength; ++i) {
- v[start] = value[i];
- start += step;
- }
- },
- "Assign list elements using a slice object"
- );
-
- cl.def("__delitem__",
- [](Vector &v, SizeType i) {
- if (i >= v.size())
- throw index_error();
- v.erase(v.begin() + DiffType(i));
- },
- "Delete the list elements at index ``i``"
- );
-
- cl.def("__delitem__",
- [](Vector &v, slice slice) {
- size_t start, stop, step, slicelength;
-
- if (!slice.compute(v.size(), &start, &stop, &step, &slicelength))
- throw error_already_set();
-
- if (step == 1 && false) {
- v.erase(v.begin() + (DiffType) start, v.begin() + DiffType(start + slicelength));
- } else {
- for (size_t i = 0; i < slicelength; ++i) {
- v.erase(v.begin() + DiffType(start));
- start += step - 1;
- }
- }
- },
- "Delete list elements using a slice object"
- );
-
-}
-
-// If the type has an operator[] that doesn't return a reference (most notably std::vector<bool>),
-// we have to access by copying; otherwise we return by reference.
-template <typename Vector> using vector_needs_copy = negation<
- std::is_same<decltype(std::declval<Vector>()[typename Vector::size_type()]), typename Vector::value_type &>>;
-
-// The usual case: access and iterate by reference
-template <typename Vector, typename Class_>
-void vector_accessor(enable_if_t<!vector_needs_copy<Vector>::value, Class_> &cl) {
- using T = typename Vector::value_type;
- using SizeType = typename Vector::size_type;
- using ItType = typename Vector::iterator;
-
- cl.def("__getitem__",
- [](Vector &v, SizeType i) -> T & {
- if (i >= v.size())
- throw index_error();
- return v[i];
- },
- return_value_policy::reference_internal // ref + keepalive
- );
-
- cl.def("__iter__",
- [](Vector &v) {
- return make_iterator<
- return_value_policy::reference_internal, ItType, ItType, T&>(
- v.begin(), v.end());
- },
- keep_alive<0, 1>() /* Essential: keep list alive while iterator exists */
- );
-}
-
-// The case for special objects, like std::vector<bool>, that have to be returned-by-copy:
-template <typename Vector, typename Class_>
-void vector_accessor(enable_if_t<vector_needs_copy<Vector>::value, Class_> &cl) {
- using T = typename Vector::value_type;
- using SizeType = typename Vector::size_type;
- using ItType = typename Vector::iterator;
- cl.def("__getitem__",
- [](const Vector &v, SizeType i) -> T {
- if (i >= v.size())
- throw index_error();
- return v[i];
- }
- );
-
- cl.def("__iter__",
- [](Vector &v) {
- return make_iterator<
- return_value_policy::copy, ItType, ItType, T>(
- v.begin(), v.end());
- },
- keep_alive<0, 1>() /* Essential: keep list alive while iterator exists */
- );
-}
-
-template <typename Vector, typename Class_> auto vector_if_insertion_operator(Class_ &cl, std::string const &name)
- -> decltype(std::declval<std::ostream&>() << std::declval<typename Vector::value_type>(), void()) {
- using size_type = typename Vector::size_type;
-
- cl.def("__repr__",
- [name](Vector &v) {
- std::ostringstream s;
- s << name << '[';
- for (size_type i=0; i < v.size(); ++i) {
- s << v[i];
- if (i != v.size() - 1)
- s << ", ";
- }
- s << ']';
- return s.str();
- },
- "Return the canonical string representation of this list."
- );
-}
-
-// Provide the buffer interface for vectors if we have data() and we have a format for it
-// GCC seems to have "void std::vector<bool>::data()" - doing SFINAE on the existence of data() is insufficient, we need to check it returns an appropriate pointer
-template <typename Vector, typename = void>
-struct vector_has_data_and_format : std::false_type {};
-template <typename Vector>
-struct vector_has_data_and_format<Vector, enable_if_t<std::is_same<decltype(format_descriptor<typename Vector::value_type>::format(), std::declval<Vector>().data()), typename Vector::value_type*>::value>> : std::true_type {};
-
-// Add the buffer interface to a vector
-template <typename Vector, typename Class_, typename... Args>
-enable_if_t<detail::any_of<std::is_same<Args, buffer_protocol>...>::value>
-vector_buffer(Class_& cl) {
- using T = typename Vector::value_type;
-
- static_assert(vector_has_data_and_format<Vector>::value, "There is not an appropriate format descriptor for this vector");
-
- // numpy.h declares this for arbitrary types, but it may raise an exception and crash hard at runtime if PYBIND11_NUMPY_DTYPE hasn't been called, so check here
- format_descriptor<T>::format();
-
- cl.def_buffer([](Vector& v) -> buffer_info {
- return buffer_info(v.data(), sizeof(T), format_descriptor<T>::format(), 1, {v.size()}, {sizeof(T)});
- });
-
- cl.def("__init__", [](Vector& vec, buffer buf) {
- auto info = buf.request();
- if (info.ndim != 1 || info.strides[0] <= 0 || info.strides[0] % sizeof(T))
- throw type_error("Only valid 1D buffers can be copied to a vector");
- if (!detail::compare_buffer_info<T>::compare(info) || sizeof(T) != info.itemsize)
- throw type_error("Format mismatch (Python: " + info.format + " C++: " + format_descriptor<T>::format() + ")");
- new (&vec) Vector();
- vec.reserve(info.shape[0]);
- T *p = static_cast<T*>(info.ptr);
- auto step = info.strides[0] / sizeof(T);
- T *end = p + info.shape[0] * step;
- for (; p < end; p += step)
- vec.push_back(*p);
- });
-
- return;
-}
-
-template <typename Vector, typename Class_, typename... Args>
-enable_if_t<!detail::any_of<std::is_same<Args, buffer_protocol>...>::value> vector_buffer(Class_&) {}
-
-NAMESPACE_END(detail)
-
-//
-// std::vector
-//
-template <typename Vector, typename holder_type = std::unique_ptr<Vector>, typename... Args>
-class_<Vector, holder_type> bind_vector(module &m, std::string const &name, Args&&... args) {
- using Class_ = class_<Vector, holder_type>;
-
- Class_ cl(m, name.c_str(), std::forward<Args>(args)...);
-
- // Declare the buffer interface if a buffer_protocol() is passed in
- detail::vector_buffer<Vector, Class_, Args...>(cl);
-
- cl.def(init<>());
-
- // Register copy constructor (if possible)
- detail::vector_if_copy_constructible<Vector, Class_>(cl);
-
- // Register comparison-related operators and functions (if possible)
- detail::vector_if_equal_operator<Vector, Class_>(cl);
-
- // Register stream insertion operator (if possible)
- detail::vector_if_insertion_operator<Vector, Class_>(cl, name);
-
- // Modifiers require copyable vector value type
- detail::vector_modifiers<Vector, Class_>(cl);
-
- // Accessor and iterator; return by value if copyable, otherwise we return by ref + keep-alive
- detail::vector_accessor<Vector, Class_>(cl);
-
- cl.def("__bool__",
- [](const Vector &v) -> bool {
- return !v.empty();
- },
- "Check whether the list is nonempty"
- );
-
- cl.def("__len__", &Vector::size);
-
-
-
-
-#if 0
- // C++ style functions deprecated, leaving it here as an example
- cl.def(init<size_type>());
-
- cl.def("resize",
- (void (Vector::*) (size_type count)) & Vector::resize,
- "changes the number of elements stored");
-
- cl.def("erase",
- [](Vector &v, SizeType i) {
- if (i >= v.size())
- throw index_error();
- v.erase(v.begin() + i);
- }, "erases element at index ``i``");
-
- cl.def("empty", &Vector::empty, "checks whether the container is empty");
- cl.def("size", &Vector::size, "returns the number of elements");
- cl.def("push_back", (void (Vector::*)(const T&)) &Vector::push_back, "adds an element to the end");
- cl.def("pop_back", &Vector::pop_back, "removes the last element");
-
- cl.def("max_size", &Vector::max_size, "returns the maximum possible number of elements");
- cl.def("reserve", &Vector::reserve, "reserves storage");
- cl.def("capacity", &Vector::capacity, "returns the number of elements that can be held in currently allocated storage");
- cl.def("shrink_to_fit", &Vector::shrink_to_fit, "reduces memory usage by freeing unused memory");
-
- cl.def("clear", &Vector::clear, "clears the contents");
- cl.def("swap", &Vector::swap, "swaps the contents");
-
- cl.def("front", [](Vector &v) {
- if (v.size()) return v.front();
- else throw index_error();
- }, "access the first element");
-
- cl.def("back", [](Vector &v) {
- if (v.size()) return v.back();
- else throw index_error();
- }, "access the last element ");
-
-#endif
-
- return cl;
-}
-
-
-
-//
-// std::map, std::unordered_map
-//
-
-NAMESPACE_BEGIN(detail)
-
-/* Fallback functions */
-template <typename, typename, typename... Args> void map_if_insertion_operator(const Args &...) { }
-template <typename, typename, typename... Args> void map_assignment(const Args &...) { }
-
-// Map assignment when copy-assignable: just copy the value
-template <typename Map, typename Class_>
-void map_assignment(enable_if_t<std::is_copy_assignable<typename Map::mapped_type>::value, Class_> &cl) {
- using KeyType = typename Map::key_type;
- using MappedType = typename Map::mapped_type;
-
- cl.def("__setitem__",
- [](Map &m, const KeyType &k, const MappedType &v) {
- auto it = m.find(k);
- if (it != m.end()) it->second = v;
- else m.emplace(k, v);
- }
- );
-}
-
-// Not copy-assignable, but still copy-constructible: we can update the value by erasing and reinserting
-template<typename Map, typename Class_>
-void map_assignment(enable_if_t<
- !std::is_copy_assignable<typename Map::mapped_type>::value &&
- std::is_copy_constructible<typename Map::mapped_type>::value,
- Class_> &cl) {
- using KeyType = typename Map::key_type;
- using MappedType = typename Map::mapped_type;
-
- cl.def("__setitem__",
- [](Map &m, const KeyType &k, const MappedType &v) {
- // We can't use m[k] = v; because value type might not be default constructable
- auto r = m.emplace(k, v);
- if (!r.second) {
- // value type is not copy assignable so the only way to insert it is to erase it first...
- m.erase(r.first);
- m.emplace(k, v);
- }
- }
- );
-}
-
-
-template <typename Map, typename Class_> auto map_if_insertion_operator(Class_ &cl, std::string const &name)
--> decltype(std::declval<std::ostream&>() << std::declval<typename Map::key_type>() << std::declval<typename Map::mapped_type>(), void()) {
-
- cl.def("__repr__",
- [name](Map &m) {
- std::ostringstream s;
- s << name << '{';
- bool f = false;
- for (auto const &kv : m) {
- if (f)
- s << ", ";
- s << kv.first << ": " << kv.second;
- f = true;
- }
- s << '}';
- return s.str();
- },
- "Return the canonical string representation of this map."
- );
-}
-
-
-NAMESPACE_END(detail)
-
-template <typename Map, typename holder_type = std::unique_ptr<Map>, typename... Args>
-class_<Map, holder_type> bind_map(module &m, const std::string &name, Args&&... args) {
- using KeyType = typename Map::key_type;
- using MappedType = typename Map::mapped_type;
- using Class_ = class_<Map, holder_type>;
-
- Class_ cl(m, name.c_str(), std::forward<Args>(args)...);
-
- cl.def(init<>());
-
- // Register stream insertion operator (if possible)
- detail::map_if_insertion_operator<Map, Class_>(cl, name);
-
- cl.def("__bool__",
- [](const Map &m) -> bool { return !m.empty(); },
- "Check whether the map is nonempty"
- );
-
- cl.def("__iter__",
- [](Map &m) { return make_key_iterator(m.begin(), m.end()); },
- keep_alive<0, 1>() /* Essential: keep list alive while iterator exists */
- );
-
- cl.def("items",
- [](Map &m) { return make_iterator(m.begin(), m.end()); },
- keep_alive<0, 1>() /* Essential: keep list alive while iterator exists */
- );
-
- cl.def("__getitem__",
- [](Map &m, const KeyType &k) -> MappedType & {
- auto it = m.find(k);
- if (it == m.end())
- throw key_error();
- return it->second;
- },
- return_value_policy::reference_internal // ref + keepalive
- );
-
- // Assignment provided only if the type is copyable
- detail::map_assignment<Map, Class_>(cl);
-
- cl.def("__delitem__",
- [](Map &m, const KeyType &k) {
- auto it = m.find(k);
- if (it == m.end())
- throw key_error();
- return m.erase(it);
- }
- );
-
- cl.def("__len__", &Map::size);
-
- return cl;
-}
-
-NAMESPACE_END(pybind11)
diff --git a/thirdparty/pybind11/pybind11/include/pybind11/typeid.h b/thirdparty/pybind11/pybind11/include/pybind11/typeid.h
deleted file mode 100644
index c903fb14cb1fdf787cfcb044181bb3b652cb286d..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/include/pybind11/typeid.h
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- pybind11/typeid.h: Compiler-independent access to type identifiers
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#pragma once
-
-#include <cstdio>
-#include <cstdlib>
-
-#if defined(__GNUG__)
-#include <cxxabi.h>
-#endif
-
-NAMESPACE_BEGIN(pybind11)
-NAMESPACE_BEGIN(detail)
-/// Erase all occurrences of a substring
-inline void erase_all(std::string &string, const std::string &search) {
- for (size_t pos = 0;;) {
- pos = string.find(search, pos);
- if (pos == std::string::npos) break;
- string.erase(pos, search.length());
- }
-}
-
-PYBIND11_NOINLINE inline void clean_type_id(std::string &name) {
-#if defined(__GNUG__)
- int status = 0;
- std::unique_ptr<char, void (*)(void *)> res {
- abi::__cxa_demangle(name.c_str(), nullptr, nullptr, &status), std::free };
- if (status == 0)
- name = res.get();
-#else
- detail::erase_all(name, "class ");
- detail::erase_all(name, "struct ");
- detail::erase_all(name, "enum ");
-#endif
- detail::erase_all(name, "pybind11::");
-}
-NAMESPACE_END(detail)
-
-/// Return a string representation of a C++ type
-template <typename T> static std::string type_id() {
- std::string name(typeid(T).name());
- detail::clean_type_id(name);
- return name;
-}
-
-NAMESPACE_END(pybind11)
diff --git a/thirdparty/pybind11/pybind11/pybind11/__init__.py b/thirdparty/pybind11/pybind11/pybind11/__init__.py
deleted file mode 100644
index a765692feada946fb8ef8dcd084a2836689fa3ca..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/pybind11/__init__.py
+++ /dev/null
@@ -1,11 +0,0 @@
-from ._version import version_info, __version__ # noqa: F401 imported but unused
-
-
-def get_include(*args, **kwargs):
- import os
- try:
- from pip import locations
- return os.path.dirname(
- locations.distutils_scheme('pybind11', *args, **kwargs)['headers'])
- except ImportError:
- return 'include'
diff --git a/thirdparty/pybind11/pybind11/pybind11/_version.py b/thirdparty/pybind11/pybind11/pybind11/_version.py
deleted file mode 100644
index 2bb44f715c160b4d4825b718f950af1988e495a4..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/pybind11/_version.py
+++ /dev/null
@@ -1,2 +0,0 @@
-version_info = (2, 1, 1)
-__version__ = '.'.join(map(str, version_info))
diff --git a/thirdparty/pybind11/pybind11/setup.cfg b/thirdparty/pybind11/pybind11/setup.cfg
deleted file mode 100644
index 9e5e88d824171fd68083bcab9dc77fad942f6fbd..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/setup.cfg
+++ /dev/null
@@ -1,10 +0,0 @@
-[bdist_wheel]
-universal=1
-
-[flake8]
-max-line-length = 99
-show_source = True
-exclude = .git, __pycache__, build, dist, docs, tools, venv
-ignore =
- # required for pretty matrix formating: multiple spaces after `,` and `[`
- E201, E241
diff --git a/thirdparty/pybind11/pybind11/setup.py b/thirdparty/pybind11/pybind11/setup.py
deleted file mode 100644
index 0cf4e47ce22b34959c90fd5229609f037317a621..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/setup.py
+++ /dev/null
@@ -1,84 +0,0 @@
-#!/usr/bin/env python
-
-# Setup script for PyPI; use CMakeFile.txt to build extension modules
-
-from setuptools import setup
-from pybind11 import __version__
-import os
-
-# Prevent installation of pybind11 headers by setting
-# PYBIND11_USE_CMAKE.
-if os.environ.get('PYBIND11_USE_CMAKE'):
- headers = []
-else:
- headers = [
- 'include/pybind11/attr.h',
- 'include/pybind11/cast.h',
- 'include/pybind11/chrono.h',
- 'include/pybind11/class_support.h',
- 'include/pybind11/common.h',
- 'include/pybind11/complex.h',
- 'include/pybind11/descr.h',
- 'include/pybind11/eigen.h',
- 'include/pybind11/eval.h',
- 'include/pybind11/functional.h',
- 'include/pybind11/numpy.h',
- 'include/pybind11/operators.h',
- 'include/pybind11/options.h',
- 'include/pybind11/pybind11.h',
- 'include/pybind11/pytypes.h',
- 'include/pybind11/stl.h',
- 'include/pybind11/stl_bind.h',
- 'include/pybind11/typeid.h'
- ]
-
-setup(
- name='pybind11',
- version=__version__,
- description='Seamless operability between C++11 and Python',
- author='Wenzel Jakob',
- author_email='wenzel.jakob@epfl.ch',
- url='https://github.com/wjakob/pybind11',
- download_url='https://github.com/wjakob/pybind11/tarball/v' + __version__,
- packages=['pybind11'],
- license='BSD',
- headers=headers,
- classifiers=[
- 'Development Status :: 5 - Production/Stable',
- 'Intended Audience :: Developers',
- 'Topic :: Software Development :: Libraries :: Python Modules',
- 'Topic :: Utilities',
- 'Programming Language :: C++',
- 'Programming Language :: Python :: 2.7',
- 'Programming Language :: Python :: 3',
- 'Programming Language :: Python :: 3.2',
- 'Programming Language :: Python :: 3.3',
- 'Programming Language :: Python :: 3.4',
- 'Programming Language :: Python :: 3.5',
- 'Programming Language :: Python :: 3.6',
- 'License :: OSI Approved :: BSD License'
- ],
- keywords='C++11, Python bindings',
- long_description="""pybind11 is a lightweight header-only library that
-exposes C++ types in Python and vice versa, mainly to create Python bindings of
-existing C++ code. Its goals and syntax are similar to the excellent
-Boost.Python by David Abrahams: to minimize boilerplate code in traditional
-extension modules by inferring type information using compile-time
-introspection.
-
-The main issue with Boost.Python-and the reason for creating such a similar
-project-is Boost. Boost is an enormously large and complex suite of utility
-libraries that works with almost every C++ compiler in existence. This
-compatibility has its cost: arcane template tricks and workarounds are
-necessary to support the oldest and buggiest of compiler specimens. Now that
-C++11-compatible compilers are widely available, this heavy machinery has
-become an excessively large and unnecessary dependency.
-
-Think of this library as a tiny self-contained version of Boost.Python with
-everything stripped away that isn't relevant for binding generation. Without
-comments, the core header files only require ~4K lines of code and depend on
-Python (2.7 or 3.x, or PyPy2.7 >= 5.7) and the C++ standard library. This
-compact implementation was possible thanks to some of the new C++11 language
-features (specifically: tuples, lambda functions and variadic templates). Since
-its creation, this library has grown beyond Boost.Python in many ways, leading
-to dramatically simpler binding code in many common situations.""")
diff --git a/thirdparty/pybind11/pybind11/tests/CMakeLists.txt b/thirdparty/pybind11/pybind11/tests/CMakeLists.txt
deleted file mode 100644
index 11be49e53c199e0df972440e01d4e6d167af6aad..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/CMakeLists.txt
+++ /dev/null
@@ -1,238 +0,0 @@
-# CMakeLists.txt -- Build system for the pybind11 test suite
-#
-# Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
-#
-# All rights reserved. Use of this source code is governed by a
-# BSD-style license that can be found in the LICENSE file.
-
-cmake_minimum_required(VERSION 2.8.12)
-
-option(PYBIND11_WERROR "Report all warnings as errors" OFF)
-
-if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
- # We're being loaded directly, i.e. not via add_subdirectory, so make this
- # work as its own project and load the pybind11Config to get the tools we need
- project(pybind11_tests)
-
- find_package(pybind11 REQUIRED CONFIG)
-endif()
-
-if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
- message(STATUS "Setting tests build type to MinSizeRel as none was specified")
- set(CMAKE_BUILD_TYPE MinSizeRel CACHE STRING "Choose the type of build." FORCE)
- set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release"
- "MinSizeRel" "RelWithDebInfo")
-endif()
-
-# Full set of test files (you can override these; see below)
-set(PYBIND11_TEST_FILES
- test_alias_initialization.cpp
- test_buffers.cpp
- test_callbacks.cpp
- test_chrono.cpp
- test_class_args.cpp
- test_constants_and_functions.cpp
- test_copy_move_policies.cpp
- test_docstring_options.cpp
- test_eigen.cpp
- test_enum.cpp
- test_eval.cpp
- test_exceptions.cpp
- test_inheritance.cpp
- test_issues.cpp
- test_keep_alive.cpp
- test_kwargs_and_defaults.cpp
- test_methods_and_attributes.cpp
- test_modules.cpp
- test_multiple_inheritance.cpp
- test_numpy_array.cpp
- test_numpy_dtypes.cpp
- test_numpy_vectorize.cpp
- test_opaque_types.cpp
- test_operator_overloading.cpp
- test_pickling.cpp
- test_python_types.cpp
- test_sequences_and_iterators.cpp
- test_smart_ptr.cpp
- test_stl_binders.cpp
- test_virtual_functions.cpp
-)
-
-# Invoking cmake with something like:
-# cmake -DPYBIND11_TEST_OVERRIDE="test_issues.cpp;test_picking.cpp" ..
-# lets you override the tests that get compiled and run. You can restore to all tests with:
-# cmake -DPYBIND11_TEST_OVERRIDE= ..
-if (PYBIND11_TEST_OVERRIDE)
- set(PYBIND11_TEST_FILES ${PYBIND11_TEST_OVERRIDE})
-endif()
-
-string(REPLACE ".cpp" ".py" PYBIND11_PYTEST_FILES "${PYBIND11_TEST_FILES}")
-
-# Check if Eigen is available; if not, remove from PYBIND11_TEST_FILES (but
-# keep it in PYBIND11_PYTEST_FILES, so that we get the "eigen is not installed"
-# skip message).
-list(FIND PYBIND11_TEST_FILES test_eigen.cpp PYBIND11_TEST_FILES_EIGEN_I)
-if(PYBIND11_TEST_FILES_EIGEN_I GREATER -1)
- # Try loading via newer Eigen's Eigen3Config first (bypassing tools/FindEigen3.cmake).
- # Eigen 3.3.1+ exports a cmake 3.0+ target for handling dependency requirements, but also
- # produces a fatal error if loaded from a pre-3.0 cmake.
- if (NOT CMAKE_VERSION VERSION_LESS 3.0)
- find_package(Eigen3 QUIET CONFIG)
- if (EIGEN3_FOUND)
- if (EIGEN3_VERSION_STRING AND NOT EIGEN3_VERSION_STRING VERSION_LESS 3.3.1)
- set(PYBIND11_EIGEN_VIA_TARGET 1)
- endif()
- endif()
- endif()
- if (NOT EIGEN3_FOUND)
- # Couldn't load via target, so fall back to allowing module mode finding, which will pick up
- # tools/FindEigen3.cmake
- find_package(Eigen3 QUIET)
- endif()
-
- if(EIGEN3_FOUND)
- # Eigen 3.3.1+ cmake sets EIGEN3_VERSION_STRING (and hard codes the version when installed
- # rather than looking it up in the cmake script); older versions, and the
- # tools/FindEigen3.cmake, set EIGEN3_VERSION instead.
- if(NOT EIGEN3_VERSION AND EIGEN3_VERSION_STRING)
- set(EIGEN3_VERSION ${EIGEN3_VERSION_STRING})
- endif()
- message(STATUS "Building tests with Eigen v${EIGEN3_VERSION}")
- else()
- list(REMOVE_AT PYBIND11_TEST_FILES ${PYBIND11_TEST_FILES_EIGEN_I})
- message(STATUS "Building tests WITHOUT Eigen")
- endif()
-endif()
-
-# Compile with compiler warnings turned on
-function(pybind11_enable_warnings target_name)
- if(MSVC)
- target_compile_options(${target_name} PRIVATE /W4)
- else()
- target_compile_options(${target_name} PRIVATE -Wall -Wextra -Wconversion -Wcast-qual)
- endif()
-
- if(PYBIND11_WERROR)
- if(MSVC)
- target_compile_options(${target_name} PRIVATE /WX)
- else()
- target_compile_options(${target_name} PRIVATE -Werror)
- endif()
- endif()
-endfunction()
-
-
-# Create the binding library
-pybind11_add_module(pybind11_tests THIN_LTO pybind11_tests.cpp
- ${PYBIND11_TEST_FILES} ${PYBIND11_HEADERS})
-
-pybind11_enable_warnings(pybind11_tests)
-
-if(EIGEN3_FOUND)
- if (PYBIND11_EIGEN_VIA_TARGET)
- target_link_libraries(pybind11_tests PRIVATE Eigen3::Eigen)
- else()
- target_include_directories(pybind11_tests PRIVATE ${EIGEN3_INCLUDE_DIR})
- endif()
- target_compile_definitions(pybind11_tests PRIVATE -DPYBIND11_TEST_EIGEN)
-endif()
-
-set(testdir ${CMAKE_CURRENT_SOURCE_DIR})
-
-# Always write the output file directly into the 'tests' directory (even on MSVC)
-if(NOT CMAKE_LIBRARY_OUTPUT_DIRECTORY)
- set_target_properties(pybind11_tests PROPERTIES LIBRARY_OUTPUT_DIRECTORY ${testdir})
- foreach(config ${CMAKE_CONFIGURATION_TYPES})
- string(TOUPPER ${config} config)
- set_target_properties(pybind11_tests PROPERTIES LIBRARY_OUTPUT_DIRECTORY_${config} ${testdir})
- endforeach()
-endif()
-
-# Make sure pytest is found or produce a fatal error
-if(NOT PYBIND11_PYTEST_FOUND)
- execute_process(COMMAND ${PYTHON_EXECUTABLE} -c "import pytest; print(pytest.__version__)"
- RESULT_VARIABLE pytest_not_found OUTPUT_VARIABLE pytest_version ERROR_QUIET)
- if(pytest_not_found)
- message(FATAL_ERROR "Running the tests requires pytest. Please install it manually"
- " (try: ${PYTHON_EXECUTABLE} -m pip install pytest)")
- elseif(pytest_version VERSION_LESS 3.0)
- message(FATAL_ERROR "Running the tests requires pytest >= 3.0. Found: ${pytest_version}"
- "Please update it (try: ${PYTHON_EXECUTABLE} -m pip install -U pytest)")
- endif()
- set(PYBIND11_PYTEST_FOUND TRUE CACHE INTERNAL "")
-endif()
-
-# A single command to compile and run the tests
-add_custom_target(pytest COMMAND ${PYTHON_EXECUTABLE} -m pytest ${PYBIND11_PYTEST_FILES}
- DEPENDS pybind11_tests WORKING_DIRECTORY ${testdir})
-
-if(PYBIND11_TEST_OVERRIDE)
- add_custom_command(TARGET pytest POST_BUILD
- COMMAND ${CMAKE_COMMAND} -E echo "Note: not all tests run: -DPYBIND11_TEST_OVERRIDE is in effect")
-endif()
-
-# Add a check target to run all the tests, starting with pytest (we add dependencies to this below)
-add_custom_target(check DEPENDS pytest)
-
-# The remaining tests only apply when being built as part of the pybind11 project, but not if the
-# tests are being built independently.
-if (NOT PROJECT_NAME STREQUAL "pybind11")
- return()
-endif()
-
-# Add a post-build comment to show the .so size and, if a previous size, compare it:
-add_custom_command(TARGET pybind11_tests POST_BUILD
- COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/tools/libsize.py
- $<TARGET_FILE:pybind11_tests> ${CMAKE_CURRENT_BINARY_DIR}/sosize-$<TARGET_FILE_NAME:pybind11_tests>.txt)
-
-# Test CMake build using functions and targets from subdirectory or installed location
-add_custom_target(test_cmake_build)
-if(NOT CMAKE_VERSION VERSION_LESS 3.1)
- # 3.0 needed for interface library for subdirectory_target/installed_target
- # 3.1 needed for cmake -E env for testing
-
- include(CMakeParseArguments)
- function(pybind11_add_build_test name)
- cmake_parse_arguments(ARG "INSTALL" "" "" ${ARGN})
-
- set(build_options "-DCMAKE_PREFIX_PATH=${PROJECT_BINARY_DIR}/mock_install"
- "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}"
- "-DPYTHON_EXECUTABLE=${PYTHON_EXECUTABLE}"
- "-DPYBIND11_CPP_STANDARD=${PYBIND11_CPP_STANDARD}")
- if(NOT ARG_INSTALL)
- list(APPEND build_options "-DPYBIND11_PROJECT_DIR=${PROJECT_SOURCE_DIR}")
- endif()
-
- add_custom_target(test_${name} ${CMAKE_CTEST_COMMAND}
- --quiet --output-log test_cmake_build/${name}.log
- --build-and-test "${CMAKE_CURRENT_SOURCE_DIR}/test_cmake_build/${name}"
- "${CMAKE_CURRENT_BINARY_DIR}/test_cmake_build/${name}"
- --build-config Release
- --build-noclean
- --build-generator ${CMAKE_GENERATOR}
- $<$<BOOL:${CMAKE_GENERATOR_PLATFORM}>:--build-generator-platform> ${CMAKE_GENERATOR_PLATFORM}
- --build-makeprogram ${CMAKE_MAKE_PROGRAM}
- --build-target check
- --build-options ${build_options}
- )
- if(ARG_INSTALL)
- add_dependencies(test_${name} mock_install)
- endif()
- add_dependencies(test_cmake_build test_${name})
- endfunction()
-
- pybind11_add_build_test(subdirectory_function)
- pybind11_add_build_test(subdirectory_target)
-
- if(PYBIND11_INSTALL)
- add_custom_target(mock_install ${CMAKE_COMMAND}
- "-DCMAKE_INSTALL_PREFIX=${PROJECT_BINARY_DIR}/mock_install"
- -P "${PROJECT_BINARY_DIR}/cmake_install.cmake"
- )
-
- pybind11_add_build_test(installed_function INSTALL)
- pybind11_add_build_test(installed_target INSTALL)
- endif()
-endif()
-
-add_dependencies(check test_cmake_build)
diff --git a/thirdparty/pybind11/pybind11/tests/conftest.py b/thirdparty/pybind11/pybind11/tests/conftest.py
deleted file mode 100644
index 5b08004e3f2bfa9476185e9e788c94339b0f7f3b..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/conftest.py
+++ /dev/null
@@ -1,239 +0,0 @@
-"""pytest configuration
-
-Extends output capture as needed by pybind11: ignore constructors, optional unordered lines.
-Adds docstring and exceptions message sanitizers: ignore Python 2 vs 3 differences.
-"""
-
-import pytest
-import textwrap
-import difflib
-import re
-import sys
-import contextlib
-import platform
-import gc
-
-_unicode_marker = re.compile(r'u(\'[^\']*\')')
-_long_marker = re.compile(r'([0-9])L')
-_hexadecimal = re.compile(r'0x[0-9a-fA-F]+')
-
-
-def _strip_and_dedent(s):
- """For triple-quote strings"""
- return textwrap.dedent(s.lstrip('\n').rstrip())
-
-
-def _split_and_sort(s):
- """For output which does not require specific line order"""
- return sorted(_strip_and_dedent(s).splitlines())
-
-
-def _make_explanation(a, b):
- """Explanation for a failed assert -- the a and b arguments are List[str]"""
- return ["--- actual / +++ expected"] + [line.strip('\n') for line in difflib.ndiff(a, b)]
-
-
-class Output(object):
- """Basic output post-processing and comparison"""
- def __init__(self, string):
- self.string = string
- self.explanation = []
-
- def __str__(self):
- return self.string
-
- def __eq__(self, other):
- # Ignore constructor/destructor output which is prefixed with "###"
- a = [line for line in self.string.strip().splitlines() if not line.startswith("###")]
- b = _strip_and_dedent(other).splitlines()
- if a == b:
- return True
- else:
- self.explanation = _make_explanation(a, b)
- return False
-
-
-class Unordered(Output):
- """Custom comparison for output without strict line ordering"""
- def __eq__(self, other):
- a = _split_and_sort(self.string)
- b = _split_and_sort(other)
- if a == b:
- return True
- else:
- self.explanation = _make_explanation(a, b)
- return False
-
-
-class Capture(object):
- def __init__(self, capfd):
- self.capfd = capfd
- self.out = ""
- self.err = ""
-
- def __enter__(self):
- self.capfd.readouterr()
- return self
-
- def __exit__(self, *_):
- self.out, self.err = self.capfd.readouterr()
-
- def __eq__(self, other):
- a = Output(self.out)
- b = other
- if a == b:
- return True
- else:
- self.explanation = a.explanation
- return False
-
- def __str__(self):
- return self.out
-
- def __contains__(self, item):
- return item in self.out
-
- @property
- def unordered(self):
- return Unordered(self.out)
-
- @property
- def stderr(self):
- return Output(self.err)
-
-
-@pytest.fixture
-def capture(capsys):
- """Extended `capsys` with context manager and custom equality operators"""
- return Capture(capsys)
-
-
-class SanitizedString(object):
- def __init__(self, sanitizer):
- self.sanitizer = sanitizer
- self.string = ""
- self.explanation = []
-
- def __call__(self, thing):
- self.string = self.sanitizer(thing)
- return self
-
- def __eq__(self, other):
- a = self.string
- b = _strip_and_dedent(other)
- if a == b:
- return True
- else:
- self.explanation = _make_explanation(a.splitlines(), b.splitlines())
- return False
-
-
-def _sanitize_general(s):
- s = s.strip()
- s = s.replace("pybind11_tests.", "m.")
- s = s.replace("unicode", "str")
- s = _long_marker.sub(r"\1", s)
- s = _unicode_marker.sub(r"\1", s)
- return s
-
-
-def _sanitize_docstring(thing):
- s = thing.__doc__
- s = _sanitize_general(s)
- return s
-
-
-@pytest.fixture
-def doc():
- """Sanitize docstrings and add custom failure explanation"""
- return SanitizedString(_sanitize_docstring)
-
-
-def _sanitize_message(thing):
- s = str(thing)
- s = _sanitize_general(s)
- s = _hexadecimal.sub("0", s)
- return s
-
-
-@pytest.fixture
-def msg():
- """Sanitize messages and add custom failure explanation"""
- return SanitizedString(_sanitize_message)
-
-
-# noinspection PyUnusedLocal
-def pytest_assertrepr_compare(op, left, right):
- """Hook to insert custom failure explanation"""
- if hasattr(left, 'explanation'):
- return left.explanation
-
-
-@contextlib.contextmanager
-def suppress(exception):
- """Suppress the desired exception"""
- try:
- yield
- except exception:
- pass
-
-
-def gc_collect():
- ''' Run the garbage collector twice (needed when running
- reference counting tests with PyPy) '''
- gc.collect()
- gc.collect()
-
-
-def pytest_namespace():
- """Add import suppression and test requirements to `pytest` namespace"""
- try:
- import numpy as np
- except ImportError:
- np = None
- try:
- import scipy
- except ImportError:
- scipy = None
- try:
- from pybind11_tests import have_eigen
- except ImportError:
- have_eigen = False
- pypy = platform.python_implementation() == "PyPy"
-
- skipif = pytest.mark.skipif
- return {
- 'suppress': suppress,
- 'requires_numpy': skipif(not np, reason="numpy is not installed"),
- 'requires_scipy': skipif(not np, reason="scipy is not installed"),
- 'requires_eigen_and_numpy': skipif(not have_eigen or not np,
- reason="eigen and/or numpy are not installed"),
- 'requires_eigen_and_scipy': skipif(not have_eigen or not scipy,
- reason="eigen and/or scipy are not installed"),
- 'unsupported_on_pypy': skipif(pypy, reason="unsupported on PyPy"),
- 'gc_collect': gc_collect
- }
-
-
-def _test_import_pybind11():
- """Early diagnostic for test module initialization errors
-
- When there is an error during initialization, the first import will report the
- real error while all subsequent imports will report nonsense. This import test
- is done early (in the pytest configuration file, before any tests) in order to
- avoid the noise of having all tests fail with identical error messages.
-
- Any possible exception is caught here and reported manually *without* the stack
- trace. This further reduces noise since the trace would only show pytest internals
- which are not useful for debugging pybind11 module issues.
- """
- # noinspection PyBroadException
- try:
- import pybind11_tests # noqa: F401 imported but unused
- except Exception as e:
- print("Failed to import pybind11_tests from pytest:")
- print(" {}: {}".format(type(e).__name__, e))
- sys.exit(1)
-
-
-_test_import_pybind11()
diff --git a/thirdparty/pybind11/pybind11/tests/constructor_stats.h b/thirdparty/pybind11/pybind11/tests/constructor_stats.h
deleted file mode 100644
index f66ff71df57e9208d6a9b2576e4c99f36a6beb33..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/constructor_stats.h
+++ /dev/null
@@ -1,276 +0,0 @@
-#pragma once
-/*
- tests/constructor_stats.h -- framework for printing and tracking object
- instance lifetimes in example/test code.
-
- Copyright (c) 2016 Jason Rhinelander <jason@imaginary.ca>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-
-This header provides a few useful tools for writing examples or tests that want to check and/or
-display object instance lifetimes. It requires that you include this header and add the following
-function calls to constructors:
-
- class MyClass {
- MyClass() { ...; print_default_created(this); }
- ~MyClass() { ...; print_destroyed(this); }
- MyClass(const MyClass &c) { ...; print_copy_created(this); }
- MyClass(MyClass &&c) { ...; print_move_created(this); }
- MyClass(int a, int b) { ...; print_created(this, a, b); }
- MyClass &operator=(const MyClass &c) { ...; print_copy_assigned(this); }
- MyClass &operator=(MyClass &&c) { ...; print_move_assigned(this); }
-
- ...
- }
-
-You can find various examples of these in several of the existing testing .cpp files. (Of course
-you don't need to add any of the above constructors/operators that you don't actually have, except
-for the destructor).
-
-Each of these will print an appropriate message such as:
-
- ### MyClass @ 0x2801910 created via default constructor
- ### MyClass @ 0x27fa780 created 100 200
- ### MyClass @ 0x2801910 destroyed
- ### MyClass @ 0x27fa780 destroyed
-
-You can also include extra arguments (such as the 100, 200 in the output above, coming from the
-value constructor) for all of the above methods which will be included in the output.
-
-For testing, each of these also keeps track the created instances and allows you to check how many
-of the various constructors have been invoked from the Python side via code such as:
-
- from pybind11_tests import ConstructorStats
- cstats = ConstructorStats.get(MyClass)
- print(cstats.alive())
- print(cstats.default_constructions)
-
-Note that `.alive()` should usually be the first thing you call as it invokes Python's garbage
-collector to actually destroy objects that aren't yet referenced.
-
-For everything except copy and move constructors and destructors, any extra values given to the
-print_...() function is stored in a class-specific values list which you can retrieve and inspect
-from the ConstructorStats instance `.values()` method.
-
-In some cases, when you need to track instances of a C++ class not registered with pybind11, you
-need to add a function returning the ConstructorStats for the C++ class; this can be done with:
-
- m.def("get_special_cstats", &ConstructorStats::get<SpecialClass>, py::return_value_policy::reference)
-
-Finally, you can suppress the output messages, but keep the constructor tracking (for
-inspection/testing in python) by using the functions with `print_` replaced with `track_` (e.g.
-`track_copy_created(this)`).
-
-*/
-
-#include "pybind11_tests.h"
-#include <unordered_map>
-#include <list>
-#include <typeindex>
-#include <sstream>
-
-class ConstructorStats {
-protected:
- std::unordered_map<void*, int> _instances; // Need a map rather than set because members can shared address with parents
- std::list<std::string> _values; // Used to track values (e.g. of value constructors)
-public:
- int default_constructions = 0;
- int copy_constructions = 0;
- int move_constructions = 0;
- int copy_assignments = 0;
- int move_assignments = 0;
-
- void copy_created(void *inst) {
- created(inst);
- copy_constructions++;
- }
-
- void move_created(void *inst) {
- created(inst);
- move_constructions++;
- }
-
- void default_created(void *inst) {
- created(inst);
- default_constructions++;
- }
-
- void created(void *inst) {
- ++_instances[inst];
- }
-
- void destroyed(void *inst) {
- if (--_instances[inst] < 0)
- throw std::runtime_error("cstats.destroyed() called with unknown "
- "instance; potential double-destruction "
- "or a missing cstats.created()");
- }
-
- static void gc() {
- // Force garbage collection to ensure any pending destructors are invoked:
-#if defined(PYPY_VERSION)
- PyObject *globals = PyEval_GetGlobals();
- PyObject *result = PyRun_String(
- "import gc\n"
- "for i in range(2):"
- " gc.collect()\n",
- Py_file_input, globals, globals);
- if (result == nullptr)
- throw py::error_already_set();
- Py_DECREF(result);
-#else
- py::module::import("gc").attr("collect")();
-#endif
- }
-
- int alive() {
- gc();
- int total = 0;
- for (const auto &p : _instances)
- if (p.second > 0)
- total += p.second;
- return total;
- }
-
- void value() {} // Recursion terminator
- // Takes one or more values, converts them to strings, then stores them.
- template <typename T, typename... Tmore> void value(const T &v, Tmore &&...args) {
- std::ostringstream oss;
- oss << v;
- _values.push_back(oss.str());
- value(std::forward<Tmore>(args)...);
- }
-
- // Move out stored values
- py::list values() {
- py::list l;
- for (const auto &v : _values) l.append(py::cast(v));
- _values.clear();
- return l;
- }
-
- // Gets constructor stats from a C++ type index
- static ConstructorStats& get(std::type_index type) {
- static std::unordered_map<std::type_index, ConstructorStats> all_cstats;
- return all_cstats[type];
- }
-
- // Gets constructor stats from a C++ type
- template <typename T> static ConstructorStats& get() {
-#if defined(PYPY_VERSION)
- gc();
-#endif
- return get(typeid(T));
- }
-
- // Gets constructor stats from a Python class
- static ConstructorStats& get(py::object class_) {
- auto &internals = py::detail::get_internals();
- const std::type_index *t1 = nullptr, *t2 = nullptr;
- try {
- auto *type_info = internals.registered_types_py.at(class_.ptr());
- for (auto &p : internals.registered_types_cpp) {
- if (p.second == type_info) {
- if (t1) {
- t2 = &p.first;
- break;
- }
- t1 = &p.first;
- }
- }
- }
- catch (std::out_of_range) {}
- if (!t1) throw std::runtime_error("Unknown class passed to ConstructorStats::get()");
- auto &cs1 = get(*t1);
- // If we have both a t1 and t2 match, one is probably the trampoline class; return whichever
- // has more constructions (typically one or the other will be 0)
- if (t2) {
- auto &cs2 = get(*t2);
- int cs1_total = cs1.default_constructions + cs1.copy_constructions + cs1.move_constructions + (int) cs1._values.size();
- int cs2_total = cs2.default_constructions + cs2.copy_constructions + cs2.move_constructions + (int) cs2._values.size();
- if (cs2_total > cs1_total) return cs2;
- }
- return cs1;
- }
-};
-
-// To track construction/destruction, you need to call these methods from the various
-// constructors/operators. The ones that take extra values record the given values in the
-// constructor stats values for later inspection.
-template <class T> void track_copy_created(T *inst) { ConstructorStats::get<T>().copy_created(inst); }
-template <class T> void track_move_created(T *inst) { ConstructorStats::get<T>().move_created(inst); }
-template <class T, typename... Values> void track_copy_assigned(T *, Values &&...values) {
- auto &cst = ConstructorStats::get<T>();
- cst.copy_assignments++;
- cst.value(std::forward<Values>(values)...);
-}
-template <class T, typename... Values> void track_move_assigned(T *, Values &&...values) {
- auto &cst = ConstructorStats::get<T>();
- cst.move_assignments++;
- cst.value(std::forward<Values>(values)...);
-}
-template <class T, typename... Values> void track_default_created(T *inst, Values &&...values) {
- auto &cst = ConstructorStats::get<T>();
- cst.default_created(inst);
- cst.value(std::forward<Values>(values)...);
-}
-template <class T, typename... Values> void track_created(T *inst, Values &&...values) {
- auto &cst = ConstructorStats::get<T>();
- cst.created(inst);
- cst.value(std::forward<Values>(values)...);
-}
-template <class T, typename... Values> void track_destroyed(T *inst) {
- ConstructorStats::get<T>().destroyed(inst);
-}
-template <class T, typename... Values> void track_values(T *, Values &&...values) {
- ConstructorStats::get<T>().value(std::forward<Values>(values)...);
-}
-
-/// Don't cast pointers to Python, print them as strings
-inline const char *format_ptrs(const char *p) { return p; }
-template <typename T>
-py::str format_ptrs(T *p) { return "{:#x}"_s.format(reinterpret_cast<std::uintptr_t>(p)); }
-template <typename T>
-auto format_ptrs(T &&x) -> decltype(std::forward<T>(x)) { return std::forward<T>(x); }
-
-template <class T, typename... Output>
-void print_constr_details(T *inst, const std::string &action, Output &&...output) {
- py::print("###", py::type_id<T>(), "@", format_ptrs(inst), action,
- format_ptrs(std::forward<Output>(output))...);
-}
-
-// Verbose versions of the above:
-template <class T, typename... Values> void print_copy_created(T *inst, Values &&...values) { // NB: this prints, but doesn't store, given values
- print_constr_details(inst, "created via copy constructor", values...);
- track_copy_created(inst);
-}
-template <class T, typename... Values> void print_move_created(T *inst, Values &&...values) { // NB: this prints, but doesn't store, given values
- print_constr_details(inst, "created via move constructor", values...);
- track_move_created(inst);
-}
-template <class T, typename... Values> void print_copy_assigned(T *inst, Values &&...values) {
- print_constr_details(inst, "assigned via copy assignment", values...);
- track_copy_assigned(inst, values...);
-}
-template <class T, typename... Values> void print_move_assigned(T *inst, Values &&...values) {
- print_constr_details(inst, "assigned via move assignment", values...);
- track_move_assigned(inst, values...);
-}
-template <class T, typename... Values> void print_default_created(T *inst, Values &&...values) {
- print_constr_details(inst, "created via default constructor", values...);
- track_default_created(inst, values...);
-}
-template <class T, typename... Values> void print_created(T *inst, Values &&...values) {
- print_constr_details(inst, "created", values...);
- track_created(inst, values...);
-}
-template <class T, typename... Values> void print_destroyed(T *inst, Values &&...values) { // Prints but doesn't store given values
- print_constr_details(inst, "destroyed", values...);
- track_destroyed(inst);
-}
-template <class T, typename... Values> void print_values(T *inst, Values &&...values) {
- print_constr_details(inst, ":", values...);
- track_values(inst, values...);
-}
-
diff --git a/thirdparty/pybind11/pybind11/tests/object.h b/thirdparty/pybind11/pybind11/tests/object.h
deleted file mode 100644
index 9235f19c20bff3afb59c6880a84c809205eff6ea..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/object.h
+++ /dev/null
@@ -1,175 +0,0 @@
-#if !defined(__OBJECT_H)
-#define __OBJECT_H
-
-#include <atomic>
-#include "constructor_stats.h"
-
-/// Reference counted object base class
-class Object {
-public:
- /// Default constructor
- Object() { print_default_created(this); }
-
- /// Copy constructor
- Object(const Object &) : m_refCount(0) { print_copy_created(this); }
-
- /// Return the current reference count
- int getRefCount() const { return m_refCount; };
-
- /// Increase the object's reference count by one
- void incRef() const { ++m_refCount; }
-
- /** \brief Decrease the reference count of
- * the object and possibly deallocate it.
- *
- * The object will automatically be deallocated once
- * the reference count reaches zero.
- */
- void decRef(bool dealloc = true) const {
- --m_refCount;
- if (m_refCount == 0 && dealloc)
- delete this;
- else if (m_refCount < 0)
- throw std::runtime_error("Internal error: reference count < 0!");
- }
-
- virtual std::string toString() const = 0;
-protected:
- /** \brief Virtual protected deconstructor.
- * (Will only be called by \ref ref)
- */
- virtual ~Object() { print_destroyed(this); }
-private:
- mutable std::atomic<int> m_refCount { 0 };
-};
-
-// Tag class used to track constructions of ref objects. When we track constructors, below, we
-// track and print out the actual class (e.g. ref<MyObject>), and *also* add a fake tracker for
-// ref_tag. This lets us check that the total number of ref<Anything> constructors/destructors is
-// correct without having to check each individual ref<Whatever> type individually.
-class ref_tag {};
-
-/**
- * \brief Reference counting helper
- *
- * The \a ref refeference template is a simple wrapper to store a
- * pointer to an object. It takes care of increasing and decreasing
- * the reference count of the object. When the last reference goes
- * out of scope, the associated object will be deallocated.
- *
- * \ingroup libcore
- */
-template <typename T> class ref {
-public:
- /// Create a nullptr reference
- ref() : m_ptr(nullptr) { print_default_created(this); track_default_created((ref_tag*) this); }
-
- /// Construct a reference from a pointer
- ref(T *ptr) : m_ptr(ptr) {
- if (m_ptr) ((Object *) m_ptr)->incRef();
-
- print_created(this, "from pointer", m_ptr); track_created((ref_tag*) this, "from pointer");
-
- }
-
- /// Copy constructor
- ref(const ref &r) : m_ptr(r.m_ptr) {
- if (m_ptr)
- ((Object *) m_ptr)->incRef();
-
- print_copy_created(this, "with pointer", m_ptr); track_copy_created((ref_tag*) this);
- }
-
- /// Move constructor
- ref(ref &&r) : m_ptr(r.m_ptr) {
- r.m_ptr = nullptr;
-
- print_move_created(this, "with pointer", m_ptr); track_move_created((ref_tag*) this);
- }
-
- /// Destroy this reference
- ~ref() {
- if (m_ptr)
- ((Object *) m_ptr)->decRef();
-
- print_destroyed(this); track_destroyed((ref_tag*) this);
- }
-
- /// Move another reference into the current one
- ref& operator=(ref&& r) {
- print_move_assigned(this, "pointer", r.m_ptr); track_move_assigned((ref_tag*) this);
-
- if (*this == r)
- return *this;
- if (m_ptr)
- ((Object *) m_ptr)->decRef();
- m_ptr = r.m_ptr;
- r.m_ptr = nullptr;
- return *this;
- }
-
- /// Overwrite this reference with another reference
- ref& operator=(const ref& r) {
- print_copy_assigned(this, "pointer", r.m_ptr); track_copy_assigned((ref_tag*) this);
-
- if (m_ptr == r.m_ptr)
- return *this;
- if (m_ptr)
- ((Object *) m_ptr)->decRef();
- m_ptr = r.m_ptr;
- if (m_ptr)
- ((Object *) m_ptr)->incRef();
- return *this;
- }
-
- /// Overwrite this reference with a pointer to another object
- ref& operator=(T *ptr) {
- print_values(this, "assigned pointer"); track_values((ref_tag*) this, "assigned pointer");
-
- if (m_ptr == ptr)
- return *this;
- if (m_ptr)
- ((Object *) m_ptr)->decRef();
- m_ptr = ptr;
- if (m_ptr)
- ((Object *) m_ptr)->incRef();
- return *this;
- }
-
- /// Compare this reference with another reference
- bool operator==(const ref &r) const { return m_ptr == r.m_ptr; }
-
- /// Compare this reference with another reference
- bool operator!=(const ref &r) const { return m_ptr != r.m_ptr; }
-
- /// Compare this reference with a pointer
- bool operator==(const T* ptr) const { return m_ptr == ptr; }
-
- /// Compare this reference with a pointer
- bool operator!=(const T* ptr) const { return m_ptr != ptr; }
-
- /// Access the object referenced by this reference
- T* operator->() { return m_ptr; }
-
- /// Access the object referenced by this reference
- const T* operator->() const { return m_ptr; }
-
- /// Return a C++ reference to the referenced object
- T& operator*() { return *m_ptr; }
-
- /// Return a const C++ reference to the referenced object
- const T& operator*() const { return *m_ptr; }
-
- /// Return a pointer to the referenced object
- operator T* () { return m_ptr; }
-
- /// Return a const pointer to the referenced object
- T* get_ptr() { return m_ptr; }
-
- /// Return a pointer to the referenced object
- const T* get_ptr() const { return m_ptr; }
-private:
- T *m_ptr;
-};
-
-#endif /* __OBJECT_H */
diff --git a/thirdparty/pybind11/pybind11/tests/pybind11_tests.cpp b/thirdparty/pybind11/pybind11/tests/pybind11_tests.cpp
deleted file mode 100644
index 1d805d75bae3c60a97296204c6fb9eb55909afc9..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/pybind11_tests.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- tests/pybind11_tests.cpp -- pybind example plugin
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include "constructor_stats.h"
-
-/*
-For testing purposes, we define a static global variable here in a function that each individual
-test .cpp calls with its initialization lambda. It's convenient here because we can just not
-compile some test files to disable/ignore some of the test code.
-
-It is NOT recommended as a way to use pybind11 in practice, however: the initialization order will
-be essentially random, which is okay for our test scripts (there are no dependencies between the
-individual pybind11 test .cpp files), but most likely not what you want when using pybind11
-productively.
-
-Instead, see the "How can I reduce the build time?" question in the "Frequently asked questions"
-section of the documentation for good practice on splitting binding code over multiple files.
-*/
-std::list<std::function<void(py::module &)>> &initializers() {
- static std::list<std::function<void(py::module &)>> inits;
- return inits;
-}
-
-test_initializer::test_initializer(std::function<void(py::module &)> initializer) {
- initializers().push_back(std::move(initializer));
-}
-
-void bind_ConstructorStats(py::module &m) {
- py::class_<ConstructorStats>(m, "ConstructorStats")
- .def("alive", &ConstructorStats::alive)
- .def("values", &ConstructorStats::values)
- .def_readwrite("default_constructions", &ConstructorStats::default_constructions)
- .def_readwrite("copy_assignments", &ConstructorStats::copy_assignments)
- .def_readwrite("move_assignments", &ConstructorStats::move_assignments)
- .def_readwrite("copy_constructions", &ConstructorStats::copy_constructions)
- .def_readwrite("move_constructions", &ConstructorStats::move_constructions)
- .def_static("get", (ConstructorStats &(*)(py::object)) &ConstructorStats::get, py::return_value_policy::reference_internal);
-}
-
-PYBIND11_PLUGIN(pybind11_tests) {
- py::module m("pybind11_tests", "pybind testing plugin");
-
- bind_ConstructorStats(m);
-
- for (const auto &initializer : initializers())
- initializer(m);
-
- if (!py::hasattr(m, "have_eigen")) m.attr("have_eigen") = false;
-
- return m.ptr();
-}
diff --git a/thirdparty/pybind11/pybind11/tests/pybind11_tests.h b/thirdparty/pybind11/pybind11/tests/pybind11_tests.h
deleted file mode 100644
index c11b687b2c4de017e9d4a7e7d74aa796e9a976ba..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/pybind11_tests.h
+++ /dev/null
@@ -1,12 +0,0 @@
-#pragma once
-#include <pybind11/pybind11.h>
-#include <functional>
-#include <list>
-
-namespace py = pybind11;
-using namespace pybind11::literals;
-
-class test_initializer {
-public:
- test_initializer(std::function<void(py::module &)> initializer);
-};
diff --git a/thirdparty/pybind11/pybind11/tests/pytest.ini b/thirdparty/pybind11/pybind11/tests/pytest.ini
deleted file mode 100644
index 401cbe0ad8650afc139e5f362edb24d3b6cf0aab..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/pytest.ini
+++ /dev/null
@@ -1,7 +0,0 @@
-[pytest]
-minversion = 3.0
-addopts =
- # show summary of skipped tests
- -rs
- # capture only Python print and C++ py::print, but not C output (low-level Python errors)
- --capture=sys
diff --git a/thirdparty/pybind11/pybind11/tests/test_alias_initialization.cpp b/thirdparty/pybind11/pybind11/tests/test_alias_initialization.cpp
deleted file mode 100644
index 48e595695a679dbcddc581b9f33fdba9e7c3b048..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_alias_initialization.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- tests/test_alias_initialization.cpp -- test cases and example of different trampoline
- initialization modes
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>, Jason Rhinelander <jason@imaginary.ca>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-test_initializer alias_initialization([](py::module &m) {
- // don't invoke Python dispatch classes by default when instantiating C++ classes that were not
- // extended on the Python side
- struct A {
- virtual ~A() {}
- virtual void f() { py::print("A.f()"); }
- };
-
- struct PyA : A {
- PyA() { py::print("PyA.PyA()"); }
- ~PyA() { py::print("PyA.~PyA()"); }
-
- void f() override {
- py::print("PyA.f()");
- PYBIND11_OVERLOAD(void, A, f);
- }
- };
-
- auto call_f = [](A *a) { a->f(); };
-
- py::class_<A, PyA>(m, "A")
- .def(py::init<>())
- .def("f", &A::f);
-
- m.def("call_f", call_f);
-
-
- // ... unless we explicitly request it, as in this example:
- struct A2 {
- virtual ~A2() {}
- virtual void f() { py::print("A2.f()"); }
- };
-
- struct PyA2 : A2 {
- PyA2() { py::print("PyA2.PyA2()"); }
- ~PyA2() { py::print("PyA2.~PyA2()"); }
- void f() override {
- py::print("PyA2.f()");
- PYBIND11_OVERLOAD(void, A2, f);
- }
- };
-
- py::class_<A2, PyA2>(m, "A2")
- .def(py::init_alias<>())
- .def("f", &A2::f);
-
- m.def("call_f", [](A2 *a2) { a2->f(); });
-
-});
-
diff --git a/thirdparty/pybind11/pybind11/tests/test_alias_initialization.py b/thirdparty/pybind11/pybind11/tests/test_alias_initialization.py
deleted file mode 100644
index fb90cfc7baea0ddffe6bb89462aadabfd6532344..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_alias_initialization.py
+++ /dev/null
@@ -1,80 +0,0 @@
-import pytest
-
-
-def test_alias_delay_initialization1(capture):
- """
- A only initializes its trampoline class when we inherit from it; if we just
- create and use an A instance directly, the trampoline initialization is
- bypassed and we only initialize an A() instead (for performance reasons).
- """
- from pybind11_tests import A, call_f
-
- class B(A):
- def __init__(self):
- super(B, self).__init__()
-
- def f(self):
- print("In python f()")
-
- # C++ version
- with capture:
- a = A()
- call_f(a)
- del a
- pytest.gc_collect()
- assert capture == "A.f()"
-
- # Python version
- with capture:
- b = B()
- call_f(b)
- del b
- pytest.gc_collect()
- assert capture == """
- PyA.PyA()
- PyA.f()
- In python f()
- PyA.~PyA()
- """
-
-
-def test_alias_delay_initialization2(capture):
- """A2, unlike the above, is configured to always initialize the alias; while
- the extra initialization and extra class layer has small virtual dispatch
- performance penalty, it also allows us to do more things with the trampoline
- class such as defining local variables and performing construction/destruction.
- """
- from pybind11_tests import A2, call_f
-
- class B2(A2):
- def __init__(self):
- super(B2, self).__init__()
-
- def f(self):
- print("In python B2.f()")
-
- # No python subclass version
- with capture:
- a2 = A2()
- call_f(a2)
- del a2
- pytest.gc_collect()
- assert capture == """
- PyA2.PyA2()
- PyA2.f()
- A2.f()
- PyA2.~PyA2()
- """
-
- # Python subclass version
- with capture:
- b2 = B2()
- call_f(b2)
- del b2
- pytest.gc_collect()
- assert capture == """
- PyA2.PyA2()
- PyA2.f()
- In python B2.f()
- PyA2.~PyA2()
- """
diff --git a/thirdparty/pybind11/pybind11/tests/test_buffers.cpp b/thirdparty/pybind11/pybind11/tests/test_buffers.cpp
deleted file mode 100644
index 057250d292bca4a6427cdc856e3aeb6989212eb8..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_buffers.cpp
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
- tests/test_buffers.cpp -- supporting Pythons' buffer protocol
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include "constructor_stats.h"
-
-class Matrix {
-public:
- Matrix(size_t rows, size_t cols) : m_rows(rows), m_cols(cols) {
- print_created(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
- m_data = new float[rows*cols];
- memset(m_data, 0, sizeof(float) * rows * cols);
- }
-
- Matrix(const Matrix &s) : m_rows(s.m_rows), m_cols(s.m_cols) {
- print_copy_created(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
- m_data = new float[m_rows * m_cols];
- memcpy(m_data, s.m_data, sizeof(float) * m_rows * m_cols);
- }
-
- Matrix(Matrix &&s) : m_rows(s.m_rows), m_cols(s.m_cols), m_data(s.m_data) {
- print_move_created(this);
- s.m_rows = 0;
- s.m_cols = 0;
- s.m_data = nullptr;
- }
-
- ~Matrix() {
- print_destroyed(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
- delete[] m_data;
- }
-
- Matrix &operator=(const Matrix &s) {
- print_copy_assigned(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
- delete[] m_data;
- m_rows = s.m_rows;
- m_cols = s.m_cols;
- m_data = new float[m_rows * m_cols];
- memcpy(m_data, s.m_data, sizeof(float) * m_rows * m_cols);
- return *this;
- }
-
- Matrix &operator=(Matrix &&s) {
- print_move_assigned(this, std::to_string(m_rows) + "x" + std::to_string(m_cols) + " matrix");
- if (&s != this) {
- delete[] m_data;
- m_rows = s.m_rows; m_cols = s.m_cols; m_data = s.m_data;
- s.m_rows = 0; s.m_cols = 0; s.m_data = nullptr;
- }
- return *this;
- }
-
- float operator()(size_t i, size_t j) const {
- return m_data[i*m_cols + j];
- }
-
- float &operator()(size_t i, size_t j) {
- return m_data[i*m_cols + j];
- }
-
- float *data() { return m_data; }
-
- size_t rows() const { return m_rows; }
- size_t cols() const { return m_cols; }
-private:
- size_t m_rows;
- size_t m_cols;
- float *m_data;
-};
-
-test_initializer buffers([](py::module &m) {
- py::class_<Matrix> mtx(m, "Matrix", py::buffer_protocol());
-
- mtx.def(py::init<size_t, size_t>())
- /// Construct from a buffer
- .def("__init__", [](Matrix &v, py::buffer b) {
- py::buffer_info info = b.request();
- if (info.format != py::format_descriptor<float>::format() || info.ndim != 2)
- throw std::runtime_error("Incompatible buffer format!");
- new (&v) Matrix(info.shape[0], info.shape[1]);
- memcpy(v.data(), info.ptr, sizeof(float) * v.rows() * v.cols());
- })
-
- .def("rows", &Matrix::rows)
- .def("cols", &Matrix::cols)
-
- /// Bare bones interface
- .def("__getitem__", [](const Matrix &m, std::pair<size_t, size_t> i) {
- if (i.first >= m.rows() || i.second >= m.cols())
- throw py::index_error();
- return m(i.first, i.second);
- })
- .def("__setitem__", [](Matrix &m, std::pair<size_t, size_t> i, float v) {
- if (i.first >= m.rows() || i.second >= m.cols())
- throw py::index_error();
- m(i.first, i.second) = v;
- })
- /// Provide buffer access
- .def_buffer([](Matrix &m) -> py::buffer_info {
- return py::buffer_info(
- m.data(), /* Pointer to buffer */
- sizeof(float), /* Size of one scalar */
- py::format_descriptor<float>::format(), /* Python struct-style format descriptor */
- 2, /* Number of dimensions */
- { m.rows(), m.cols() }, /* Buffer dimensions */
- { sizeof(float) * m.rows(), /* Strides (in bytes) for each index */
- sizeof(float) }
- );
- })
- ;
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_buffers.py b/thirdparty/pybind11/pybind11/tests/test_buffers.py
deleted file mode 100644
index 24843d95a23b47dfb87dde9b775b85969d3b1a2c..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_buffers.py
+++ /dev/null
@@ -1,62 +0,0 @@
-import pytest
-from pybind11_tests import Matrix, ConstructorStats
-
-pytestmark = pytest.requires_numpy
-
-with pytest.suppress(ImportError):
- import numpy as np
-
-
-def test_from_python():
- with pytest.raises(RuntimeError) as excinfo:
- Matrix(np.array([1, 2, 3])) # trying to assign a 1D array
- assert str(excinfo.value) == "Incompatible buffer format!"
-
- m3 = np.array([[1, 2, 3], [4, 5, 6]]).astype(np.float32)
- m4 = Matrix(m3)
-
- for i in range(m4.rows()):
- for j in range(m4.cols()):
- assert m3[i, j] == m4[i, j]
-
- cstats = ConstructorStats.get(Matrix)
- assert cstats.alive() == 1
- del m3, m4
- assert cstats.alive() == 0
- assert cstats.values() == ["2x3 matrix"]
- assert cstats.copy_constructions == 0
- # assert cstats.move_constructions >= 0 # Don't invoke any
- assert cstats.copy_assignments == 0
- assert cstats.move_assignments == 0
-
-
-# PyPy: Memory leak in the "np.array(m, copy=False)" call
-# https://bitbucket.org/pypy/pypy/issues/2444
-@pytest.unsupported_on_pypy
-def test_to_python():
- m = Matrix(5, 5)
-
- assert m[2, 3] == 0
- m[2, 3] = 4
- assert m[2, 3] == 4
-
- m2 = np.array(m, copy=False)
- assert m2.shape == (5, 5)
- assert abs(m2).sum() == 4
- assert m2[2, 3] == 4
- m2[2, 3] = 5
- assert m2[2, 3] == 5
-
- cstats = ConstructorStats.get(Matrix)
- assert cstats.alive() == 1
- del m
- pytest.gc_collect()
- assert cstats.alive() == 1
- del m2 # holds an m reference
- pytest.gc_collect()
- assert cstats.alive() == 0
- assert cstats.values() == ["5x5 matrix"]
- assert cstats.copy_constructions == 0
- # assert cstats.move_constructions >= 0 # Don't invoke any
- assert cstats.copy_assignments == 0
- assert cstats.move_assignments == 0
diff --git a/thirdparty/pybind11/pybind11/tests/test_callbacks.cpp b/thirdparty/pybind11/pybind11/tests/test_callbacks.cpp
deleted file mode 100644
index f89cc1c792e759a0a05e5c91b0b56d009783aec6..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_callbacks.cpp
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- tests/test_callbacks.cpp -- callbacks
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include "constructor_stats.h"
-#include <pybind11/functional.h>
-
-
-py::object test_callback1(py::object func) {
- return func();
-}
-
-py::tuple test_callback2(py::object func) {
- return func("Hello", 'x', true, 5);
-}
-
-std::string test_callback3(const std::function<int(int)> &func) {
- return "func(43) = " + std::to_string(func(43));
-}
-
-std::function<int(int)> test_callback4() {
- return [](int i) { return i+1; };
-}
-
-py::cpp_function test_callback5() {
- return py::cpp_function([](int i) { return i+1; },
- py::arg("number"));
-}
-
-int dummy_function(int i) { return i + 1; }
-int dummy_function2(int i, int j) { return i + j; }
-std::function<int(int)> roundtrip(std::function<int(int)> f, bool expect_none = false) {
- if (expect_none && f) {
- throw std::runtime_error("Expected None to be converted to empty std::function");
- }
- return f;
-}
-
-std::string test_dummy_function(const std::function<int(int)> &f) {
- using fn_type = int (*)(int);
- auto result = f.target<fn_type>();
- if (!result) {
- auto r = f(1);
- return "can't convert to function pointer: eval(1) = " + std::to_string(r);
- } else if (*result == dummy_function) {
- auto r = (*result)(1);
- return "matches dummy_function: eval(1) = " + std::to_string(r);
- } else {
- return "argument does NOT match dummy_function. This should never happen!";
- }
-}
-
-struct Payload {
- Payload() {
- print_default_created(this);
- }
- ~Payload() {
- print_destroyed(this);
- }
- Payload(const Payload &) {
- print_copy_created(this);
- }
- Payload(Payload &&) {
- print_move_created(this);
- }
-};
-
-/// Something to trigger a conversion error
-struct Unregistered {};
-
-class AbstractBase {
-public:
- virtual unsigned int func() = 0;
-};
-
-void func_accepting_func_accepting_base(std::function<double(AbstractBase&)>) { }
-
-struct MovableObject {
- bool valid = true;
-
- MovableObject() = default;
- MovableObject(const MovableObject &) = default;
- MovableObject &operator=(const MovableObject &) = default;
- MovableObject(MovableObject &&o) : valid(o.valid) { o.valid = false; }
- MovableObject &operator=(MovableObject &&o) {
- valid = o.valid;
- o.valid = false;
- return *this;
- }
-};
-
-test_initializer callbacks([](py::module &m) {
- m.def("test_callback1", &test_callback1);
- m.def("test_callback2", &test_callback2);
- m.def("test_callback3", &test_callback3);
- m.def("test_callback4", &test_callback4);
- m.def("test_callback5", &test_callback5);
-
- // Test keyword args and generalized unpacking
- m.def("test_tuple_unpacking", [](py::function f) {
- auto t1 = py::make_tuple(2, 3);
- auto t2 = py::make_tuple(5, 6);
- return f("positional", 1, *t1, 4, *t2);
- });
-
- m.def("test_dict_unpacking", [](py::function f) {
- auto d1 = py::dict("key"_a="value", "a"_a=1);
- auto d2 = py::dict();
- auto d3 = py::dict("b"_a=2);
- return f("positional", 1, **d1, **d2, **d3);
- });
-
- m.def("test_keyword_args", [](py::function f) {
- return f("x"_a=10, "y"_a=20);
- });
-
- m.def("test_unpacking_and_keywords1", [](py::function f) {
- auto args = py::make_tuple(2);
- auto kwargs = py::dict("d"_a=4);
- return f(1, *args, "c"_a=3, **kwargs);
- });
-
- m.def("test_unpacking_and_keywords2", [](py::function f) {
- auto kwargs1 = py::dict("a"_a=1);
- auto kwargs2 = py::dict("c"_a=3, "d"_a=4);
- return f("positional", *py::make_tuple(1), 2, *py::make_tuple(3, 4), 5,
- "key"_a="value", **kwargs1, "b"_a=2, **kwargs2, "e"_a=5);
- });
-
- m.def("test_unpacking_error1", [](py::function f) {
- auto kwargs = py::dict("x"_a=3);
- return f("x"_a=1, "y"_a=2, **kwargs); // duplicate ** after keyword
- });
-
- m.def("test_unpacking_error2", [](py::function f) {
- auto kwargs = py::dict("x"_a=3);
- return f(**kwargs, "x"_a=1); // duplicate keyword after **
- });
-
- m.def("test_arg_conversion_error1", [](py::function f) {
- f(234, Unregistered(), "kw"_a=567);
- });
-
- m.def("test_arg_conversion_error2", [](py::function f) {
- f(234, "expected_name"_a=Unregistered(), "kw"_a=567);
- });
-
- /* Test cleanup of lambda closure */
- m.def("test_cleanup", []() -> std::function<void(void)> {
- Payload p;
-
- return [p]() {
- /* p should be cleaned up when the returned function is garbage collected */
- (void) p;
- };
- });
-
- /* Test if passing a function pointer from C++ -> Python -> C++ yields the original pointer */
- m.def("dummy_function", &dummy_function);
- m.def("dummy_function2", &dummy_function2);
- m.def("roundtrip", &roundtrip, py::arg("f"), py::arg("expect_none")=false);
- m.def("test_dummy_function", &test_dummy_function);
- // Export the payload constructor statistics for testing purposes:
- m.def("payload_cstats", &ConstructorStats::get<Payload>);
-
- m.def("func_accepting_func_accepting_base",
- func_accepting_func_accepting_base);
-
- py::class_<MovableObject>(m, "MovableObject");
-
- m.def("callback_with_movable", [](std::function<void(MovableObject &)> f) {
- auto x = MovableObject();
- f(x); // lvalue reference shouldn't move out object
- return x.valid; // must still return `true`
- });
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_callbacks.py b/thirdparty/pybind11/pybind11/tests/test_callbacks.py
deleted file mode 100644
index f94e7b64c3ded4d07da626347fd6c80b306000a6..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_callbacks.py
+++ /dev/null
@@ -1,104 +0,0 @@
-import pytest
-
-
-def test_callbacks():
- from functools import partial
- from pybind11_tests import (test_callback1, test_callback2, test_callback3,
- test_callback4, test_callback5)
-
- def func1():
- return "func1"
-
- def func2(a, b, c, d):
- return "func2", a, b, c, d
-
- def func3(a):
- return "func3({})".format(a)
-
- assert test_callback1(func1) == "func1"
- assert test_callback2(func2) == ("func2", "Hello", "x", True, 5)
- assert test_callback1(partial(func2, 1, 2, 3, 4)) == ("func2", 1, 2, 3, 4)
- assert test_callback1(partial(func3, "partial")) == "func3(partial)"
- assert test_callback3(lambda i: i + 1) == "func(43) = 44"
-
- f = test_callback4()
- assert f(43) == 44
- f = test_callback5()
- assert f(number=43) == 44
-
-
-def test_keyword_args_and_generalized_unpacking():
- from pybind11_tests import (test_tuple_unpacking, test_dict_unpacking, test_keyword_args,
- test_unpacking_and_keywords1, test_unpacking_and_keywords2,
- test_unpacking_error1, test_unpacking_error2,
- test_arg_conversion_error1, test_arg_conversion_error2)
-
- def f(*args, **kwargs):
- return args, kwargs
-
- assert test_tuple_unpacking(f) == (("positional", 1, 2, 3, 4, 5, 6), {})
- assert test_dict_unpacking(f) == (("positional", 1), {"key": "value", "a": 1, "b": 2})
- assert test_keyword_args(f) == ((), {"x": 10, "y": 20})
- assert test_unpacking_and_keywords1(f) == ((1, 2), {"c": 3, "d": 4})
- assert test_unpacking_and_keywords2(f) == (
- ("positional", 1, 2, 3, 4, 5),
- {"key": "value", "a": 1, "b": 2, "c": 3, "d": 4, "e": 5}
- )
-
- with pytest.raises(TypeError) as excinfo:
- test_unpacking_error1(f)
- assert "Got multiple values for keyword argument" in str(excinfo.value)
-
- with pytest.raises(TypeError) as excinfo:
- test_unpacking_error2(f)
- assert "Got multiple values for keyword argument" in str(excinfo.value)
-
- with pytest.raises(RuntimeError) as excinfo:
- test_arg_conversion_error1(f)
- assert "Unable to convert call argument" in str(excinfo.value)
-
- with pytest.raises(RuntimeError) as excinfo:
- test_arg_conversion_error2(f)
- assert "Unable to convert call argument" in str(excinfo.value)
-
-
-def test_lambda_closure_cleanup():
- from pybind11_tests import test_cleanup, payload_cstats
-
- test_cleanup()
- cstats = payload_cstats()
- assert cstats.alive() == 0
- assert cstats.copy_constructions == 1
- assert cstats.move_constructions >= 1
-
-
-def test_cpp_function_roundtrip():
- """Test if passing a function pointer from C++ -> Python -> C++ yields the original pointer"""
- from pybind11_tests import dummy_function, dummy_function2, test_dummy_function, roundtrip
-
- assert test_dummy_function(dummy_function) == "matches dummy_function: eval(1) = 2"
- assert test_dummy_function(roundtrip(dummy_function)) == "matches dummy_function: eval(1) = 2"
- assert roundtrip(None, expect_none=True) is None
- assert test_dummy_function(lambda x: x + 2) == "can't convert to function pointer: eval(1) = 3"
-
- with pytest.raises(TypeError) as excinfo:
- test_dummy_function(dummy_function2)
- assert "incompatible function arguments" in str(excinfo.value)
-
- with pytest.raises(TypeError) as excinfo:
- test_dummy_function(lambda x, y: x + y)
- assert any(s in str(excinfo.value) for s in ("missing 1 required positional argument",
- "takes exactly 2 arguments"))
-
-
-def test_function_signatures(doc):
- from pybind11_tests import test_callback3, test_callback4
-
- assert doc(test_callback3) == "test_callback3(arg0: Callable[[int], int]) -> str"
- assert doc(test_callback4) == "test_callback4() -> Callable[[int], int]"
-
-
-def test_movable_object():
- from pybind11_tests import callback_with_movable
-
- assert callback_with_movable(lambda _: None) is True
diff --git a/thirdparty/pybind11/pybind11/tests/test_chrono.cpp b/thirdparty/pybind11/pybind11/tests/test_chrono.cpp
deleted file mode 100644
index fcc1b6185a704b8604b7d64c6abd0d6420d3b79b..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_chrono.cpp
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- tests/test_chrono.cpp -- test conversions to/from std::chrono types
-
- Copyright (c) 2016 Trent Houliston <trent@houliston.me> and
- Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-
-#include "pybind11_tests.h"
-#include "constructor_stats.h"
-#include <pybind11/chrono.h>
-
-// Return the current time off the wall clock
-std::chrono::system_clock::time_point test_chrono1() {
- return std::chrono::system_clock::now();
-}
-
-// Round trip the passed in system clock time
-std::chrono::system_clock::time_point test_chrono2(std::chrono::system_clock::time_point t) {
- return t;
-}
-
-// Round trip the passed in duration
-std::chrono::system_clock::duration test_chrono3(std::chrono::system_clock::duration d) {
- return d;
-}
-
-// Difference between two passed in time_points
-std::chrono::system_clock::duration test_chrono4(std::chrono::system_clock::time_point a, std::chrono::system_clock::time_point b) {
- return a - b;
-}
-
-// Return the current time off the steady_clock
-std::chrono::steady_clock::time_point test_chrono5() {
- return std::chrono::steady_clock::now();
-}
-
-// Round trip a steady clock timepoint
-std::chrono::steady_clock::time_point test_chrono6(std::chrono::steady_clock::time_point t) {
- return t;
-}
-
-// Roundtrip a duration in microseconds from a float argument
-std::chrono::microseconds test_chrono7(std::chrono::microseconds t) {
- return t;
-}
-
-// Float durations (issue #719)
-std::chrono::duration<double> test_chrono_float_diff(std::chrono::duration<float> a, std::chrono::duration<float> b) {
- return a - b;
-}
-
-test_initializer chrono([] (py::module &m) {
- m.def("test_chrono1", &test_chrono1);
- m.def("test_chrono2", &test_chrono2);
- m.def("test_chrono3", &test_chrono3);
- m.def("test_chrono4", &test_chrono4);
- m.def("test_chrono5", &test_chrono5);
- m.def("test_chrono6", &test_chrono6);
- m.def("test_chrono7", &test_chrono7);
- m.def("test_chrono_float_diff", &test_chrono_float_diff);
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_chrono.py b/thirdparty/pybind11/pybind11/tests/test_chrono.py
deleted file mode 100644
index 55094edbfa6647af32834a63b046f6d3ef0a2afc..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_chrono.py
+++ /dev/null
@@ -1,120 +0,0 @@
-
-
-def test_chrono_system_clock():
- from pybind11_tests import test_chrono1
- import datetime
-
- # Get the time from both c++ and datetime
- date1 = test_chrono1()
- date2 = datetime.datetime.today()
-
- # The returned value should be a datetime
- assert isinstance(date1, datetime.datetime)
-
- # The numbers should vary by a very small amount (time it took to execute)
- diff = abs(date1 - date2)
-
- # There should never be a days/seconds difference
- assert diff.days == 0
- assert diff.seconds == 0
-
- # We test that no more than about 0.5 seconds passes here
- # This makes sure that the dates created are very close to the same
- # but if the testing system is incredibly overloaded this should still pass
- assert diff.microseconds < 500000
-
-
-def test_chrono_system_clock_roundtrip():
- from pybind11_tests import test_chrono2
- import datetime
-
- date1 = datetime.datetime.today()
-
- # Roundtrip the time
- date2 = test_chrono2(date1)
-
- # The returned value should be a datetime
- assert isinstance(date2, datetime.datetime)
-
- # They should be identical (no information lost on roundtrip)
- diff = abs(date1 - date2)
- assert diff.days == 0
- assert diff.seconds == 0
- assert diff.microseconds == 0
-
-
-def test_chrono_duration_roundtrip():
- from pybind11_tests import test_chrono3
- import datetime
-
- # Get the difference between two times (a timedelta)
- date1 = datetime.datetime.today()
- date2 = datetime.datetime.today()
- diff = date2 - date1
-
- # Make sure this is a timedelta
- assert isinstance(diff, datetime.timedelta)
-
- cpp_diff = test_chrono3(diff)
-
- assert cpp_diff.days == diff.days
- assert cpp_diff.seconds == diff.seconds
- assert cpp_diff.microseconds == diff.microseconds
-
-
-def test_chrono_duration_subtraction_equivalence():
- from pybind11_tests import test_chrono4
- import datetime
-
- date1 = datetime.datetime.today()
- date2 = datetime.datetime.today()
-
- diff = date2 - date1
- cpp_diff = test_chrono4(date2, date1)
-
- assert cpp_diff.days == diff.days
- assert cpp_diff.seconds == diff.seconds
- assert cpp_diff.microseconds == diff.microseconds
-
-
-def test_chrono_steady_clock():
- from pybind11_tests import test_chrono5
- import datetime
-
- time1 = test_chrono5()
- time2 = test_chrono5()
-
- assert isinstance(time1, datetime.timedelta)
- assert isinstance(time2, datetime.timedelta)
-
-
-def test_chrono_steady_clock_roundtrip():
- from pybind11_tests import test_chrono6
- import datetime
-
- time1 = datetime.timedelta(days=10, seconds=10, microseconds=100)
- time2 = test_chrono6(time1)
-
- assert isinstance(time2, datetime.timedelta)
-
- # They should be identical (no information lost on roundtrip)
- assert time1.days == time2.days
- assert time1.seconds == time2.seconds
- assert time1.microseconds == time2.microseconds
-
-
-def test_floating_point_duration():
- from pybind11_tests import test_chrono7, test_chrono_float_diff
- import datetime
-
- # Test using 35.525123 seconds as an example floating point number in seconds
- time = test_chrono7(35.525123)
-
- assert isinstance(time, datetime.timedelta)
-
- assert time.seconds == 35
- assert 525122 <= time.microseconds <= 525123
-
- diff = test_chrono_float_diff(43.789012, 1.123456)
- assert diff.seconds == 42
- assert 665556 <= diff.microseconds <= 665557
diff --git a/thirdparty/pybind11/pybind11/tests/test_class_args.cpp b/thirdparty/pybind11/pybind11/tests/test_class_args.cpp
deleted file mode 100644
index e18b39db2ef250af2796b69259008ecc5115c351..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_class_args.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- tests/test_class_args.cpp -- tests that various way of defining a class work
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-
-template <int N> class BreaksBase {};
-template <int N> class BreaksTramp : public BreaksBase<N> {};
-// These should all compile just fine:
-typedef py::class_<BreaksBase<1>, std::unique_ptr<BreaksBase<1>>, BreaksTramp<1>> DoesntBreak1;
-typedef py::class_<BreaksBase<2>, BreaksTramp<2>, std::unique_ptr<BreaksBase<2>>> DoesntBreak2;
-typedef py::class_<BreaksBase<3>, std::unique_ptr<BreaksBase<3>>> DoesntBreak3;
-typedef py::class_<BreaksBase<4>, BreaksTramp<4>> DoesntBreak4;
-typedef py::class_<BreaksBase<5>> DoesntBreak5;
-typedef py::class_<BreaksBase<6>, std::shared_ptr<BreaksBase<6>>, BreaksTramp<6>> DoesntBreak6;
-typedef py::class_<BreaksBase<7>, BreaksTramp<7>, std::shared_ptr<BreaksBase<7>>> DoesntBreak7;
-typedef py::class_<BreaksBase<8>, std::shared_ptr<BreaksBase<8>>> DoesntBreak8;
-#define CHECK_BASE(N) static_assert(std::is_same<typename DoesntBreak##N::type, BreaksBase<N>>::value, \
- "DoesntBreak" #N " has wrong type!")
-CHECK_BASE(1); CHECK_BASE(2); CHECK_BASE(3); CHECK_BASE(4); CHECK_BASE(5); CHECK_BASE(6); CHECK_BASE(7); CHECK_BASE(8);
-#define CHECK_ALIAS(N) static_assert(DoesntBreak##N::has_alias && std::is_same<typename DoesntBreak##N::type_alias, BreaksTramp<N>>::value, \
- "DoesntBreak" #N " has wrong type_alias!")
-#define CHECK_NOALIAS(N) static_assert(!DoesntBreak##N::has_alias && std::is_void<typename DoesntBreak##N::type_alias>::value, \
- "DoesntBreak" #N " has type alias, but shouldn't!")
-CHECK_ALIAS(1); CHECK_ALIAS(2); CHECK_NOALIAS(3); CHECK_ALIAS(4); CHECK_NOALIAS(5); CHECK_ALIAS(6); CHECK_ALIAS(7); CHECK_NOALIAS(8);
-#define CHECK_HOLDER(N, TYPE) static_assert(std::is_same<typename DoesntBreak##N::holder_type, std::TYPE##_ptr<BreaksBase<N>>>::value, \
- "DoesntBreak" #N " has wrong holder_type!")
-CHECK_HOLDER(1, unique); CHECK_HOLDER(2, unique); CHECK_HOLDER(3, unique); CHECK_HOLDER(4, unique); CHECK_HOLDER(5, unique);
-CHECK_HOLDER(6, shared); CHECK_HOLDER(7, shared); CHECK_HOLDER(8, shared);
-
-// There's no nice way to test that these fail because they fail to compile; leave them here,
-// though, so that they can be manually tested by uncommenting them (and seeing that compilation
-// failures occurs).
-
-// We have to actually look into the type: the typedef alone isn't enough to instantiate the type:
-#define CHECK_BROKEN(N) static_assert(std::is_same<typename Breaks##N::type, BreaksBase<-N>>::value, \
- "Breaks1 has wrong type!");
-
-//// Two holder classes:
-//typedef py::class_<BreaksBase<-1>, std::unique_ptr<BreaksBase<-1>>, std::unique_ptr<BreaksBase<-1>>> Breaks1;
-//CHECK_BROKEN(1);
-//// Two aliases:
-//typedef py::class_<BreaksBase<-2>, BreaksTramp<-2>, BreaksTramp<-2>> Breaks2;
-//CHECK_BROKEN(2);
-//// Holder + 2 aliases
-//typedef py::class_<BreaksBase<-3>, std::unique_ptr<BreaksBase<-3>>, BreaksTramp<-3>, BreaksTramp<-3>> Breaks3;
-//CHECK_BROKEN(3);
-//// Alias + 2 holders
-//typedef py::class_<BreaksBase<-4>, std::unique_ptr<BreaksBase<-4>>, BreaksTramp<-4>, std::shared_ptr<BreaksBase<-4>>> Breaks4;
-//CHECK_BROKEN(4);
-//// Invalid option (not a subclass or holder)
-//typedef py::class_<BreaksBase<-5>, BreaksTramp<-4>> Breaks5;
-//CHECK_BROKEN(5);
-//// Invalid option: multiple inheritance not supported:
-//template <> struct BreaksBase<-8> : BreaksBase<-6>, BreaksBase<-7> {};
-//typedef py::class_<BreaksBase<-8>, BreaksBase<-6>, BreaksBase<-7>> Breaks8;
-//CHECK_BROKEN(8);
-
-test_initializer class_args([](py::module &m) {
- // Just test that this compiled okay
- m.def("class_args_noop", []() {});
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_class_args.py b/thirdparty/pybind11/pybind11/tests/test_class_args.py
deleted file mode 100644
index 40cbcec9fb49a8837fe5d94a0194627645fa03db..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_class_args.py
+++ /dev/null
@@ -1,8 +0,0 @@
-
-
-def test_class_args():
- """There's basically nothing to test here; just make sure the code compiled
- and declared its definition
- """
- from pybind11_tests import class_args_noop
- class_args_noop()
diff --git a/thirdparty/pybind11/pybind11/tests/test_cmake_build/installed_function/CMakeLists.txt b/thirdparty/pybind11/pybind11/tests/test_cmake_build/installed_function/CMakeLists.txt
deleted file mode 100644
index e0c20a8a3634ea7e33859c5009ba2c9edd1b011a..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_cmake_build/installed_function/CMakeLists.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-cmake_minimum_required(VERSION 2.8.12)
-project(test_installed_module CXX)
-
-set(CMAKE_MODULE_PATH "")
-
-find_package(pybind11 CONFIG REQUIRED)
-message(STATUS "Found pybind11 v${pybind11_VERSION}: ${pybind11_INCLUDE_DIRS}")
-
-pybind11_add_module(test_cmake_build SHARED NO_EXTRAS ../main.cpp)
-
-add_custom_target(check ${CMAKE_COMMAND} -E env PYTHONPATH=$<TARGET_FILE_DIR:test_cmake_build>
- ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/../test.py ${PROJECT_NAME})
diff --git a/thirdparty/pybind11/pybind11/tests/test_cmake_build/installed_target/CMakeLists.txt b/thirdparty/pybind11/pybind11/tests/test_cmake_build/installed_target/CMakeLists.txt
deleted file mode 100644
index cd3ae6f7d84ccb6b7cf9ff58c71cd37a90d6710a..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_cmake_build/installed_target/CMakeLists.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-cmake_minimum_required(VERSION 3.0)
-project(test_installed_target CXX)
-
-set(CMAKE_MODULE_PATH "")
-
-find_package(pybind11 CONFIG REQUIRED)
-message(STATUS "Found pybind11 v${pybind11_VERSION}: ${pybind11_INCLUDE_DIRS}")
-
-add_library(test_cmake_build MODULE ../main.cpp)
-
-target_link_libraries(test_cmake_build PRIVATE pybind11::module)
-
-# make sure result is, for example, test_installed_target.so, not libtest_installed_target.dylib
-set_target_properties(test_cmake_build PROPERTIES PREFIX "${PYTHON_MODULE_PREFIX}"
- SUFFIX "${PYTHON_MODULE_EXTENSION}")
-
-# Do not treat includes from IMPORTED target as SYSTEM (Python headers in pybind11::module).
-# This may be needed to resolve header conflicts, e.g. between Python release and debug headers.
-set_target_properties(test_cmake_build PROPERTIES NO_SYSTEM_FROM_IMPORTED ON)
-
-add_custom_target(check ${CMAKE_COMMAND} -E env PYTHONPATH=$<TARGET_FILE_DIR:test_cmake_build>
- ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/../test.py ${PROJECT_NAME})
diff --git a/thirdparty/pybind11/pybind11/tests/test_cmake_build/main.cpp b/thirdparty/pybind11/pybind11/tests/test_cmake_build/main.cpp
deleted file mode 100644
index e0f5b69c9f8181cd9ac2bbe1c33ace4cdb5e7c6b..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_cmake_build/main.cpp
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <pybind11/pybind11.h>
-namespace py = pybind11;
-
-PYBIND11_PLUGIN(test_cmake_build) {
- py::module m("test_cmake_build");
-
- m.def("add", [](int i, int j) { return i + j; });
-
- return m.ptr();
-}
diff --git a/thirdparty/pybind11/pybind11/tests/test_cmake_build/subdirectory_function/CMakeLists.txt b/thirdparty/pybind11/pybind11/tests/test_cmake_build/subdirectory_function/CMakeLists.txt
deleted file mode 100644
index 278007aebd1c130cce62772decb6a19cd77e3fbb..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_cmake_build/subdirectory_function/CMakeLists.txt
+++ /dev/null
@@ -1,8 +0,0 @@
-cmake_minimum_required(VERSION 2.8.12)
-project(test_subdirectory_module CXX)
-
-add_subdirectory(${PYBIND11_PROJECT_DIR} pybind11)
-pybind11_add_module(test_cmake_build THIN_LTO ../main.cpp)
-
-add_custom_target(check ${CMAKE_COMMAND} -E env PYTHONPATH=$<TARGET_FILE_DIR:test_cmake_build>
- ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/../test.py ${PROJECT_NAME})
diff --git a/thirdparty/pybind11/pybind11/tests/test_cmake_build/subdirectory_target/CMakeLists.txt b/thirdparty/pybind11/pybind11/tests/test_cmake_build/subdirectory_target/CMakeLists.txt
deleted file mode 100644
index 6b142d62a931a3636e4074a6d39be5a0e7052689..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_cmake_build/subdirectory_target/CMakeLists.txt
+++ /dev/null
@@ -1,15 +0,0 @@
-cmake_minimum_required(VERSION 3.0)
-project(test_subdirectory_target CXX)
-
-add_subdirectory(${PYBIND11_PROJECT_DIR} pybind11)
-
-add_library(test_cmake_build MODULE ../main.cpp)
-
-target_link_libraries(test_cmake_build PRIVATE pybind11::module)
-
-# make sure result is, for example, test_installed_target.so, not libtest_installed_target.dylib
-set_target_properties(test_cmake_build PROPERTIES PREFIX "${PYTHON_MODULE_PREFIX}"
- SUFFIX "${PYTHON_MODULE_EXTENSION}")
-
-add_custom_target(check ${CMAKE_COMMAND} -E env PYTHONPATH=$<TARGET_FILE_DIR:test_cmake_build>
- ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/../test.py ${PROJECT_NAME})
diff --git a/thirdparty/pybind11/pybind11/tests/test_cmake_build/test.py b/thirdparty/pybind11/pybind11/tests/test_cmake_build/test.py
deleted file mode 100644
index 1467a61dc0e75c05c8a91ce3b8bc6c2338ff8c3e..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_cmake_build/test.py
+++ /dev/null
@@ -1,5 +0,0 @@
-import sys
-import test_cmake_build
-
-assert test_cmake_build.add(1, 2) == 3
-print("{} imports, runs, and adds: 1 + 2 = 3".format(sys.argv[1]))
diff --git a/thirdparty/pybind11/pybind11/tests/test_constants_and_functions.cpp b/thirdparty/pybind11/pybind11/tests/test_constants_and_functions.cpp
deleted file mode 100644
index 653bdf6b64d051ef76e5962eb610086f43fe2758..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_constants_and_functions.cpp
+++ /dev/null
@@ -1,104 +0,0 @@
-/*
- tests/test_constants_and_functions.cpp -- global constants and functions, enumerations, raw byte strings
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-enum MyEnum { EFirstEntry = 1, ESecondEntry };
-
-std::string test_function1() {
- return "test_function()";
-}
-
-std::string test_function2(MyEnum k) {
- return "test_function(enum=" + std::to_string(k) + ")";
-}
-
-std::string test_function3(int i) {
- return "test_function(" + std::to_string(i) + ")";
-}
-
-py::str test_function4(int, float) { return "test_function(int, float)"; }
-py::str test_function4(float, int) { return "test_function(float, int)"; }
-
-py::bytes return_bytes() {
- const char *data = "\x01\x00\x02\x00";
- return std::string(data, 4);
-}
-
-std::string print_bytes(py::bytes bytes) {
- std::string ret = "bytes[";
- const auto value = static_cast<std::string>(bytes);
- for (size_t i = 0; i < value.length(); ++i) {
- ret += std::to_string(static_cast<int>(value[i])) + " ";
- }
- ret.back() = ']';
- return ret;
-}
-
-// Test that we properly handle C++17 exception specifiers (which are part of the function signature
-// in C++17). These should all still work before C++17, but don't affect the function signature.
-namespace test_exc_sp {
-int f1(int x) noexcept { return x+1; }
-int f2(int x) noexcept(true) { return x+2; }
-int f3(int x) noexcept(false) { return x+3; }
-int f4(int x) throw() { return x+4; } // Deprecated equivalent to noexcept(true)
-struct C {
- int m1(int x) noexcept { return x-1; }
- int m2(int x) const noexcept { return x-2; }
- int m3(int x) noexcept(true) { return x-3; }
- int m4(int x) const noexcept(true) { return x-4; }
- int m5(int x) noexcept(false) { return x-5; }
- int m6(int x) const noexcept(false) { return x-6; }
- int m7(int x) throw() { return x-7; }
- int m8(int x) const throw() { return x-8; }
-};
-}
-
-
-test_initializer constants_and_functions([](py::module &m) {
- m.attr("some_constant") = py::int_(14);
-
- m.def("test_function", &test_function1);
- m.def("test_function", &test_function2);
- m.def("test_function", &test_function3);
-
-#if defined(PYBIND11_OVERLOAD_CAST)
- m.def("test_function", py::overload_cast<int, float>(&test_function4));
- m.def("test_function", py::overload_cast<float, int>(&test_function4));
-#else
- m.def("test_function", static_cast<py::str (*)(int, float)>(&test_function4));
- m.def("test_function", static_cast<py::str (*)(float, int)>(&test_function4));
-#endif
-
- py::enum_<MyEnum>(m, "MyEnum")
- .value("EFirstEntry", EFirstEntry)
- .value("ESecondEntry", ESecondEntry)
- .export_values();
-
- m.def("return_bytes", &return_bytes);
- m.def("print_bytes", &print_bytes);
-
- using namespace test_exc_sp;
- py::module m2 = m.def_submodule("exc_sp");
- py::class_<C>(m2, "C")
- .def(py::init<>())
- .def("m1", &C::m1)
- .def("m2", &C::m2)
- .def("m3", &C::m3)
- .def("m4", &C::m4)
- .def("m5", &C::m5)
- .def("m6", &C::m6)
- .def("m7", &C::m7)
- .def("m8", &C::m8)
- ;
- m2.def("f1", f1);
- m2.def("f2", f2);
- m2.def("f3", f3);
- m2.def("f4", f4);
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_constants_and_functions.py b/thirdparty/pybind11/pybind11/tests/test_constants_and_functions.py
deleted file mode 100644
index 2a570d2e588f26b1f51bcafc138d00a6873659c6..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_constants_and_functions.py
+++ /dev/null
@@ -1,43 +0,0 @@
-
-
-def test_constants():
- from pybind11_tests import some_constant
-
- assert some_constant == 14
-
-
-def test_function_overloading():
- from pybind11_tests import MyEnum, test_function
-
- assert test_function() == "test_function()"
- assert test_function(7) == "test_function(7)"
- assert test_function(MyEnum.EFirstEntry) == "test_function(enum=1)"
- assert test_function(MyEnum.ESecondEntry) == "test_function(enum=2)"
-
- assert test_function(1, 1.0) == "test_function(int, float)"
- assert test_function(2.0, 2) == "test_function(float, int)"
-
-
-def test_bytes():
- from pybind11_tests import return_bytes, print_bytes
-
- assert print_bytes(return_bytes()) == "bytes[1 0 2 0]"
-
-
-def test_exception_specifiers():
- from pybind11_tests.exc_sp import C, f1, f2, f3, f4
-
- c = C()
- assert c.m1(2) == 1
- assert c.m2(3) == 1
- assert c.m3(5) == 2
- assert c.m4(7) == 3
- assert c.m5(10) == 5
- assert c.m6(14) == 8
- assert c.m7(20) == 13
- assert c.m8(29) == 21
-
- assert f1(33) == 34
- assert f2(53) == 55
- assert f3(86) == 89
- assert f4(140) == 144
diff --git a/thirdparty/pybind11/pybind11/tests/test_copy_move_policies.cpp b/thirdparty/pybind11/pybind11/tests/test_copy_move_policies.cpp
deleted file mode 100644
index 6f7907c1f94ae673abb8b817785c2a7fd7e8a970..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_copy_move_policies.cpp
+++ /dev/null
@@ -1,41 +0,0 @@
-/*
- tests/test_copy_move_policies.cpp -- 'copy' and 'move'
- return value policies
-
- Copyright (c) 2016 Ben North <ben@redfrontdoor.org>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-template <typename derived>
-struct empty {
- static const derived& get_one() { return instance_; }
- static derived instance_;
-};
-
-struct lacking_copy_ctor : public empty<lacking_copy_ctor> {
- lacking_copy_ctor() {}
- lacking_copy_ctor(const lacking_copy_ctor& other) = delete;
-};
-
-template <> lacking_copy_ctor empty<lacking_copy_ctor>::instance_ = {};
-
-struct lacking_move_ctor : public empty<lacking_move_ctor> {
- lacking_move_ctor() {}
- lacking_move_ctor(const lacking_move_ctor& other) = delete;
- lacking_move_ctor(lacking_move_ctor&& other) = delete;
-};
-
-template <> lacking_move_ctor empty<lacking_move_ctor>::instance_ = {};
-
-test_initializer copy_move_policies([](py::module &m) {
- py::class_<lacking_copy_ctor>(m, "lacking_copy_ctor")
- .def_static("get_one", &lacking_copy_ctor::get_one,
- py::return_value_policy::copy);
- py::class_<lacking_move_ctor>(m, "lacking_move_ctor")
- .def_static("get_one", &lacking_move_ctor::get_one,
- py::return_value_policy::move);
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_copy_move_policies.py b/thirdparty/pybind11/pybind11/tests/test_copy_move_policies.py
deleted file mode 100644
index edcf38075fa5254eb8927cec0e459ba616af7b49..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_copy_move_policies.py
+++ /dev/null
@@ -1,15 +0,0 @@
-import pytest
-
-
-def test_lacking_copy_ctor():
- from pybind11_tests import lacking_copy_ctor
- with pytest.raises(RuntimeError) as excinfo:
- lacking_copy_ctor.get_one()
- assert "the object is non-copyable!" in str(excinfo.value)
-
-
-def test_lacking_move_ctor():
- from pybind11_tests import lacking_move_ctor
- with pytest.raises(RuntimeError) as excinfo:
- lacking_move_ctor.get_one()
- assert "the object is neither movable nor copyable!" in str(excinfo.value)
diff --git a/thirdparty/pybind11/pybind11/tests/test_docstring_options.cpp b/thirdparty/pybind11/pybind11/tests/test_docstring_options.cpp
deleted file mode 100644
index 9a9297cc35e89d3a8aeb18c56b1d852cc3deaefd..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_docstring_options.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- tests/test_docstring_options.cpp -- generation of docstrings and signatures
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-struct DocstringTestFoo {
- int value;
- void setValue(int v) { value = v; }
- int getValue() const { return value; }
-};
-
-test_initializer docstring_generation([](py::module &m) {
-
- {
- py::options options;
- options.disable_function_signatures();
-
- m.def("test_function1", [](int, int) {}, py::arg("a"), py::arg("b"));
- m.def("test_function2", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
-
- m.def("test_overloaded1", [](int) {}, py::arg("i"), "Overload docstring");
- m.def("test_overloaded1", [](double) {}, py::arg("d"));
-
- m.def("test_overloaded2", [](int) {}, py::arg("i"), "overload docstring 1");
- m.def("test_overloaded2", [](double) {}, py::arg("d"), "overload docstring 2");
-
- m.def("test_overloaded3", [](int) {}, py::arg("i"));
- m.def("test_overloaded3", [](double) {}, py::arg("d"), "Overload docstr");
-
- options.enable_function_signatures();
-
- m.def("test_function3", [](int, int) {}, py::arg("a"), py::arg("b"));
- m.def("test_function4", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
-
- options.disable_function_signatures().disable_user_defined_docstrings();
-
- m.def("test_function5", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
-
- {
- py::options nested_options;
- nested_options.enable_user_defined_docstrings();
- m.def("test_function6", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
- }
- }
-
- m.def("test_function7", [](int, int) {}, py::arg("a"), py::arg("b"), "A custom docstring");
-
- {
- py::options options;
- options.disable_user_defined_docstrings();
-
- py::class_<DocstringTestFoo>(m, "DocstringTestFoo", "This is a class docstring")
- .def_property("value_prop", &DocstringTestFoo::getValue, &DocstringTestFoo::setValue, "This is a property docstring")
- ;
- }
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_docstring_options.py b/thirdparty/pybind11/pybind11/tests/test_docstring_options.py
deleted file mode 100644
index 5e40f68687832fbf8ed5fcec735b9cff05459b8d..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_docstring_options.py
+++ /dev/null
@@ -1,42 +0,0 @@
-
-
-def test_docstring_options():
- from pybind11_tests import (test_function1, test_function2, test_function3,
- test_function4, test_function5, test_function6,
- test_function7, DocstringTestFoo,
- test_overloaded1, test_overloaded2, test_overloaded3)
-
- # options.disable_function_signatures()
- assert not test_function1.__doc__
-
- assert test_function2.__doc__ == "A custom docstring"
-
- # docstring specified on just the first overload definition:
- assert test_overloaded1.__doc__ == "Overload docstring"
-
- # docstring on both overloads:
- assert test_overloaded2.__doc__ == "overload docstring 1\noverload docstring 2"
-
- # docstring on only second overload:
- assert test_overloaded3.__doc__ == "Overload docstr"
-
- # options.enable_function_signatures()
- assert test_function3.__doc__ .startswith("test_function3(a: int, b: int) -> None")
-
- assert test_function4.__doc__ .startswith("test_function4(a: int, b: int) -> None")
- assert test_function4.__doc__ .endswith("A custom docstring\n")
-
- # options.disable_function_signatures()
- # options.disable_user_defined_docstrings()
- assert not test_function5.__doc__
-
- # nested options.enable_user_defined_docstrings()
- assert test_function6.__doc__ == "A custom docstring"
-
- # RAII destructor
- assert test_function7.__doc__ .startswith("test_function7(a: int, b: int) -> None")
- assert test_function7.__doc__ .endswith("A custom docstring\n")
-
- # Suppression of user-defined docstrings for non-function objects
- assert not DocstringTestFoo.__doc__
- assert not DocstringTestFoo.value_prop.__doc__
diff --git a/thirdparty/pybind11/pybind11/tests/test_eigen.cpp b/thirdparty/pybind11/pybind11/tests/test_eigen.cpp
deleted file mode 100644
index f2ec8fd2e67c06ed760e5b3dbaa589bd884b4abd..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_eigen.cpp
+++ /dev/null
@@ -1,294 +0,0 @@
-/*
- tests/eigen.cpp -- automatic conversion of Eigen types
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include "constructor_stats.h"
-#include <pybind11/eigen.h>
-#include <Eigen/Cholesky>
-
-using MatrixXdR = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
-
-
-
-// Sets/resets a testing reference matrix to have values of 10*r + c, where r and c are the
-// (1-based) row/column number.
-template <typename M> void reset_ref(M &x) {
- for (int i = 0; i < x.rows(); i++) for (int j = 0; j < x.cols(); j++)
- x(i, j) = 11 + 10*i + j;
-}
-
-// Returns a static, column-major matrix
-Eigen::MatrixXd &get_cm() {
- static Eigen::MatrixXd *x;
- if (!x) {
- x = new Eigen::MatrixXd(3, 3);
- reset_ref(*x);
- }
- return *x;
-}
-// Likewise, but row-major
-MatrixXdR &get_rm() {
- static MatrixXdR *x;
- if (!x) {
- x = new MatrixXdR(3, 3);
- reset_ref(*x);
- }
- return *x;
-}
-// Resets the values of the static matrices returned by get_cm()/get_rm()
-void reset_refs() {
- reset_ref(get_cm());
- reset_ref(get_rm());
-}
-
-// Returns element 2,1 from a matrix (used to test copy/nocopy)
-double get_elem(Eigen::Ref<const Eigen::MatrixXd> m) { return m(2, 1); };
-
-
-// Returns a matrix with 10*r + 100*c added to each matrix element (to help test that the matrix
-// reference is referencing rows/columns correctly).
-template <typename MatrixArgType> Eigen::MatrixXd adjust_matrix(MatrixArgType m) {
- Eigen::MatrixXd ret(m);
- for (int c = 0; c < m.cols(); c++) for (int r = 0; r < m.rows(); r++)
- ret(r, c) += 10*r + 100*c;
- return ret;
-}
-
-struct CustomOperatorNew {
- CustomOperatorNew() = default;
-
- Eigen::Matrix4d a = Eigen::Matrix4d::Zero();
- Eigen::Matrix4d b = Eigen::Matrix4d::Identity();
-
- EIGEN_MAKE_ALIGNED_OPERATOR_NEW;
-};
-
-test_initializer eigen([](py::module &m) {
- typedef Eigen::Matrix<float, 5, 6, Eigen::RowMajor> FixedMatrixR;
- typedef Eigen::Matrix<float, 5, 6> FixedMatrixC;
- typedef Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor> DenseMatrixR;
- typedef Eigen::Matrix<float, Eigen::Dynamic, Eigen::Dynamic> DenseMatrixC;
- typedef Eigen::Matrix<float, 4, Eigen::Dynamic> FourRowMatrixC;
- typedef Eigen::Matrix<float, Eigen::Dynamic, 4> FourColMatrixC;
- typedef Eigen::Matrix<float, 4, Eigen::Dynamic> FourRowMatrixR;
- typedef Eigen::Matrix<float, Eigen::Dynamic, 4> FourColMatrixR;
- typedef Eigen::SparseMatrix<float, Eigen::RowMajor> SparseMatrixR;
- typedef Eigen::SparseMatrix<float> SparseMatrixC;
-
- m.attr("have_eigen") = true;
-
- m.def("double_col", [](const Eigen::VectorXf &x) -> Eigen::VectorXf { return 2.0f * x; });
- m.def("double_row", [](const Eigen::RowVectorXf &x) -> Eigen::RowVectorXf { return 2.0f * x; });
- m.def("double_complex", [](const Eigen::VectorXcf &x) -> Eigen::VectorXcf { return 2.0f * x; });
- m.def("double_threec", [](py::EigenDRef<Eigen::Vector3f> x) { x *= 2; });
- m.def("double_threer", [](py::EigenDRef<Eigen::RowVector3f> x) { x *= 2; });
- m.def("double_mat_cm", [](Eigen::MatrixXf x) -> Eigen::MatrixXf { return 2.0f * x; });
- m.def("double_mat_rm", [](DenseMatrixR x) -> DenseMatrixR { return 2.0f * x; });
-
- // Different ways of passing via Eigen::Ref; the first and second are the Eigen-recommended
- m.def("cholesky1", [](Eigen::Ref<MatrixXdR> x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
- m.def("cholesky2", [](const Eigen::Ref<const MatrixXdR> &x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
- m.def("cholesky3", [](const Eigen::Ref<MatrixXdR> &x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
- m.def("cholesky4", [](Eigen::Ref<const MatrixXdR> x) -> Eigen::MatrixXd { return x.llt().matrixL(); });
-
- // Mutators: these add some value to the given element using Eigen, but Eigen should be mapping into
- // the numpy array data and so the result should show up there. There are three versions: one that
- // works on a contiguous-row matrix (numpy's default), one for a contiguous-column matrix, and one
- // for any matrix.
- auto add_rm = [](Eigen::Ref<MatrixXdR> x, int r, int c, double v) { x(r,c) += v; };
- auto add_cm = [](Eigen::Ref<Eigen::MatrixXd> x, int r, int c, double v) { x(r,c) += v; };
-
- // Mutators (Eigen maps into numpy variables):
- m.def("add_rm", add_rm); // Only takes row-contiguous
- m.def("add_cm", add_cm); // Only takes column-contiguous
- // Overloaded versions that will accept either row or column contiguous:
- m.def("add1", add_rm);
- m.def("add1", add_cm);
- m.def("add2", add_cm);
- m.def("add2", add_rm);
- // This one accepts a matrix of any stride:
- m.def("add_any", [](py::EigenDRef<Eigen::MatrixXd> x, int r, int c, double v) { x(r,c) += v; });
-
- // Return mutable references (numpy maps into eigen varibles)
- m.def("get_cm_ref", []() { return Eigen::Ref<Eigen::MatrixXd>(get_cm()); });
- m.def("get_rm_ref", []() { return Eigen::Ref<MatrixXdR>(get_rm()); });
- // The same references, but non-mutable (numpy maps into eigen variables, but is !writeable)
- m.def("get_cm_const_ref", []() { return Eigen::Ref<const Eigen::MatrixXd>(get_cm()); });
- m.def("get_rm_const_ref", []() { return Eigen::Ref<const MatrixXdR>(get_rm()); });
- // Just the corners (via a Map instead of a Ref):
- m.def("get_cm_corners", []() {
- auto &x = get_cm();
- return py::EigenDMap<Eigen::Matrix2d>(
- x.data(),
- py::EigenDStride(x.outerStride() * (x.rows() - 1), x.innerStride() * (x.cols() - 1)));
- });
- m.def("get_cm_corners_const", []() {
- const auto &x = get_cm();
- return py::EigenDMap<const Eigen::Matrix2d>(
- x.data(),
- py::EigenDStride(x.outerStride() * (x.rows() - 1), x.innerStride() * (x.cols() - 1)));
- });
-
- m.def("reset_refs", reset_refs); // Restores get_{cm,rm}_ref to original values
-
- // Increments and returns ref to (same) matrix
- m.def("incr_matrix", [](Eigen::Ref<Eigen::MatrixXd> m, double v) {
- m += Eigen::MatrixXd::Constant(m.rows(), m.cols(), v);
- return m;
- }, py::return_value_policy::reference);
-
- // Same, but accepts a matrix of any strides
- m.def("incr_matrix_any", [](py::EigenDRef<Eigen::MatrixXd> m, double v) {
- m += Eigen::MatrixXd::Constant(m.rows(), m.cols(), v);
- return m;
- }, py::return_value_policy::reference);
-
- // Returns an eigen slice of even rows
- m.def("even_rows", [](py::EigenDRef<Eigen::MatrixXd> m) {
- return py::EigenDMap<Eigen::MatrixXd>(
- m.data(), (m.rows() + 1) / 2, m.cols(),
- py::EigenDStride(m.outerStride(), 2 * m.innerStride()));
- }, py::return_value_policy::reference);
-
- // Returns an eigen slice of even columns
- m.def("even_cols", [](py::EigenDRef<Eigen::MatrixXd> m) {
- return py::EigenDMap<Eigen::MatrixXd>(
- m.data(), m.rows(), (m.cols() + 1) / 2,
- py::EigenDStride(2 * m.outerStride(), m.innerStride()));
- }, py::return_value_policy::reference);
-
- // Returns diagonals: a vector-like object with an inner stride != 1
- m.def("diagonal", [](const Eigen::Ref<const Eigen::MatrixXd> &x) { return x.diagonal(); });
- m.def("diagonal_1", [](const Eigen::Ref<const Eigen::MatrixXd> &x) { return x.diagonal<1>(); });
- m.def("diagonal_n", [](const Eigen::Ref<const Eigen::MatrixXd> &x, int index) { return x.diagonal(index); });
-
- // Return a block of a matrix (gives non-standard strides)
- m.def("block", [](const Eigen::Ref<const Eigen::MatrixXd> &x, int start_row, int start_col, int block_rows, int block_cols) {
- return x.block(start_row, start_col, block_rows, block_cols);
- });
-
- // return value referencing/copying tests:
- class ReturnTester {
- Eigen::MatrixXd mat = create();
- public:
- ReturnTester() { print_created(this); }
- ~ReturnTester() { print_destroyed(this); }
- static Eigen::MatrixXd create() { return Eigen::MatrixXd::Ones(10, 10); }
- static const Eigen::MatrixXd createConst() { return Eigen::MatrixXd::Ones(10, 10); }
- Eigen::MatrixXd &get() { return mat; }
- Eigen::MatrixXd *getPtr() { return &mat; }
- const Eigen::MatrixXd &view() { return mat; }
- const Eigen::MatrixXd *viewPtr() { return &mat; }
- Eigen::Ref<Eigen::MatrixXd> ref() { return mat; }
- Eigen::Ref<const Eigen::MatrixXd> refConst() { return mat; }
- Eigen::Block<Eigen::MatrixXd> block(int r, int c, int nrow, int ncol) { return mat.block(r, c, nrow, ncol); }
- Eigen::Block<const Eigen::MatrixXd> blockConst(int r, int c, int nrow, int ncol) const { return mat.block(r, c, nrow, ncol); }
- py::EigenDMap<Eigen::Matrix2d> corners() { return py::EigenDMap<Eigen::Matrix2d>(mat.data(),
- py::EigenDStride(mat.outerStride() * (mat.outerSize()-1), mat.innerStride() * (mat.innerSize()-1))); }
- py::EigenDMap<const Eigen::Matrix2d> cornersConst() const { return py::EigenDMap<const Eigen::Matrix2d>(mat.data(),
- py::EigenDStride(mat.outerStride() * (mat.outerSize()-1), mat.innerStride() * (mat.innerSize()-1))); }
- };
- using rvp = py::return_value_policy;
- py::class_<ReturnTester>(m, "ReturnTester")
- .def(py::init<>())
- .def_static("create", &ReturnTester::create)
- .def_static("create_const", &ReturnTester::createConst)
- .def("get", &ReturnTester::get, rvp::reference_internal)
- .def("get_ptr", &ReturnTester::getPtr, rvp::reference_internal)
- .def("view", &ReturnTester::view, rvp::reference_internal)
- .def("view_ptr", &ReturnTester::view, rvp::reference_internal)
- .def("copy_get", &ReturnTester::get) // Default rvp: copy
- .def("copy_view", &ReturnTester::view) // "
- .def("ref", &ReturnTester::ref) // Default for Ref is to reference
- .def("ref_const", &ReturnTester::refConst) // Likewise, but const
- .def("ref_safe", &ReturnTester::ref, rvp::reference_internal)
- .def("ref_const_safe", &ReturnTester::refConst, rvp::reference_internal)
- .def("copy_ref", &ReturnTester::ref, rvp::copy)
- .def("copy_ref_const", &ReturnTester::refConst, rvp::copy)
- .def("block", &ReturnTester::block)
- .def("block_safe", &ReturnTester::block, rvp::reference_internal)
- .def("block_const", &ReturnTester::blockConst, rvp::reference_internal)
- .def("copy_block", &ReturnTester::block, rvp::copy)
- .def("corners", &ReturnTester::corners, rvp::reference_internal)
- .def("corners_const", &ReturnTester::cornersConst, rvp::reference_internal)
- ;
-
- // Returns a DiagonalMatrix with diagonal (1,2,3,...)
- m.def("incr_diag", [](int k) {
- Eigen::DiagonalMatrix<int, Eigen::Dynamic> m(k);
- for (int i = 0; i < k; i++) m.diagonal()[i] = i+1;
- return m;
- });
-
- // Returns a SelfAdjointView referencing the lower triangle of m
- m.def("symmetric_lower", [](const Eigen::MatrixXi &m) {
- return m.selfadjointView<Eigen::Lower>();
- });
- // Returns a SelfAdjointView referencing the lower triangle of m
- m.def("symmetric_upper", [](const Eigen::MatrixXi &m) {
- return m.selfadjointView<Eigen::Upper>();
- });
-
- // Test matrix for various functions below.
- Eigen::MatrixXf mat(5, 6);
- mat << 0, 3, 0, 0, 0, 11,
- 22, 0, 0, 0, 17, 11,
- 7, 5, 0, 1, 0, 11,
- 0, 0, 0, 0, 0, 11,
- 0, 0, 14, 0, 8, 11;
-
- m.def("fixed_r", [mat]() -> FixedMatrixR { return FixedMatrixR(mat); });
- m.def("fixed_r_const", [mat]() -> const FixedMatrixR { return FixedMatrixR(mat); });
- m.def("fixed_c", [mat]() -> FixedMatrixC { return FixedMatrixC(mat); });
- m.def("fixed_copy_r", [](const FixedMatrixR &m) -> FixedMatrixR { return m; });
- m.def("fixed_copy_c", [](const FixedMatrixC &m) -> FixedMatrixC { return m; });
- m.def("fixed_mutator_r", [](Eigen::Ref<FixedMatrixR>) {});
- m.def("fixed_mutator_c", [](Eigen::Ref<FixedMatrixC>) {});
- m.def("fixed_mutator_a", [](py::EigenDRef<FixedMatrixC>) {});
- m.def("dense_r", [mat]() -> DenseMatrixR { return DenseMatrixR(mat); });
- m.def("dense_c", [mat]() -> DenseMatrixC { return DenseMatrixC(mat); });
- m.def("dense_copy_r", [](const DenseMatrixR &m) -> DenseMatrixR { return m; });
- m.def("dense_copy_c", [](const DenseMatrixC &m) -> DenseMatrixC { return m; });
- m.def("sparse_r", [mat]() -> SparseMatrixR { return Eigen::SparseView<Eigen::MatrixXf>(mat); });
- m.def("sparse_c", [mat]() -> SparseMatrixC { return Eigen::SparseView<Eigen::MatrixXf>(mat); });
- m.def("sparse_copy_r", [](const SparseMatrixR &m) -> SparseMatrixR { return m; });
- m.def("sparse_copy_c", [](const SparseMatrixC &m) -> SparseMatrixC { return m; });
- m.def("partial_copy_four_rm_r", [](const FourRowMatrixR &m) -> FourRowMatrixR { return m; });
- m.def("partial_copy_four_rm_c", [](const FourColMatrixR &m) -> FourColMatrixR { return m; });
- m.def("partial_copy_four_cm_r", [](const FourRowMatrixC &m) -> FourRowMatrixC { return m; });
- m.def("partial_copy_four_cm_c", [](const FourColMatrixC &m) -> FourColMatrixC { return m; });
-
- // Test that we can cast a numpy object to a Eigen::MatrixXd explicitly
- m.def("cpp_copy", [](py::handle m) { return m.cast<Eigen::MatrixXd>()(1, 0); });
- m.def("cpp_ref_c", [](py::handle m) { return m.cast<Eigen::Ref<Eigen::MatrixXd>>()(1, 0); });
- m.def("cpp_ref_r", [](py::handle m) { return m.cast<Eigen::Ref<MatrixXdR>>()(1, 0); });
- m.def("cpp_ref_any", [](py::handle m) { return m.cast<py::EigenDRef<Eigen::MatrixXd>>()(1, 0); });
-
-
- // Test that we can prevent copying into an argument that would normally copy: First a version
- // that would allow copying (if types or strides don't match) for comparison:
- m.def("get_elem", &get_elem);
- // Now this alternative that calls the tells pybind to fail rather than copy:
- m.def("get_elem_nocopy", [](Eigen::Ref<const Eigen::MatrixXd> m) -> double { return get_elem(m); },
- py::arg().noconvert());
- // Also test a row-major-only no-copy const ref:
- m.def("get_elem_rm_nocopy", [](Eigen::Ref<const Eigen::Matrix<long, -1, -1, Eigen::RowMajor>> &m) -> long { return m(2, 1); },
- py::arg().noconvert());
-
- // Issue #738: 1xN or Nx1 2D matrices were neither accepted nor properly copied with an
- // incompatible stride value on the length-1 dimension--but that should be allowed (without
- // requiring a copy!) because the stride value can be safely ignored on a size-1 dimension.
- m.def("iss738_f1", &adjust_matrix<const Eigen::Ref<const Eigen::MatrixXd> &>, py::arg().noconvert());
- m.def("iss738_f2", &adjust_matrix<const Eigen::Ref<const Eigen::Matrix<double, -1, -1, Eigen::RowMajor>> &>, py::arg().noconvert());
-
- py::class_<CustomOperatorNew>(m, "CustomOperatorNew")
- .def(py::init<>())
- .def_readonly("a", &CustomOperatorNew::a)
- .def_readonly("b", &CustomOperatorNew::b);
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_eigen.py b/thirdparty/pybind11/pybind11/tests/test_eigen.py
deleted file mode 100644
index df08edf3d7951e65046ae9490b6faf7b06eb8f69..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_eigen.py
+++ /dev/null
@@ -1,626 +0,0 @@
-import pytest
-
-pytestmark = pytest.requires_eigen_and_numpy
-
-with pytest.suppress(ImportError):
- import numpy as np
-
- ref = np.array([[ 0., 3, 0, 0, 0, 11],
- [22, 0, 0, 0, 17, 11],
- [ 7, 5, 0, 1, 0, 11],
- [ 0, 0, 0, 0, 0, 11],
- [ 0, 0, 14, 0, 8, 11]])
-
-
-def assert_equal_ref(mat):
- np.testing.assert_array_equal(mat, ref)
-
-
-def assert_sparse_equal_ref(sparse_mat):
- assert_equal_ref(sparse_mat.todense())
-
-
-def test_fixed():
- from pybind11_tests import fixed_r, fixed_c, fixed_copy_r, fixed_copy_c
-
- assert_equal_ref(fixed_c())
- assert_equal_ref(fixed_r())
- assert_equal_ref(fixed_copy_r(fixed_r()))
- assert_equal_ref(fixed_copy_c(fixed_c()))
- assert_equal_ref(fixed_copy_r(fixed_c()))
- assert_equal_ref(fixed_copy_c(fixed_r()))
-
-
-def test_dense():
- from pybind11_tests import dense_r, dense_c, dense_copy_r, dense_copy_c
-
- assert_equal_ref(dense_r())
- assert_equal_ref(dense_c())
- assert_equal_ref(dense_copy_r(dense_r()))
- assert_equal_ref(dense_copy_c(dense_c()))
- assert_equal_ref(dense_copy_r(dense_c()))
- assert_equal_ref(dense_copy_c(dense_r()))
-
-
-def test_partially_fixed():
- from pybind11_tests import (partial_copy_four_rm_r, partial_copy_four_rm_c,
- partial_copy_four_cm_r, partial_copy_four_cm_c)
-
- ref2 = np.array([[0., 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15]])
- np.testing.assert_array_equal(partial_copy_four_rm_r(ref2), ref2)
- np.testing.assert_array_equal(partial_copy_four_rm_c(ref2), ref2)
- np.testing.assert_array_equal(partial_copy_four_rm_r(ref2[:, 1]), ref2[:, [1]])
- np.testing.assert_array_equal(partial_copy_four_rm_c(ref2[0, :]), ref2[[0], :])
- np.testing.assert_array_equal(partial_copy_four_rm_r(ref2[:, (0, 2)]), ref2[:, (0, 2)])
- np.testing.assert_array_equal(
- partial_copy_four_rm_c(ref2[(3, 1, 2), :]), ref2[(3, 1, 2), :])
-
- np.testing.assert_array_equal(partial_copy_four_cm_r(ref2), ref2)
- np.testing.assert_array_equal(partial_copy_four_cm_c(ref2), ref2)
- np.testing.assert_array_equal(partial_copy_four_cm_r(ref2[:, 1]), ref2[:, [1]])
- np.testing.assert_array_equal(partial_copy_four_cm_c(ref2[0, :]), ref2[[0], :])
- np.testing.assert_array_equal(partial_copy_four_cm_r(ref2[:, (0, 2)]), ref2[:, (0, 2)])
- np.testing.assert_array_equal(
- partial_copy_four_cm_c(ref2[(3, 1, 2), :]), ref2[(3, 1, 2), :])
-
-
-def test_mutator_descriptors():
- from pybind11_tests import fixed_mutator_r, fixed_mutator_c, fixed_mutator_a
- zr = np.arange(30, dtype='float32').reshape(5, 6) # row-major
- zc = zr.reshape(6, 5).transpose() # column-major
-
- fixed_mutator_r(zr)
- fixed_mutator_c(zc)
- fixed_mutator_a(zr)
- fixed_mutator_a(zc)
- with pytest.raises(TypeError) as excinfo:
- fixed_mutator_r(zc)
- assert ('(numpy.ndarray[float32[5, 6], flags.writeable, flags.c_contiguous]) -> arg0: None'
- in str(excinfo.value))
- with pytest.raises(TypeError) as excinfo:
- fixed_mutator_c(zr)
- assert ('(numpy.ndarray[float32[5, 6], flags.writeable, flags.f_contiguous]) -> arg0: None'
- in str(excinfo.value))
- with pytest.raises(TypeError) as excinfo:
- fixed_mutator_a(np.array([[1, 2], [3, 4]], dtype='float32'))
- assert ('(numpy.ndarray[float32[5, 6], flags.writeable]) -> arg0: None'
- in str(excinfo.value))
- zr.flags.writeable = False
- with pytest.raises(TypeError):
- fixed_mutator_r(zr)
- with pytest.raises(TypeError):
- fixed_mutator_a(zr)
-
-
-def test_cpp_casting():
- from pybind11_tests import (cpp_copy, cpp_ref_c, cpp_ref_r, cpp_ref_any,
- fixed_r, fixed_c, get_cm_ref, get_rm_ref, ReturnTester)
- assert cpp_copy(fixed_r()) == 22.
- assert cpp_copy(fixed_c()) == 22.
- z = np.array([[5., 6], [7, 8]])
- assert cpp_copy(z) == 7.
- assert cpp_copy(get_cm_ref()) == 21.
- assert cpp_copy(get_rm_ref()) == 21.
- assert cpp_ref_c(get_cm_ref()) == 21.
- assert cpp_ref_r(get_rm_ref()) == 21.
- with pytest.raises(RuntimeError) as excinfo:
- # Can't reference fixed_c: it contains floats, cpp_ref_any wants doubles
- cpp_ref_any(fixed_c())
- assert 'Unable to cast Python instance' in str(excinfo.value)
- with pytest.raises(RuntimeError) as excinfo:
- # Can't reference fixed_r: it contains floats, cpp_ref_any wants doubles
- cpp_ref_any(fixed_r())
- assert 'Unable to cast Python instance' in str(excinfo.value)
- assert cpp_ref_any(ReturnTester.create()) == 1.
-
- assert cpp_ref_any(get_cm_ref()) == 21.
- assert cpp_ref_any(get_cm_ref()) == 21.
-
-
-def test_pass_readonly_array():
- from pybind11_tests import fixed_copy_r, fixed_r, fixed_r_const
- z = np.full((5, 6), 42.0)
- z.flags.writeable = False
- np.testing.assert_array_equal(z, fixed_copy_r(z))
- np.testing.assert_array_equal(fixed_r_const(), fixed_r())
- assert not fixed_r_const().flags.writeable
- np.testing.assert_array_equal(fixed_copy_r(fixed_r_const()), fixed_r_const())
-
-
-def test_nonunit_stride_from_python():
- from pybind11_tests import (
- double_row, double_col, double_complex, double_mat_cm, double_mat_rm,
- double_threec, double_threer)
-
- counting_mat = np.arange(9.0, dtype=np.float32).reshape((3, 3))
- second_row = counting_mat[1, :]
- second_col = counting_mat[:, 1]
- np.testing.assert_array_equal(double_row(second_row), 2.0 * second_row)
- np.testing.assert_array_equal(double_col(second_row), 2.0 * second_row)
- np.testing.assert_array_equal(double_complex(second_row), 2.0 * second_row)
- np.testing.assert_array_equal(double_row(second_col), 2.0 * second_col)
- np.testing.assert_array_equal(double_col(second_col), 2.0 * second_col)
- np.testing.assert_array_equal(double_complex(second_col), 2.0 * second_col)
-
- counting_3d = np.arange(27.0, dtype=np.float32).reshape((3, 3, 3))
- slices = [counting_3d[0, :, :], counting_3d[:, 0, :], counting_3d[:, :, 0]]
- for slice_idx, ref_mat in enumerate(slices):
- np.testing.assert_array_equal(double_mat_cm(ref_mat), 2.0 * ref_mat)
- np.testing.assert_array_equal(double_mat_rm(ref_mat), 2.0 * ref_mat)
-
- # Mutator:
- double_threer(second_row)
- double_threec(second_col)
- np.testing.assert_array_equal(counting_mat, [[0., 2, 2], [6, 16, 10], [6, 14, 8]])
-
-
-def test_nonunit_stride_to_python():
- from pybind11_tests import diagonal, diagonal_1, diagonal_n, block
-
- assert np.all(diagonal(ref) == ref.diagonal())
- assert np.all(diagonal_1(ref) == ref.diagonal(1))
- for i in range(-5, 7):
- assert np.all(diagonal_n(ref, i) == ref.diagonal(i)), "diagonal_n({})".format(i)
-
- assert np.all(block(ref, 2, 1, 3, 3) == ref[2:5, 1:4])
- assert np.all(block(ref, 1, 4, 4, 2) == ref[1:, 4:])
- assert np.all(block(ref, 1, 4, 3, 2) == ref[1:4, 4:])
-
-
-def test_eigen_ref_to_python():
- from pybind11_tests import cholesky1, cholesky2, cholesky3, cholesky4
-
- chols = [cholesky1, cholesky2, cholesky3, cholesky4]
- for i, chol in enumerate(chols, start=1):
- mymat = chol(np.array([[1., 2, 4], [2, 13, 23], [4, 23, 77]]))
- assert np.all(mymat == np.array([[1, 0, 0], [2, 3, 0], [4, 5, 6]])), "cholesky{}".format(i)
-
-
-def assign_both(a1, a2, r, c, v):
- a1[r, c] = v
- a2[r, c] = v
-
-
-def array_copy_but_one(a, r, c, v):
- z = np.array(a, copy=True)
- z[r, c] = v
- return z
-
-
-def test_eigen_return_references():
- """Tests various ways of returning references and non-referencing copies"""
- from pybind11_tests import ReturnTester
- master = np.ones((10, 10))
- a = ReturnTester()
- a_get1 = a.get()
- assert not a_get1.flags.owndata and a_get1.flags.writeable
- assign_both(a_get1, master, 3, 3, 5)
- a_get2 = a.get_ptr()
- assert not a_get2.flags.owndata and a_get2.flags.writeable
- assign_both(a_get1, master, 2, 3, 6)
-
- a_view1 = a.view()
- assert not a_view1.flags.owndata and not a_view1.flags.writeable
- with pytest.raises(ValueError):
- a_view1[2, 3] = 4
- a_view2 = a.view_ptr()
- assert not a_view2.flags.owndata and not a_view2.flags.writeable
- with pytest.raises(ValueError):
- a_view2[2, 3] = 4
-
- a_copy1 = a.copy_get()
- assert a_copy1.flags.owndata and a_copy1.flags.writeable
- np.testing.assert_array_equal(a_copy1, master)
- a_copy1[7, 7] = -44 # Shouldn't affect anything else
- c1want = array_copy_but_one(master, 7, 7, -44)
- a_copy2 = a.copy_view()
- assert a_copy2.flags.owndata and a_copy2.flags.writeable
- np.testing.assert_array_equal(a_copy2, master)
- a_copy2[4, 4] = -22 # Shouldn't affect anything else
- c2want = array_copy_but_one(master, 4, 4, -22)
-
- a_ref1 = a.ref()
- assert not a_ref1.flags.owndata and a_ref1.flags.writeable
- assign_both(a_ref1, master, 1, 1, 15)
- a_ref2 = a.ref_const()
- assert not a_ref2.flags.owndata and not a_ref2.flags.writeable
- with pytest.raises(ValueError):
- a_ref2[5, 5] = 33
- a_ref3 = a.ref_safe()
- assert not a_ref3.flags.owndata and a_ref3.flags.writeable
- assign_both(a_ref3, master, 0, 7, 99)
- a_ref4 = a.ref_const_safe()
- assert not a_ref4.flags.owndata and not a_ref4.flags.writeable
- with pytest.raises(ValueError):
- a_ref4[7, 0] = 987654321
-
- a_copy3 = a.copy_ref()
- assert a_copy3.flags.owndata and a_copy3.flags.writeable
- np.testing.assert_array_equal(a_copy3, master)
- a_copy3[8, 1] = 11
- c3want = array_copy_but_one(master, 8, 1, 11)
- a_copy4 = a.copy_ref_const()
- assert a_copy4.flags.owndata and a_copy4.flags.writeable
- np.testing.assert_array_equal(a_copy4, master)
- a_copy4[8, 4] = 88
- c4want = array_copy_but_one(master, 8, 4, 88)
-
- a_block1 = a.block(3, 3, 2, 2)
- assert not a_block1.flags.owndata and a_block1.flags.writeable
- a_block1[0, 0] = 55
- master[3, 3] = 55
- a_block2 = a.block_safe(2, 2, 3, 2)
- assert not a_block2.flags.owndata and a_block2.flags.writeable
- a_block2[2, 1] = -123
- master[4, 3] = -123
- a_block3 = a.block_const(6, 7, 4, 3)
- assert not a_block3.flags.owndata and not a_block3.flags.writeable
- with pytest.raises(ValueError):
- a_block3[2, 2] = -44444
-
- a_copy5 = a.copy_block(2, 2, 2, 3)
- assert a_copy5.flags.owndata and a_copy5.flags.writeable
- np.testing.assert_array_equal(a_copy5, master[2:4, 2:5])
- a_copy5[1, 1] = 777
- c5want = array_copy_but_one(master[2:4, 2:5], 1, 1, 777)
-
- a_corn1 = a.corners()
- assert not a_corn1.flags.owndata and a_corn1.flags.writeable
- a_corn1 *= 50
- a_corn1[1, 1] = 999
- master[0, 0] = 50
- master[0, 9] = 50
- master[9, 0] = 50
- master[9, 9] = 999
- a_corn2 = a.corners_const()
- assert not a_corn2.flags.owndata and not a_corn2.flags.writeable
- with pytest.raises(ValueError):
- a_corn2[1, 0] = 51
-
- # All of the changes made all the way along should be visible everywhere
- # now (except for the copies, of course)
- np.testing.assert_array_equal(a_get1, master)
- np.testing.assert_array_equal(a_get2, master)
- np.testing.assert_array_equal(a_view1, master)
- np.testing.assert_array_equal(a_view2, master)
- np.testing.assert_array_equal(a_ref1, master)
- np.testing.assert_array_equal(a_ref2, master)
- np.testing.assert_array_equal(a_ref3, master)
- np.testing.assert_array_equal(a_ref4, master)
- np.testing.assert_array_equal(a_block1, master[3:5, 3:5])
- np.testing.assert_array_equal(a_block2, master[2:5, 2:4])
- np.testing.assert_array_equal(a_block3, master[6:10, 7:10])
- np.testing.assert_array_equal(a_corn1, master[0::master.shape[0] - 1, 0::master.shape[1] - 1])
- np.testing.assert_array_equal(a_corn2, master[0::master.shape[0] - 1, 0::master.shape[1] - 1])
-
- np.testing.assert_array_equal(a_copy1, c1want)
- np.testing.assert_array_equal(a_copy2, c2want)
- np.testing.assert_array_equal(a_copy3, c3want)
- np.testing.assert_array_equal(a_copy4, c4want)
- np.testing.assert_array_equal(a_copy5, c5want)
-
-
-def assert_keeps_alive(cl, method, *args):
- from pybind11_tests import ConstructorStats
- cstats = ConstructorStats.get(cl)
- start_with = cstats.alive()
- a = cl()
- assert cstats.alive() == start_with + 1
- z = method(a, *args)
- assert cstats.alive() == start_with + 1
- del a
- # Here's the keep alive in action:
- assert cstats.alive() == start_with + 1
- del z
- # Keep alive should have expired:
- assert cstats.alive() == start_with
-
-
-def test_eigen_keepalive():
- from pybind11_tests import ReturnTester, ConstructorStats
- a = ReturnTester()
-
- cstats = ConstructorStats.get(ReturnTester)
- assert cstats.alive() == 1
- unsafe = [a.ref(), a.ref_const(), a.block(1, 2, 3, 4)]
- copies = [a.copy_get(), a.copy_view(), a.copy_ref(), a.copy_ref_const(),
- a.copy_block(4, 3, 2, 1)]
- del a
- assert cstats.alive() == 0
- del unsafe
- del copies
-
- for meth in [ReturnTester.get, ReturnTester.get_ptr, ReturnTester.view,
- ReturnTester.view_ptr, ReturnTester.ref_safe, ReturnTester.ref_const_safe,
- ReturnTester.corners, ReturnTester.corners_const]:
- assert_keeps_alive(ReturnTester, meth)
-
- for meth in [ReturnTester.block_safe, ReturnTester.block_const]:
- assert_keeps_alive(ReturnTester, meth, 4, 3, 2, 1)
-
-
-def test_eigen_ref_mutators():
- """Tests whether Eigen can mutate numpy values"""
- from pybind11_tests import add_rm, add_cm, add_any, add1, add2
- orig = np.array([[1., 2, 3], [4, 5, 6], [7, 8, 9]])
- zr = np.array(orig)
- zc = np.array(orig, order='F')
- add_rm(zr, 1, 0, 100)
- assert np.all(zr == np.array([[1., 2, 3], [104, 5, 6], [7, 8, 9]]))
- add_cm(zc, 1, 0, 200)
- assert np.all(zc == np.array([[1., 2, 3], [204, 5, 6], [7, 8, 9]]))
-
- add_any(zr, 1, 0, 20)
- assert np.all(zr == np.array([[1., 2, 3], [124, 5, 6], [7, 8, 9]]))
- add_any(zc, 1, 0, 10)
- assert np.all(zc == np.array([[1., 2, 3], [214, 5, 6], [7, 8, 9]]))
-
- # Can't reference a col-major array with a row-major Ref, and vice versa:
- with pytest.raises(TypeError):
- add_rm(zc, 1, 0, 1)
- with pytest.raises(TypeError):
- add_cm(zr, 1, 0, 1)
-
- # Overloads:
- add1(zr, 1, 0, -100)
- add2(zr, 1, 0, -20)
- assert np.all(zr == orig)
- add1(zc, 1, 0, -200)
- add2(zc, 1, 0, -10)
- assert np.all(zc == orig)
-
- # a non-contiguous slice (this won't work on either the row- or
- # column-contiguous refs, but should work for the any)
- cornersr = zr[0::2, 0::2]
- cornersc = zc[0::2, 0::2]
-
- assert np.all(cornersr == np.array([[1., 3], [7, 9]]))
- assert np.all(cornersc == np.array([[1., 3], [7, 9]]))
-
- with pytest.raises(TypeError):
- add_rm(cornersr, 0, 1, 25)
- with pytest.raises(TypeError):
- add_cm(cornersr, 0, 1, 25)
- with pytest.raises(TypeError):
- add_rm(cornersc, 0, 1, 25)
- with pytest.raises(TypeError):
- add_cm(cornersc, 0, 1, 25)
- add_any(cornersr, 0, 1, 25)
- add_any(cornersc, 0, 1, 44)
- assert np.all(zr == np.array([[1., 2, 28], [4, 5, 6], [7, 8, 9]]))
- assert np.all(zc == np.array([[1., 2, 47], [4, 5, 6], [7, 8, 9]]))
-
- # You shouldn't be allowed to pass a non-writeable array to a mutating Eigen method:
- zro = zr[0:4, 0:4]
- zro.flags.writeable = False
- with pytest.raises(TypeError):
- add_rm(zro, 0, 0, 0)
- with pytest.raises(TypeError):
- add_any(zro, 0, 0, 0)
- with pytest.raises(TypeError):
- add1(zro, 0, 0, 0)
- with pytest.raises(TypeError):
- add2(zro, 0, 0, 0)
-
- # integer array shouldn't be passable to a double-matrix-accepting mutating func:
- zi = np.array([[1, 2], [3, 4]])
- with pytest.raises(TypeError):
- add_rm(zi)
-
-
-def test_numpy_ref_mutators():
- """Tests numpy mutating Eigen matrices (for returned Eigen::Ref<...>s)"""
- from pybind11_tests import (
- get_cm_ref, get_cm_const_ref, get_rm_ref, get_rm_const_ref, reset_refs)
- reset_refs() # In case another test already changed it
-
- zc = get_cm_ref()
- zcro = get_cm_const_ref()
- zr = get_rm_ref()
- zrro = get_rm_const_ref()
-
- assert [zc[1, 2], zcro[1, 2], zr[1, 2], zrro[1, 2]] == [23] * 4
-
- assert not zc.flags.owndata and zc.flags.writeable
- assert not zr.flags.owndata and zr.flags.writeable
- assert not zcro.flags.owndata and not zcro.flags.writeable
- assert not zrro.flags.owndata and not zrro.flags.writeable
-
- zc[1, 2] = 99
- expect = np.array([[11., 12, 13], [21, 22, 99], [31, 32, 33]])
- # We should have just changed zc, of course, but also zcro and the original eigen matrix
- assert np.all(zc == expect)
- assert np.all(zcro == expect)
- assert np.all(get_cm_ref() == expect)
-
- zr[1, 2] = 99
- assert np.all(zr == expect)
- assert np.all(zrro == expect)
- assert np.all(get_rm_ref() == expect)
-
- # Make sure the readonly ones are numpy-readonly:
- with pytest.raises(ValueError):
- zcro[1, 2] = 6
- with pytest.raises(ValueError):
- zrro[1, 2] = 6
-
- # We should be able to explicitly copy like this (and since we're copying,
- # the const should drop away)
- y1 = np.array(get_cm_const_ref())
-
- assert y1.flags.owndata and y1.flags.writeable
- # We should get copies of the eigen data, which was modified above:
- assert y1[1, 2] == 99
- y1[1, 2] += 12
- assert y1[1, 2] == 111
- assert zc[1, 2] == 99 # Make sure we aren't referencing the original
-
-
-def test_both_ref_mutators():
- """Tests a complex chain of nested eigen/numpy references"""
- from pybind11_tests import (
- incr_matrix, get_cm_ref, incr_matrix_any, even_cols, even_rows, reset_refs)
- reset_refs() # In case another test already changed it
-
- z = get_cm_ref() # numpy -> eigen
- z[0, 2] -= 3
- z2 = incr_matrix(z, 1) # numpy -> eigen -> numpy -> eigen
- z2[1, 1] += 6
- z3 = incr_matrix(z, 2) # (numpy -> eigen)^3
- z3[2, 2] += -5
- z4 = incr_matrix(z, 3) # (numpy -> eigen)^4
- z4[1, 1] -= 1
- z5 = incr_matrix(z, 4) # (numpy -> eigen)^5
- z5[0, 0] = 0
- assert np.all(z == z2)
- assert np.all(z == z3)
- assert np.all(z == z4)
- assert np.all(z == z5)
- expect = np.array([[0., 22, 20], [31, 37, 33], [41, 42, 38]])
- assert np.all(z == expect)
-
- y = np.array(range(100), dtype='float64').reshape(10, 10)
- y2 = incr_matrix_any(y, 10) # np -> eigen -> np
- y3 = incr_matrix_any(y2[0::2, 0::2], -33) # np -> eigen -> np slice -> np -> eigen -> np
- y4 = even_rows(y3) # numpy -> eigen slice -> (... y3)
- y5 = even_cols(y4) # numpy -> eigen slice -> (... y4)
- y6 = incr_matrix_any(y5, 1000) # numpy -> eigen -> (... y5)
-
- # Apply same mutations using just numpy:
- yexpect = np.array(range(100), dtype='float64').reshape(10, 10)
- yexpect += 10
- yexpect[0::2, 0::2] -= 33
- yexpect[0::4, 0::4] += 1000
- assert np.all(y6 == yexpect[0::4, 0::4])
- assert np.all(y5 == yexpect[0::4, 0::4])
- assert np.all(y4 == yexpect[0::4, 0::2])
- assert np.all(y3 == yexpect[0::2, 0::2])
- assert np.all(y2 == yexpect)
- assert np.all(y == yexpect)
-
-
-def test_nocopy_wrapper():
- from pybind11_tests import get_elem, get_elem_nocopy, get_elem_rm_nocopy
- # get_elem requires a column-contiguous matrix reference, but should be
- # callable with other types of matrix (via copying):
- int_matrix_colmajor = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]], order='F')
- dbl_matrix_colmajor = np.array(int_matrix_colmajor, dtype='double', order='F', copy=True)
- int_matrix_rowmajor = np.array(int_matrix_colmajor, order='C', copy=True)
- dbl_matrix_rowmajor = np.array(int_matrix_rowmajor, dtype='double', order='C', copy=True)
-
- # All should be callable via get_elem:
- assert get_elem(int_matrix_colmajor) == 8
- assert get_elem(dbl_matrix_colmajor) == 8
- assert get_elem(int_matrix_rowmajor) == 8
- assert get_elem(dbl_matrix_rowmajor) == 8
-
- # All but the second should fail with get_elem_nocopy:
- with pytest.raises(TypeError) as excinfo:
- get_elem_nocopy(int_matrix_colmajor)
- assert ('get_elem_nocopy(): incompatible function arguments.' in str(excinfo.value) and
- ', flags.f_contiguous' in str(excinfo.value))
- assert get_elem_nocopy(dbl_matrix_colmajor) == 8
- with pytest.raises(TypeError) as excinfo:
- get_elem_nocopy(int_matrix_rowmajor)
- assert ('get_elem_nocopy(): incompatible function arguments.' in str(excinfo.value) and
- ', flags.f_contiguous' in str(excinfo.value))
- with pytest.raises(TypeError) as excinfo:
- get_elem_nocopy(dbl_matrix_rowmajor)
- assert ('get_elem_nocopy(): incompatible function arguments.' in str(excinfo.value) and
- ', flags.f_contiguous' in str(excinfo.value))
-
- # For the row-major test, we take a long matrix in row-major, so only the third is allowed:
- with pytest.raises(TypeError) as excinfo:
- get_elem_rm_nocopy(int_matrix_colmajor)
- assert ('get_elem_rm_nocopy(): incompatible function arguments.' in str(excinfo.value) and
- ', flags.c_contiguous' in str(excinfo.value))
- with pytest.raises(TypeError) as excinfo:
- get_elem_rm_nocopy(dbl_matrix_colmajor)
- assert ('get_elem_rm_nocopy(): incompatible function arguments.' in str(excinfo.value) and
- ', flags.c_contiguous' in str(excinfo.value))
- assert get_elem_rm_nocopy(int_matrix_rowmajor) == 8
- with pytest.raises(TypeError) as excinfo:
- get_elem_rm_nocopy(dbl_matrix_rowmajor)
- assert ('get_elem_rm_nocopy(): incompatible function arguments.' in str(excinfo.value) and
- ', flags.c_contiguous' in str(excinfo.value))
-
-
-def test_special_matrix_objects():
- from pybind11_tests import incr_diag, symmetric_upper, symmetric_lower
-
- assert np.all(incr_diag(7) == np.diag([1., 2, 3, 4, 5, 6, 7]))
-
- asymm = np.array([[ 1., 2, 3, 4],
- [ 5, 6, 7, 8],
- [ 9, 10, 11, 12],
- [13, 14, 15, 16]])
- symm_lower = np.array(asymm)
- symm_upper = np.array(asymm)
- for i in range(4):
- for j in range(i + 1, 4):
- symm_lower[i, j] = symm_lower[j, i]
- symm_upper[j, i] = symm_upper[i, j]
-
- assert np.all(symmetric_lower(asymm) == symm_lower)
- assert np.all(symmetric_upper(asymm) == symm_upper)
-
-
-def test_dense_signature(doc):
- from pybind11_tests import double_col, double_row, double_complex, double_mat_rm
-
- assert doc(double_col) == """
- double_col(arg0: numpy.ndarray[float32[m, 1]]) -> numpy.ndarray[float32[m, 1]]
- """
- assert doc(double_row) == """
- double_row(arg0: numpy.ndarray[float32[1, n]]) -> numpy.ndarray[float32[1, n]]
- """
- assert doc(double_complex) == """
- double_complex(arg0: numpy.ndarray[complex64[m, 1]]) -> numpy.ndarray[complex64[m, 1]]
- """
- assert doc(double_mat_rm) == """
- double_mat_rm(arg0: numpy.ndarray[float32[m, n]]) -> numpy.ndarray[float32[m, n]]
- """
-
-
-@pytest.requires_eigen_and_scipy
-def test_sparse():
- from pybind11_tests import sparse_r, sparse_c, sparse_copy_r, sparse_copy_c
-
- assert_sparse_equal_ref(sparse_r())
- assert_sparse_equal_ref(sparse_c())
- assert_sparse_equal_ref(sparse_copy_r(sparse_r()))
- assert_sparse_equal_ref(sparse_copy_c(sparse_c()))
- assert_sparse_equal_ref(sparse_copy_r(sparse_c()))
- assert_sparse_equal_ref(sparse_copy_c(sparse_r()))
-
-
-@pytest.requires_eigen_and_scipy
-def test_sparse_signature(doc):
- from pybind11_tests import sparse_copy_r, sparse_copy_c
-
- assert doc(sparse_copy_r) == """
- sparse_copy_r(arg0: scipy.sparse.csr_matrix[float32]) -> scipy.sparse.csr_matrix[float32]
- """ # noqa: E501 line too long
- assert doc(sparse_copy_c) == """
- sparse_copy_c(arg0: scipy.sparse.csc_matrix[float32]) -> scipy.sparse.csc_matrix[float32]
- """ # noqa: E501 line too long
-
-
-def test_issue738():
- from pybind11_tests import iss738_f1, iss738_f2
-
- assert np.all(iss738_f1(np.array([[1., 2, 3]])) == np.array([[1., 102, 203]]))
- assert np.all(iss738_f1(np.array([[1.], [2], [3]])) == np.array([[1.], [12], [23]]))
-
- assert np.all(iss738_f2(np.array([[1., 2, 3]])) == np.array([[1., 102, 203]]))
- assert np.all(iss738_f2(np.array([[1.], [2], [3]])) == np.array([[1.], [12], [23]]))
-
-
-def test_custom_operator_new():
- """Using Eigen types as member variables requires a class-specific
- operator new with proper alignment"""
- from pybind11_tests import CustomOperatorNew
-
- o = CustomOperatorNew()
- np.testing.assert_allclose(o.a, 0.0)
- np.testing.assert_allclose(o.b.diagonal(), 1.0)
diff --git a/thirdparty/pybind11/pybind11/tests/test_enum.cpp b/thirdparty/pybind11/pybind11/tests/test_enum.cpp
deleted file mode 100644
index 09f334cdb2c72dc152bcfd4f740857087025608f..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_enum.cpp
+++ /dev/null
@@ -1,68 +0,0 @@
-/*
- tests/test_enums.cpp -- enumerations
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-enum UnscopedEnum {
- EOne = 1,
- ETwo
-};
-
-enum class ScopedEnum {
- Two = 2,
- Three
-};
-
-enum Flags {
- Read = 4,
- Write = 2,
- Execute = 1
-};
-
-class ClassWithUnscopedEnum {
-public:
- enum EMode {
- EFirstMode = 1,
- ESecondMode
- };
-
- static EMode test_function(EMode mode) {
- return mode;
- }
-};
-
-std::string test_scoped_enum(ScopedEnum z) {
- return "ScopedEnum::" + std::string(z == ScopedEnum::Two ? "Two" : "Three");
-}
-
-test_initializer enums([](py::module &m) {
- m.def("test_scoped_enum", &test_scoped_enum);
-
- py::enum_<UnscopedEnum>(m, "UnscopedEnum", py::arithmetic())
- .value("EOne", EOne)
- .value("ETwo", ETwo)
- .export_values();
-
- py::enum_<ScopedEnum>(m, "ScopedEnum", py::arithmetic())
- .value("Two", ScopedEnum::Two)
- .value("Three", ScopedEnum::Three);
-
- py::enum_<Flags>(m, "Flags", py::arithmetic())
- .value("Read", Flags::Read)
- .value("Write", Flags::Write)
- .value("Execute", Flags::Execute)
- .export_values();
-
- py::class_<ClassWithUnscopedEnum> exenum_class(m, "ClassWithUnscopedEnum");
- exenum_class.def_static("test_function", &ClassWithUnscopedEnum::test_function);
- py::enum_<ClassWithUnscopedEnum::EMode>(exenum_class, "EMode")
- .value("EFirstMode", ClassWithUnscopedEnum::EFirstMode)
- .value("ESecondMode", ClassWithUnscopedEnum::ESecondMode)
- .export_values();
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_enum.py b/thirdparty/pybind11/pybind11/tests/test_enum.py
deleted file mode 100644
index ba7e22ab0c6e13faa503fbba918afeebed329e7d..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_enum.py
+++ /dev/null
@@ -1,117 +0,0 @@
-import pytest
-
-
-def test_unscoped_enum():
- from pybind11_tests import UnscopedEnum, EOne
-
- assert str(UnscopedEnum.EOne) == "UnscopedEnum.EOne"
- assert str(UnscopedEnum.ETwo) == "UnscopedEnum.ETwo"
- assert str(EOne) == "UnscopedEnum.EOne"
- # __members__ property
- assert UnscopedEnum.__members__ == {"EOne": UnscopedEnum.EOne, "ETwo": UnscopedEnum.ETwo}
- # __members__ readonly
- with pytest.raises(AttributeError):
- UnscopedEnum.__members__ = {}
- # __members__ returns a copy
- foo = UnscopedEnum.__members__
- foo["bar"] = "baz"
- assert UnscopedEnum.__members__ == {"EOne": UnscopedEnum.EOne, "ETwo": UnscopedEnum.ETwo}
-
- # no TypeError exception for unscoped enum ==/!= int comparisons
- y = UnscopedEnum.ETwo
- assert y == 2
- assert y != 3
-
- assert int(UnscopedEnum.ETwo) == 2
- assert str(UnscopedEnum(2)) == "UnscopedEnum.ETwo"
-
- # order
- assert UnscopedEnum.EOne < UnscopedEnum.ETwo
- assert UnscopedEnum.EOne < 2
- assert UnscopedEnum.ETwo > UnscopedEnum.EOne
- assert UnscopedEnum.ETwo > 1
- assert UnscopedEnum.ETwo <= 2
- assert UnscopedEnum.ETwo >= 2
- assert UnscopedEnum.EOne <= UnscopedEnum.ETwo
- assert UnscopedEnum.EOne <= 2
- assert UnscopedEnum.ETwo >= UnscopedEnum.EOne
- assert UnscopedEnum.ETwo >= 1
- assert not (UnscopedEnum.ETwo < UnscopedEnum.EOne)
- assert not (2 < UnscopedEnum.EOne)
-
-
-def test_scoped_enum():
- from pybind11_tests import ScopedEnum, test_scoped_enum
-
- assert test_scoped_enum(ScopedEnum.Three) == "ScopedEnum::Three"
- z = ScopedEnum.Two
- assert test_scoped_enum(z) == "ScopedEnum::Two"
-
- # expected TypeError exceptions for scoped enum ==/!= int comparisons
- with pytest.raises(TypeError):
- assert z == 2
- with pytest.raises(TypeError):
- assert z != 3
-
- # order
- assert ScopedEnum.Two < ScopedEnum.Three
- assert ScopedEnum.Three > ScopedEnum.Two
- assert ScopedEnum.Two <= ScopedEnum.Three
- assert ScopedEnum.Two <= ScopedEnum.Two
- assert ScopedEnum.Two >= ScopedEnum.Two
- assert ScopedEnum.Three >= ScopedEnum.Two
-
-
-def test_implicit_conversion():
- from pybind11_tests import ClassWithUnscopedEnum
-
- assert str(ClassWithUnscopedEnum.EMode.EFirstMode) == "EMode.EFirstMode"
- assert str(ClassWithUnscopedEnum.EFirstMode) == "EMode.EFirstMode"
-
- f = ClassWithUnscopedEnum.test_function
- first = ClassWithUnscopedEnum.EFirstMode
- second = ClassWithUnscopedEnum.ESecondMode
-
- assert f(first) == 1
-
- assert f(first) == f(first)
- assert not f(first) != f(first)
-
- assert f(first) != f(second)
- assert not f(first) == f(second)
-
- assert f(first) == int(f(first))
- assert not f(first) != int(f(first))
-
- assert f(first) != int(f(second))
- assert not f(first) == int(f(second))
-
- # noinspection PyDictCreation
- x = {f(first): 1, f(second): 2}
- x[f(first)] = 3
- x[f(second)] = 4
- # Hashing test
- assert str(x) == "{EMode.EFirstMode: 3, EMode.ESecondMode: 4}"
-
-
-def test_binary_operators():
- from pybind11_tests import Flags
-
- assert int(Flags.Read) == 4
- assert int(Flags.Write) == 2
- assert int(Flags.Execute) == 1
- assert int(Flags.Read | Flags.Write | Flags.Execute) == 7
- assert int(Flags.Read | Flags.Write) == 6
- assert int(Flags.Read | Flags.Execute) == 5
- assert int(Flags.Write | Flags.Execute) == 3
- assert int(Flags.Write | 1) == 3
-
- state = Flags.Read | Flags.Write
- assert (state & Flags.Read) != 0
- assert (state & Flags.Write) != 0
- assert (state & Flags.Execute) == 0
- assert (state & 1) == 0
-
- state2 = ~state
- assert state2 == -7
- assert int(state ^ state2) == -1
diff --git a/thirdparty/pybind11/pybind11/tests/test_eval.cpp b/thirdparty/pybind11/pybind11/tests/test_eval.cpp
deleted file mode 100644
index ed4c226fe4f54c1a9d53a14d6216cde8e9ed21bb..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_eval.cpp
+++ /dev/null
@@ -1,79 +0,0 @@
-/*
- tests/test_eval.cpp -- Usage of eval() and eval_file()
-
- Copyright (c) 2016 Klemens D. Morgenstern
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-
-#include <pybind11/eval.h>
-#include "pybind11_tests.h"
-
-test_initializer eval([](py::module &m) {
- auto global = py::dict(py::module::import("__main__").attr("__dict__"));
-
- m.def("test_eval_statements", [global]() {
- auto local = py::dict();
- local["call_test"] = py::cpp_function([&]() -> int {
- return 42;
- });
-
- auto result = py::eval<py::eval_statements>(
- "print('Hello World!');\n"
- "x = call_test();",
- global, local
- );
- auto x = local["x"].cast<int>();
-
- return result == py::none() && x == 42;
- });
-
- m.def("test_eval", [global]() {
- auto local = py::dict();
- local["x"] = py::int_(42);
- auto x = py::eval("x", global, local);
- return x.cast<int>() == 42;
- });
-
- m.def("test_eval_single_statement", []() {
- auto local = py::dict();
- local["call_test"] = py::cpp_function([&]() -> int {
- return 42;
- });
-
- auto result = py::eval<py::eval_single_statement>("x = call_test()", py::dict(), local);
- auto x = local["x"].cast<int>();
- return result == py::none() && x == 42;
- });
-
- m.def("test_eval_file", [global](py::str filename) {
- auto local = py::dict();
- local["y"] = py::int_(43);
-
- int val_out;
- local["call_test2"] = py::cpp_function([&](int value) { val_out = value; });
-
- auto result = py::eval_file(filename, global, local);
- return val_out == 43 && result == py::none();
- });
-
- m.def("test_eval_failure", []() {
- try {
- py::eval("nonsense code ...");
- } catch (py::error_already_set &) {
- return true;
- }
- return false;
- });
-
- m.def("test_eval_file_failure", []() {
- try {
- py::eval_file("non-existing file");
- } catch (std::exception &) {
- return true;
- }
- return false;
- });
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_eval.py b/thirdparty/pybind11/pybind11/tests/test_eval.py
deleted file mode 100644
index 8715dbadb8c5c26f9dcb69e922e247bfcf5f520f..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_eval.py
+++ /dev/null
@@ -1,19 +0,0 @@
-import os
-
-
-def test_evals(capture):
- from pybind11_tests import (test_eval_statements, test_eval, test_eval_single_statement,
- test_eval_file, test_eval_failure, test_eval_file_failure)
-
- with capture:
- assert test_eval_statements()
- assert capture == "Hello World!"
-
- assert test_eval()
- assert test_eval_single_statement()
-
- filename = os.path.join(os.path.dirname(__file__), "test_eval_call.py")
- assert test_eval_file(filename)
-
- assert test_eval_failure()
- assert test_eval_file_failure()
diff --git a/thirdparty/pybind11/pybind11/tests/test_eval_call.py b/thirdparty/pybind11/pybind11/tests/test_eval_call.py
deleted file mode 100644
index 53c7e721fec9490a208be8deafed5e4c27363425..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_eval_call.py
+++ /dev/null
@@ -1,4 +0,0 @@
-# This file is called from 'test_eval.py'
-
-if 'call_test2' in locals():
- call_test2(y) # noqa: F821 undefined name
diff --git a/thirdparty/pybind11/pybind11/tests/test_exceptions.cpp b/thirdparty/pybind11/pybind11/tests/test_exceptions.cpp
deleted file mode 100644
index 706b500f231b71aef29811b7b405ec94e88736a3..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_exceptions.cpp
+++ /dev/null
@@ -1,173 +0,0 @@
-/*
- tests/test_custom-exceptions.cpp -- exception translation
-
- Copyright (c) 2016 Pim Schellart <P.Schellart@princeton.edu>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-// A type that should be raised as an exeption in Python
-class MyException : public std::exception {
-public:
- explicit MyException(const char * m) : message{m} {}
- virtual const char * what() const noexcept override {return message.c_str();}
-private:
- std::string message = "";
-};
-
-// A type that should be translated to a standard Python exception
-class MyException2 : public std::exception {
-public:
- explicit MyException2(const char * m) : message{m} {}
- virtual const char * what() const noexcept override {return message.c_str();}
-private:
- std::string message = "";
-};
-
-// A type that is not derived from std::exception (and is thus unknown)
-class MyException3 {
-public:
- explicit MyException3(const char * m) : message{m} {}
- virtual const char * what() const noexcept {return message.c_str();}
-private:
- std::string message = "";
-};
-
-// A type that should be translated to MyException
-// and delegated to its exception translator
-class MyException4 : public std::exception {
-public:
- explicit MyException4(const char * m) : message{m} {}
- virtual const char * what() const noexcept override {return message.c_str();}
-private:
- std::string message = "";
-};
-
-
-// Like the above, but declared via the helper function
-class MyException5 : public std::logic_error {
-public:
- explicit MyException5(const std::string &what) : std::logic_error(what) {}
-};
-
-// Inherits from MyException5
-class MyException5_1 : public MyException5 {
- using MyException5::MyException5;
-};
-
-void throws1() {
- throw MyException("this error should go to a custom type");
-}
-
-void throws2() {
- throw MyException2("this error should go to a standard Python exception");
-}
-
-void throws3() {
- throw MyException3("this error cannot be translated");
-}
-
-void throws4() {
- throw MyException4("this error is rethrown");
-}
-
-void throws5() {
- throw MyException5("this is a helper-defined translated exception");
-}
-
-void throws5_1() {
- throw MyException5_1("MyException5 subclass");
-}
-
-void throws_logic_error() {
- throw std::logic_error("this error should fall through to the standard handler");
-}
-
-struct PythonCallInDestructor {
- PythonCallInDestructor(const py::dict &d) : d(d) {}
- ~PythonCallInDestructor() { d["good"] = true; }
-
- py::dict d;
-};
-
-test_initializer custom_exceptions([](py::module &m) {
- // make a new custom exception and use it as a translation target
- static py::exception<MyException> ex(m, "MyException");
- py::register_exception_translator([](std::exception_ptr p) {
- try {
- if (p) std::rethrow_exception(p);
- } catch (const MyException &e) {
- // Set MyException as the active python error
- ex(e.what());
- }
- });
-
- // register new translator for MyException2
- // no need to store anything here because this type will
- // never by visible from Python
- py::register_exception_translator([](std::exception_ptr p) {
- try {
- if (p) std::rethrow_exception(p);
- } catch (const MyException2 &e) {
- // Translate this exception to a standard RuntimeError
- PyErr_SetString(PyExc_RuntimeError, e.what());
- }
- });
-
- // register new translator for MyException4
- // which will catch it and delegate to the previously registered
- // translator for MyException by throwing a new exception
- py::register_exception_translator([](std::exception_ptr p) {
- try {
- if (p) std::rethrow_exception(p);
- } catch (const MyException4 &e) {
- throw MyException(e.what());
- }
- });
-
- // A simple exception translation:
- auto ex5 = py::register_exception<MyException5>(m, "MyException5");
- // A slightly more complicated one that declares MyException5_1 as a subclass of MyException5
- py::register_exception<MyException5_1>(m, "MyException5_1", ex5.ptr());
-
- m.def("throws1", &throws1);
- m.def("throws2", &throws2);
- m.def("throws3", &throws3);
- m.def("throws4", &throws4);
- m.def("throws5", &throws5);
- m.def("throws5_1", &throws5_1);
- m.def("throws_logic_error", &throws_logic_error);
-
- m.def("throw_already_set", [](bool err) {
- if (err)
- PyErr_SetString(PyExc_ValueError, "foo");
- try {
- throw py::error_already_set();
- } catch (const std::runtime_error& e) {
- if ((err && e.what() != std::string("ValueError: foo")) ||
- (!err && e.what() != std::string("Unknown internal error occurred")))
- {
- PyErr_Clear();
- throw std::runtime_error("error message mismatch");
- }
- }
- PyErr_Clear();
- if (err)
- PyErr_SetString(PyExc_ValueError, "foo");
- throw py::error_already_set();
- });
-
- m.def("python_call_in_destructor", [](py::dict d) {
- try {
- PythonCallInDestructor set_dict_in_destructor(d);
- PyErr_SetString(PyExc_ValueError, "foo");
- throw py::error_already_set();
- } catch (const py::error_already_set&) {
- return true;
- }
- return false;
- });
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_exceptions.py b/thirdparty/pybind11/pybind11/tests/test_exceptions.py
deleted file mode 100644
index 0025e4eb69a11b458902c99d878f6d31a43c9162..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_exceptions.py
+++ /dev/null
@@ -1,74 +0,0 @@
-import pytest
-
-
-def test_error_already_set(msg):
- from pybind11_tests import throw_already_set
-
- with pytest.raises(RuntimeError) as excinfo:
- throw_already_set(False)
- assert msg(excinfo.value) == "Unknown internal error occurred"
-
- with pytest.raises(ValueError) as excinfo:
- throw_already_set(True)
- assert msg(excinfo.value) == "foo"
-
-
-def test_python_call_in_catch():
- from pybind11_tests import python_call_in_destructor
-
- d = {}
- assert python_call_in_destructor(d) is True
- assert d["good"] is True
-
-
-def test_custom(msg):
- from pybind11_tests import (MyException, MyException5, MyException5_1,
- throws1, throws2, throws3, throws4, throws5, throws5_1,
- throws_logic_error)
-
- # Can we catch a MyException?"
- with pytest.raises(MyException) as excinfo:
- throws1()
- assert msg(excinfo.value) == "this error should go to a custom type"
-
- # Can we translate to standard Python exceptions?
- with pytest.raises(RuntimeError) as excinfo:
- throws2()
- assert msg(excinfo.value) == "this error should go to a standard Python exception"
-
- # Can we handle unknown exceptions?
- with pytest.raises(RuntimeError) as excinfo:
- throws3()
- assert msg(excinfo.value) == "Caught an unknown exception!"
-
- # Can we delegate to another handler by rethrowing?
- with pytest.raises(MyException) as excinfo:
- throws4()
- assert msg(excinfo.value) == "this error is rethrown"
-
- # "Can we fall-through to the default handler?"
- with pytest.raises(RuntimeError) as excinfo:
- throws_logic_error()
- assert msg(excinfo.value) == "this error should fall through to the standard handler"
-
- # Can we handle a helper-declared exception?
- with pytest.raises(MyException5) as excinfo:
- throws5()
- assert msg(excinfo.value) == "this is a helper-defined translated exception"
-
- # Exception subclassing:
- with pytest.raises(MyException5) as excinfo:
- throws5_1()
- assert msg(excinfo.value) == "MyException5 subclass"
- assert isinstance(excinfo.value, MyException5_1)
-
- with pytest.raises(MyException5_1) as excinfo:
- throws5_1()
- assert msg(excinfo.value) == "MyException5 subclass"
-
- with pytest.raises(MyException5) as excinfo:
- try:
- throws5()
- except MyException5_1:
- raise RuntimeError("Exception error: caught child from parent")
- assert msg(excinfo.value) == "this is a helper-defined translated exception"
diff --git a/thirdparty/pybind11/pybind11/tests/test_inheritance.cpp b/thirdparty/pybind11/pybind11/tests/test_inheritance.cpp
deleted file mode 100644
index c19f58dc2eed5be23fc1522dd89df6e779303ee7..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_inheritance.cpp
+++ /dev/null
@@ -1,123 +0,0 @@
-/*
- tests/test_inheritance.cpp -- inheritance, automatic upcasting for polymorphic types
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-class Pet {
-public:
- Pet(const std::string &name, const std::string &species)
- : m_name(name), m_species(species) {}
- std::string name() const { return m_name; }
- std::string species() const { return m_species; }
-private:
- std::string m_name;
- std::string m_species;
-};
-
-class Dog : public Pet {
-public:
- Dog(const std::string &name) : Pet(name, "dog") {}
- std::string bark() const { return "Woof!"; }
-};
-
-class Rabbit : public Pet {
-public:
- Rabbit(const std::string &name) : Pet(name, "parrot") {}
-};
-
-class Hamster : public Pet {
-public:
- Hamster(const std::string &name) : Pet(name, "rodent") {}
-};
-
-class Chimera : public Pet {
- Chimera() : Pet("Kimmy", "chimera") {}
-};
-
-std::string pet_name_species(const Pet &pet) {
- return pet.name() + " is a " + pet.species();
-}
-
-std::string dog_bark(const Dog &dog) {
- return dog.bark();
-}
-
-
-struct BaseClass { virtual ~BaseClass() {} };
-struct DerivedClass1 : BaseClass { };
-struct DerivedClass2 : BaseClass { };
-
-struct MismatchBase1 { };
-struct MismatchDerived1 : MismatchBase1 { };
-
-struct MismatchBase2 { };
-struct MismatchDerived2 : MismatchBase2 { };
-
-test_initializer inheritance([](py::module &m) {
- py::class_<Pet> pet_class(m, "Pet");
- pet_class
- .def(py::init<std::string, std::string>())
- .def("name", &Pet::name)
- .def("species", &Pet::species);
-
- /* One way of declaring a subclass relationship: reference parent's class_ object */
- py::class_<Dog>(m, "Dog", pet_class)
- .def(py::init<std::string>());
-
- /* Another way of declaring a subclass relationship: reference parent's C++ type */
- py::class_<Rabbit, Pet>(m, "Rabbit")
- .def(py::init<std::string>());
-
- /* And another: list parent in class template arguments */
- py::class_<Hamster, Pet>(m, "Hamster")
- .def(py::init<std::string>());
-
- py::class_<Chimera, Pet>(m, "Chimera");
-
- m.def("pet_name_species", pet_name_species);
- m.def("dog_bark", dog_bark);
-
- py::class_<BaseClass>(m, "BaseClass").def(py::init<>());
- py::class_<DerivedClass1>(m, "DerivedClass1").def(py::init<>());
- py::class_<DerivedClass2>(m, "DerivedClass2").def(py::init<>());
-
- m.def("return_class_1", []() -> BaseClass* { return new DerivedClass1(); });
- m.def("return_class_2", []() -> BaseClass* { return new DerivedClass2(); });
- m.def("return_class_n", [](int n) -> BaseClass* {
- if (n == 1) return new DerivedClass1();
- if (n == 2) return new DerivedClass2();
- return new BaseClass();
- });
- m.def("return_none", []() -> BaseClass* { return nullptr; });
-
- m.def("test_isinstance", [](py::list l) {
- struct Unregistered { }; // checks missing type_info code path
-
- return py::make_tuple(
- py::isinstance<py::tuple>(l[0]),
- py::isinstance<py::dict>(l[1]),
- py::isinstance<Pet>(l[2]),
- py::isinstance<Pet>(l[3]),
- py::isinstance<Dog>(l[4]),
- py::isinstance<Rabbit>(l[5]),
- py::isinstance<Unregistered>(l[6])
- );
- });
-
- m.def("test_mismatched_holder_type_1", []() {
- auto m = py::module::import("__main__");
- py::class_<MismatchBase1, std::shared_ptr<MismatchBase1>>(m, "MismatchBase1");
- py::class_<MismatchDerived1, MismatchBase1>(m, "MismatchDerived1");
- });
- m.def("test_mismatched_holder_type_2", []() {
- auto m = py::module::import("__main__");
- py::class_<MismatchBase2>(m, "MismatchBase2");
- py::class_<MismatchDerived2, std::shared_ptr<MismatchDerived2>, MismatchBase2>(m, "MismatchDerived2");
- });
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_inheritance.py b/thirdparty/pybind11/pybind11/tests/test_inheritance.py
deleted file mode 100644
index d1f537d1d65cb821c960175f199164740f1d1686..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_inheritance.py
+++ /dev/null
@@ -1,78 +0,0 @@
-import pytest
-
-
-def test_inheritance(msg):
- from pybind11_tests import Pet, Dog, Rabbit, Hamster, Chimera, dog_bark, pet_name_species
-
- roger = Rabbit('Rabbit')
- assert roger.name() + " is a " + roger.species() == "Rabbit is a parrot"
- assert pet_name_species(roger) == "Rabbit is a parrot"
-
- polly = Pet('Polly', 'parrot')
- assert polly.name() + " is a " + polly.species() == "Polly is a parrot"
- assert pet_name_species(polly) == "Polly is a parrot"
-
- molly = Dog('Molly')
- assert molly.name() + " is a " + molly.species() == "Molly is a dog"
- assert pet_name_species(molly) == "Molly is a dog"
-
- fred = Hamster('Fred')
- assert fred.name() + " is a " + fred.species() == "Fred is a rodent"
-
- assert dog_bark(molly) == "Woof!"
-
- with pytest.raises(TypeError) as excinfo:
- dog_bark(polly)
- assert msg(excinfo.value) == """
- dog_bark(): incompatible function arguments. The following argument types are supported:
- 1. (arg0: m.Dog) -> str
-
- Invoked with: <m.Pet object at 0>
- """
-
- with pytest.raises(TypeError) as excinfo:
- Chimera("lion", "goat")
- assert "No constructor defined!" in str(excinfo.value)
-
-
-def test_automatic_upcasting():
- from pybind11_tests import return_class_1, return_class_2, return_class_n, return_none
-
- assert type(return_class_1()).__name__ == "DerivedClass1"
- assert type(return_class_2()).__name__ == "DerivedClass2"
- assert type(return_none()).__name__ == "NoneType"
- # Repeat these a few times in a random order to ensure no invalid caching
- # is applied
- assert type(return_class_n(1)).__name__ == "DerivedClass1"
- assert type(return_class_n(2)).__name__ == "DerivedClass2"
- assert type(return_class_n(0)).__name__ == "BaseClass"
- assert type(return_class_n(2)).__name__ == "DerivedClass2"
- assert type(return_class_n(2)).__name__ == "DerivedClass2"
- assert type(return_class_n(0)).__name__ == "BaseClass"
- assert type(return_class_n(1)).__name__ == "DerivedClass1"
-
-
-def test_isinstance():
- from pybind11_tests import test_isinstance, Pet, Dog
-
- objects = [tuple(), dict(), Pet("Polly", "parrot")] + [Dog("Molly")] * 4
- expected = (True, True, True, True, True, False, False)
- assert test_isinstance(objects) == expected
-
-
-def test_holder():
- from pybind11_tests import test_mismatched_holder_type_1, test_mismatched_holder_type_2
-
- with pytest.raises(RuntimeError) as excinfo:
- test_mismatched_holder_type_1()
-
- assert str(excinfo.value) == ("generic_type: type \"MismatchDerived1\" does not have "
- "a non-default holder type while its base "
- "\"MismatchBase1\" does")
-
- with pytest.raises(RuntimeError) as excinfo:
- test_mismatched_holder_type_2()
-
- assert str(excinfo.value) == ("generic_type: type \"MismatchDerived2\" has a "
- "non-default holder type while its base "
- "\"MismatchBase2\" does not")
diff --git a/thirdparty/pybind11/pybind11/tests/test_issues.cpp b/thirdparty/pybind11/pybind11/tests/test_issues.cpp
deleted file mode 100644
index 7da37004564f83d674aaf39e42f4206ede120bbe..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_issues.cpp
+++ /dev/null
@@ -1,400 +0,0 @@
-/*
- tests/test_issues.cpp -- collection of testcases for miscellaneous issues
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include "constructor_stats.h"
-#include <pybind11/stl.h>
-#include <pybind11/operators.h>
-#include <pybind11/complex.h>
-
-#define TRACKERS(CLASS) CLASS() { print_default_created(this); } ~CLASS() { print_destroyed(this); }
-struct NestABase { int value = -2; TRACKERS(NestABase) };
-struct NestA : NestABase { int value = 3; NestA& operator+=(int i) { value += i; return *this; } TRACKERS(NestA) };
-struct NestB { NestA a; int value = 4; NestB& operator-=(int i) { value -= i; return *this; } TRACKERS(NestB) };
-struct NestC { NestB b; int value = 5; NestC& operator*=(int i) { value *= i; return *this; } TRACKERS(NestC) };
-
-/// #393
-class OpTest1 {};
-class OpTest2 {};
-
-OpTest1 operator+(const OpTest1 &, const OpTest1 &) {
- py::print("Add OpTest1 with OpTest1");
- return OpTest1();
-}
-OpTest2 operator+(const OpTest2 &, const OpTest2 &) {
- py::print("Add OpTest2 with OpTest2");
- return OpTest2();
-}
-OpTest2 operator+(const OpTest2 &, const OpTest1 &) {
- py::print("Add OpTest2 with OpTest1");
- return OpTest2();
-}
-
-// #461
-class Dupe1 {
-public:
- Dupe1(int v) : v_{v} {}
- int get_value() const { return v_; }
-private:
- int v_;
-};
-class Dupe2 {};
-class Dupe3 {};
-class DupeException : public std::runtime_error {};
-
-// #478
-template <typename T> class custom_unique_ptr {
-public:
- custom_unique_ptr() { print_default_created(this); }
- custom_unique_ptr(T *ptr) : _ptr{ptr} { print_created(this, ptr); }
- custom_unique_ptr(custom_unique_ptr<T> &&move) : _ptr{move._ptr} { move._ptr = nullptr; print_move_created(this); }
- custom_unique_ptr &operator=(custom_unique_ptr<T> &&move) { print_move_assigned(this); if (_ptr) destruct_ptr(); _ptr = move._ptr; move._ptr = nullptr; return *this; }
- custom_unique_ptr(const custom_unique_ptr<T> &) = delete;
- void operator=(const custom_unique_ptr<T> ©) = delete;
- ~custom_unique_ptr() { print_destroyed(this); if (_ptr) destruct_ptr(); }
-private:
- T *_ptr = nullptr;
- void destruct_ptr() { delete _ptr; }
-};
-PYBIND11_DECLARE_HOLDER_TYPE(T, custom_unique_ptr<T>);
-
-/// Issue #528: templated constructor
-struct TplConstrClass {
- template <typename T> TplConstrClass(const T &arg) : str{arg} {}
- std::string str;
- bool operator==(const TplConstrClass &t) const { return t.str == str; }
-};
-namespace std {
-template <> struct hash<TplConstrClass> { size_t operator()(const TplConstrClass &t) const { return std::hash<std::string>()(t.str); } };
-}
-
-void init_issues(py::module &m) {
- py::module m2 = m.def_submodule("issues");
-
-#if !defined(_MSC_VER)
- // Visual Studio 2015 currently cannot compile this test
- // (see the comment in type_caster_base::make_copy_constructor)
- // #70 compilation issue if operator new is not public
- class NonConstructible { private: void *operator new(size_t bytes) throw(); };
- py::class_<NonConstructible>(m, "Foo");
- m2.def("getstmt", []() -> NonConstructible * { return nullptr; },
- py::return_value_policy::reference);
-#endif
-
- // #137: const char* isn't handled properly
- m2.def("print_cchar", [](const char *s) { return std::string(s); });
-
- // #150: char bindings broken
- m2.def("print_char", [](char c) { return std::string(1, c); });
-
- // #159: virtual function dispatch has problems with similar-named functions
- struct Base { virtual std::string dispatch() const {
- /* for some reason MSVC2015 can't compile this if the function is pure virtual */
- return {};
- }; };
-
- struct DispatchIssue : Base {
- virtual std::string dispatch() const {
- PYBIND11_OVERLOAD_PURE(std::string, Base, dispatch, /* no arguments */);
- }
- };
-
- py::class_<Base, DispatchIssue>(m2, "DispatchIssue")
- .def(py::init<>())
- .def("dispatch", &Base::dispatch);
-
- m2.def("dispatch_issue_go", [](const Base * b) { return b->dispatch(); });
-
- struct Placeholder { int i; Placeholder(int i) : i(i) { } };
-
- py::class_<Placeholder>(m2, "Placeholder")
- .def(py::init<int>())
- .def("__repr__", [](const Placeholder &p) { return "Placeholder[" + std::to_string(p.i) + "]"; });
-
- // #171: Can't return reference wrappers (or STL datastructures containing them)
- m2.def("return_vec_of_reference_wrapper", [](std::reference_wrapper<Placeholder> p4) {
- Placeholder *p1 = new Placeholder{1};
- Placeholder *p2 = new Placeholder{2};
- Placeholder *p3 = new Placeholder{3};
- std::vector<std::reference_wrapper<Placeholder>> v;
- v.push_back(std::ref(*p1));
- v.push_back(std::ref(*p2));
- v.push_back(std::ref(*p3));
- v.push_back(p4);
- return v;
- });
-
- // #181: iterator passthrough did not compile
- m2.def("iterator_passthrough", [](py::iterator s) -> py::iterator {
- return py::make_iterator(std::begin(s), std::end(s));
- });
-
- // #187: issue involving std::shared_ptr<> return value policy & garbage collection
- struct ElementBase { virtual void foo() { } /* Force creation of virtual table */ };
- struct ElementA : ElementBase {
- ElementA(int v) : v(v) { }
- int value() { return v; }
- int v;
- };
-
- struct ElementList {
- void add(std::shared_ptr<ElementBase> e) { l.push_back(e); }
- std::vector<std::shared_ptr<ElementBase>> l;
- };
-
- py::class_<ElementBase, std::shared_ptr<ElementBase>> (m2, "ElementBase");
-
- py::class_<ElementA, ElementBase, std::shared_ptr<ElementA>>(m2, "ElementA")
- .def(py::init<int>())
- .def("value", &ElementA::value);
-
- py::class_<ElementList, std::shared_ptr<ElementList>>(m2, "ElementList")
- .def(py::init<>())
- .def("add", &ElementList::add)
- .def("get", [](ElementList &el) {
- py::list list;
- for (auto &e : el.l)
- list.append(py::cast(e));
- return list;
- });
-
- // (no id): should not be able to pass 'None' to a reference argument
- m2.def("get_element", [](ElementA &el) { return el.value(); });
-
- // (no id): don't cast doubles to ints
- m2.def("expect_float", [](float f) { return f; });
- m2.def("expect_int", [](int i) { return i; });
-
- try {
- py::class_<Placeholder>(m2, "Placeholder");
- throw std::logic_error("Expected an exception!");
- } catch (std::runtime_error &) {
- /* All good */
- }
-
- // Issue #283: __str__ called on uninitialized instance when constructor arguments invalid
- class StrIssue {
- public:
- StrIssue(int i) : val{i} {}
- StrIssue() : StrIssue(-1) {}
- int value() const { return val; }
- private:
- int val;
- };
- py::class_<StrIssue> si(m2, "StrIssue");
- si .def(py::init<int>())
- .def(py::init<>())
- .def("__str__", [](const StrIssue &si) { return "StrIssue[" + std::to_string(si.value()) + "]"; })
- ;
-
- // Issue #328: first member in a class can't be used in operators
- py::class_<NestABase>(m2, "NestABase").def(py::init<>()).def_readwrite("value", &NestABase::value);
- py::class_<NestA>(m2, "NestA").def(py::init<>()).def(py::self += int())
- .def("as_base", [](NestA &a) -> NestABase& { return (NestABase&) a; }, py::return_value_policy::reference_internal);
- py::class_<NestB>(m2, "NestB").def(py::init<>()).def(py::self -= int()).def_readwrite("a", &NestB::a);
- py::class_<NestC>(m2, "NestC").def(py::init<>()).def(py::self *= int()).def_readwrite("b", &NestC::b);
- m2.def("get_NestA", [](const NestA &a) { return a.value; });
- m2.def("get_NestB", [](const NestB &b) { return b.value; });
- m2.def("get_NestC", [](const NestC &c) { return c.value; });
-
- // Issue 389: r_v_p::move should fall-through to copy on non-movable objects
- class MoveIssue1 {
- public:
- MoveIssue1(int v) : v{v} {}
- MoveIssue1(const MoveIssue1 &c) { v = c.v; }
- MoveIssue1(MoveIssue1 &&) = delete;
- int v;
- };
- class MoveIssue2 {
- public:
- MoveIssue2(int v) : v{v} {}
- MoveIssue2(MoveIssue2 &&) = default;
- int v;
- };
- py::class_<MoveIssue1>(m2, "MoveIssue1").def(py::init<int>()).def_readwrite("value", &MoveIssue1::v);
- py::class_<MoveIssue2>(m2, "MoveIssue2").def(py::init<int>()).def_readwrite("value", &MoveIssue2::v);
- m2.def("get_moveissue1", [](int i) -> MoveIssue1 * { return new MoveIssue1(i); }, py::return_value_policy::move);
- m2.def("get_moveissue2", [](int i) { return MoveIssue2(i); }, py::return_value_policy::move);
-
- // Issues 392/397: overridding reference-returning functions
- class OverrideTest {
- public:
- struct A { std::string value = "hi"; };
- std::string v;
- A a;
- explicit OverrideTest(const std::string &v) : v{v} {}
- virtual std::string str_value() { return v; }
- virtual std::string &str_ref() { return v; }
- virtual A A_value() { return a; }
- virtual A &A_ref() { return a; }
- };
- class PyOverrideTest : public OverrideTest {
- public:
- using OverrideTest::OverrideTest;
- std::string str_value() override { PYBIND11_OVERLOAD(std::string, OverrideTest, str_value); }
- // Not allowed (uncommenting should hit a static_assert failure): we can't get a reference
- // to a python numeric value, since we only copy values in the numeric type caster:
-// std::string &str_ref() override { PYBIND11_OVERLOAD(std::string &, OverrideTest, str_ref); }
- // But we can work around it like this:
- private:
- std::string _tmp;
- std::string str_ref_helper() { PYBIND11_OVERLOAD(std::string, OverrideTest, str_ref); }
- public:
- std::string &str_ref() override { return _tmp = str_ref_helper(); }
-
- A A_value() override { PYBIND11_OVERLOAD(A, OverrideTest, A_value); }
- A &A_ref() override { PYBIND11_OVERLOAD(A &, OverrideTest, A_ref); }
- };
- py::class_<OverrideTest::A>(m2, "OverrideTest_A")
- .def_readwrite("value", &OverrideTest::A::value);
- py::class_<OverrideTest, PyOverrideTest>(m2, "OverrideTest")
- .def(py::init<const std::string &>())
- .def("str_value", &OverrideTest::str_value)
-// .def("str_ref", &OverrideTest::str_ref)
- .def("A_value", &OverrideTest::A_value)
- .def("A_ref", &OverrideTest::A_ref);
-
- /// Issue 393: need to return NotSupported to ensure correct arithmetic operator behavior
- py::class_<OpTest1>(m2, "OpTest1")
- .def(py::init<>())
- .def(py::self + py::self);
-
- py::class_<OpTest2>(m2, "OpTest2")
- .def(py::init<>())
- .def(py::self + py::self)
- .def("__add__", [](const OpTest2& c2, const OpTest1& c1) { return c2 + c1; })
- .def("__radd__", [](const OpTest2& c2, const OpTest1& c1) { return c2 + c1; });
-
- // Issue 388: Can't make iterators via make_iterator() with different r/v policies
- static std::vector<int> list = { 1, 2, 3 };
- m2.def("make_iterator_1", []() { return py::make_iterator<py::return_value_policy::copy>(list); });
- m2.def("make_iterator_2", []() { return py::make_iterator<py::return_value_policy::automatic>(list); });
-
- static std::vector<std::string> nothrows;
- // Issue 461: registering two things with the same name:
- py::class_<Dupe1>(m2, "Dupe1")
- .def("get_value", &Dupe1::get_value)
- ;
- m2.def("dupe1_factory", [](int v) { return new Dupe1(v); });
-
- py::class_<Dupe2>(m2, "Dupe2");
- py::exception<DupeException>(m2, "DupeException");
-
- try {
- m2.def("Dupe1", [](int v) { return new Dupe1(v); });
- nothrows.emplace_back("Dupe1");
- }
- catch (std::runtime_error &) {}
- try {
- py::class_<Dupe3>(m2, "dupe1_factory");
- nothrows.emplace_back("dupe1_factory");
- }
- catch (std::runtime_error &) {}
- try {
- py::exception<Dupe3>(m2, "Dupe2");
- nothrows.emplace_back("Dupe2");
- }
- catch (std::runtime_error &) {}
- try {
- m2.def("DupeException", []() { return 30; });
- nothrows.emplace_back("DupeException1");
- }
- catch (std::runtime_error &) {}
- try {
- py::class_<DupeException>(m2, "DupeException");
- nothrows.emplace_back("DupeException2");
- }
- catch (std::runtime_error &) {}
- m2.def("dupe_exception_failures", []() {
- py::list l;
- for (auto &e : nothrows) l.append(py::cast(e));
- return l;
- });
-
- /// Issue #471: shared pointer instance not dellocated
- class SharedChild : public std::enable_shared_from_this<SharedChild> {
- public:
- SharedChild() { print_created(this); }
- ~SharedChild() { print_destroyed(this); }
- };
-
- class SharedParent {
- public:
- SharedParent() : child(std::make_shared<SharedChild>()) { }
- const SharedChild &get_child() const { return *child; }
-
- private:
- std::shared_ptr<SharedChild> child;
- };
-
- py::class_<SharedChild, std::shared_ptr<SharedChild>>(m, "SharedChild");
- py::class_<SharedParent, std::shared_ptr<SharedParent>>(m, "SharedParent")
- .def(py::init<>())
- .def("get_child", &SharedParent::get_child, py::return_value_policy::reference);
-
- /// Issue/PR #478: unique ptrs constructed and freed without destruction
- class SpecialHolderObj {
- public:
- int val = 0;
- SpecialHolderObj *ch = nullptr;
- SpecialHolderObj(int v, bool make_child = true) : val{v}, ch{make_child ? new SpecialHolderObj(val+1, false) : nullptr}
- { print_created(this, val); }
- ~SpecialHolderObj() { delete ch; print_destroyed(this); }
- SpecialHolderObj *child() { return ch; }
- };
-
- py::class_<SpecialHolderObj, custom_unique_ptr<SpecialHolderObj>>(m, "SpecialHolderObj")
- .def(py::init<int>())
- .def("child", &SpecialHolderObj::child, pybind11::return_value_policy::reference_internal)
- .def_readwrite("val", &SpecialHolderObj::val)
- .def_static("holder_cstats", &ConstructorStats::get<custom_unique_ptr<SpecialHolderObj>>,
- py::return_value_policy::reference);
-
- /// Issue #484: number conversion generates unhandled exceptions
- m2.def("test_complex", [](float x) { py::print("{}"_s.format(x)); });
- m2.def("test_complex", [](std::complex<float> x) { py::print("({}, {})"_s.format(x.real(), x.imag())); });
-
- /// Issue #511: problem with inheritance + overwritten def_static
- struct MyBase {
- static std::unique_ptr<MyBase> make() {
- return std::unique_ptr<MyBase>(new MyBase());
- }
- };
-
- struct MyDerived : MyBase {
- static std::unique_ptr<MyDerived> make() {
- return std::unique_ptr<MyDerived>(new MyDerived());
- }
- };
-
- py::class_<MyBase>(m2, "MyBase")
- .def_static("make", &MyBase::make);
-
- py::class_<MyDerived, MyBase>(m2, "MyDerived")
- .def_static("make", &MyDerived::make)
- .def_static("make2", &MyDerived::make);
-
- py::dict d;
- std::string bar = "bar";
- d["str"] = bar;
- d["num"] = 3.7;
-
- /// Issue #528: templated constructor
- m2.def("tpl_constr_vector", [](std::vector<TplConstrClass> &) {});
- m2.def("tpl_constr_map", [](std::unordered_map<TplConstrClass, TplConstrClass> &) {});
- m2.def("tpl_constr_set", [](std::unordered_set<TplConstrClass> &) {});
-#if defined(PYBIND11_HAS_OPTIONAL)
- m2.def("tpl_constr_optional", [](std::optional<TplConstrClass> &) {});
-#elif defined(PYBIND11_HAS_EXP_OPTIONAL)
- m2.def("tpl_constr_optional", [](std::experimental::optional<TplConstrClass> &) {});
-#endif
-}
-
-// MSVC workaround: trying to use a lambda here crashes MSVC
-test_initializer issues(&init_issues);
diff --git a/thirdparty/pybind11/pybind11/tests/test_issues.py b/thirdparty/pybind11/pybind11/tests/test_issues.py
deleted file mode 100644
index e60b5ca907e44b86317b89961805615553b704e3..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_issues.py
+++ /dev/null
@@ -1,251 +0,0 @@
-import pytest
-from pybind11_tests import ConstructorStats
-
-
-def test_regressions():
- from pybind11_tests.issues import print_cchar, print_char
-
- # #137: const char* isn't handled properly
- assert print_cchar("const char *") == "const char *"
- # #150: char bindings broken
- assert print_char("c") == "c"
-
-
-def test_dispatch_issue(msg):
- """#159: virtual function dispatch has problems with similar-named functions"""
- from pybind11_tests.issues import DispatchIssue, dispatch_issue_go
-
- class PyClass1(DispatchIssue):
- def dispatch(self):
- return "Yay.."
-
- class PyClass2(DispatchIssue):
- def dispatch(self):
- with pytest.raises(RuntimeError) as excinfo:
- super(PyClass2, self).dispatch()
- assert msg(excinfo.value) == 'Tried to call pure virtual function "Base::dispatch"'
-
- p = PyClass1()
- return dispatch_issue_go(p)
-
- b = PyClass2()
- assert dispatch_issue_go(b) == "Yay.."
-
-
-def test_reference_wrapper():
- """#171: Can't return reference wrappers (or STL data structures containing them)"""
- from pybind11_tests.issues import Placeholder, return_vec_of_reference_wrapper
-
- assert str(return_vec_of_reference_wrapper(Placeholder(4))) == \
- "[Placeholder[1], Placeholder[2], Placeholder[3], Placeholder[4]]"
-
-
-def test_iterator_passthrough():
- """#181: iterator passthrough did not compile"""
- from pybind11_tests.issues import iterator_passthrough
-
- assert list(iterator_passthrough(iter([3, 5, 7, 9, 11, 13, 15]))) == [3, 5, 7, 9, 11, 13, 15]
-
-
-def test_shared_ptr_gc():
- """// #187: issue involving std::shared_ptr<> return value policy & garbage collection"""
- from pybind11_tests.issues import ElementList, ElementA
-
- el = ElementList()
- for i in range(10):
- el.add(ElementA(i))
- pytest.gc_collect()
- for i, v in enumerate(el.get()):
- assert i == v.value()
-
-
-def test_no_id(msg):
- from pybind11_tests.issues import get_element, expect_float, expect_int
-
- with pytest.raises(TypeError) as excinfo:
- get_element(None)
- assert msg(excinfo.value) == """
- get_element(): incompatible function arguments. The following argument types are supported:
- 1. (arg0: m.issues.ElementA) -> int
-
- Invoked with: None
- """
-
- with pytest.raises(TypeError) as excinfo:
- expect_int(5.2)
- assert msg(excinfo.value) == """
- expect_int(): incompatible function arguments. The following argument types are supported:
- 1. (arg0: int) -> int
-
- Invoked with: 5.2
- """
- assert expect_float(12) == 12
-
-
-def test_str_issue(msg):
- """Issue #283: __str__ called on uninitialized instance when constructor arguments invalid"""
- from pybind11_tests.issues import StrIssue
-
- assert str(StrIssue(3)) == "StrIssue[3]"
-
- with pytest.raises(TypeError) as excinfo:
- str(StrIssue("no", "such", "constructor"))
- assert msg(excinfo.value) == """
- __init__(): incompatible constructor arguments. The following argument types are supported:
- 1. m.issues.StrIssue(arg0: int)
- 2. m.issues.StrIssue()
-
- Invoked with: 'no', 'such', 'constructor'
- """
-
-
-def test_nested():
- """ #328: first member in a class can't be used in operators"""
- from pybind11_tests.issues import NestA, NestB, NestC, get_NestA, get_NestB, get_NestC
-
- a = NestA()
- b = NestB()
- c = NestC()
-
- a += 10
- assert get_NestA(a) == 13
- b.a += 100
- assert get_NestA(b.a) == 103
- c.b.a += 1000
- assert get_NestA(c.b.a) == 1003
- b -= 1
- assert get_NestB(b) == 3
- c.b -= 3
- assert get_NestB(c.b) == 1
- c *= 7
- assert get_NestC(c) == 35
-
- abase = a.as_base()
- assert abase.value == -2
- a.as_base().value += 44
- assert abase.value == 42
- assert c.b.a.as_base().value == -2
- c.b.a.as_base().value += 44
- assert c.b.a.as_base().value == 42
-
- del c
- pytest.gc_collect()
- del a # Should't delete while abase is still alive
- pytest.gc_collect()
-
- assert abase.value == 42
- del abase, b
- pytest.gc_collect()
-
-
-def test_move_fallback():
- from pybind11_tests.issues import get_moveissue1, get_moveissue2
- m2 = get_moveissue2(2)
- assert m2.value == 2
- m1 = get_moveissue1(1)
- assert m1.value == 1
-
-
-def test_override_ref():
- from pybind11_tests.issues import OverrideTest
- o = OverrideTest("asdf")
-
- # Not allowed (see associated .cpp comment)
- # i = o.str_ref()
- # assert o.str_ref() == "asdf"
- assert o.str_value() == "asdf"
-
- assert o.A_value().value == "hi"
- a = o.A_ref()
- assert a.value == "hi"
- a.value = "bye"
- assert a.value == "bye"
-
-
-def test_operators_notimplemented(capture):
- from pybind11_tests.issues import OpTest1, OpTest2
- with capture:
- c1, c2 = OpTest1(), OpTest2()
- c1 + c1
- c2 + c2
- c2 + c1
- c1 + c2
- assert capture == """
- Add OpTest1 with OpTest1
- Add OpTest2 with OpTest2
- Add OpTest2 with OpTest1
- Add OpTest2 with OpTest1
- """
-
-
-def test_iterator_rvpolicy():
- """ Issue 388: Can't make iterators via make_iterator() with different r/v policies """
- from pybind11_tests.issues import make_iterator_1
- from pybind11_tests.issues import make_iterator_2
-
- assert list(make_iterator_1()) == [1, 2, 3]
- assert list(make_iterator_2()) == [1, 2, 3]
- assert not isinstance(make_iterator_1(), type(make_iterator_2()))
-
-
-def test_dupe_assignment():
- """ Issue 461: overwriting a class with a function """
- from pybind11_tests.issues import dupe_exception_failures
- assert dupe_exception_failures() == []
-
-
-def test_enable_shared_from_this_with_reference_rvp():
- """ Issue #471: shared pointer instance not dellocated """
- from pybind11_tests import SharedParent, SharedChild
-
- parent = SharedParent()
- child = parent.get_child()
-
- cstats = ConstructorStats.get(SharedChild)
- assert cstats.alive() == 1
- del child, parent
- assert cstats.alive() == 0
-
-
-def test_non_destructed_holders():
- """ Issue #478: unique ptrs constructed and freed without destruction """
- from pybind11_tests import SpecialHolderObj
-
- a = SpecialHolderObj(123)
- b = a.child()
-
- assert a.val == 123
- assert b.val == 124
-
- cstats = SpecialHolderObj.holder_cstats()
- assert cstats.alive() == 1
- del b
- assert cstats.alive() == 1
- del a
- assert cstats.alive() == 0
-
-
-def test_complex_cast(capture):
- """ Issue #484: number conversion generates unhandled exceptions """
- from pybind11_tests.issues import test_complex
-
- with capture:
- test_complex(1)
- test_complex(2j)
-
- assert capture == """
- 1.0
- (0.0, 2.0)
- """
-
-
-def test_inheritance_override_def_static():
- from pybind11_tests.issues import MyBase, MyDerived
-
- b = MyBase.make()
- d1 = MyDerived.make2()
- d2 = MyDerived.make()
-
- assert isinstance(b, MyBase)
- assert isinstance(d1, MyDerived)
- assert isinstance(d2, MyDerived)
diff --git a/thirdparty/pybind11/pybind11/tests/test_keep_alive.cpp b/thirdparty/pybind11/pybind11/tests/test_keep_alive.cpp
deleted file mode 100644
index cd62a02e884184b190cdcd9221390014cb26572c..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_keep_alive.cpp
+++ /dev/null
@@ -1,40 +0,0 @@
-/*
- tests/test_keep_alive.cpp -- keep_alive modifier (pybind11's version
- of Boost.Python's with_custodian_and_ward / with_custodian_and_ward_postcall)
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-class Child {
-public:
- Child() { py::print("Allocating child."); }
- ~Child() { py::print("Releasing child."); }
-};
-
-class Parent {
-public:
- Parent() { py::print("Allocating parent."); }
- ~Parent() { py::print("Releasing parent."); }
- void addChild(Child *) { }
- Child *returnChild() { return new Child(); }
- Child *returnNullChild() { return nullptr; }
-};
-
-test_initializer keep_alive([](py::module &m) {
- py::class_<Parent>(m, "Parent")
- .def(py::init<>())
- .def("addChild", &Parent::addChild)
- .def("addChildKeepAlive", &Parent::addChild, py::keep_alive<1, 2>())
- .def("returnChild", &Parent::returnChild)
- .def("returnChildKeepAlive", &Parent::returnChild, py::keep_alive<1, 0>())
- .def("returnNullChildKeepAliveChild", &Parent::returnNullChild, py::keep_alive<1, 0>())
- .def("returnNullChildKeepAliveParent", &Parent::returnNullChild, py::keep_alive<0, 1>());
-
- py::class_<Child>(m, "Child")
- .def(py::init<>());
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_keep_alive.py b/thirdparty/pybind11/pybind11/tests/test_keep_alive.py
deleted file mode 100644
index bfd7d40c3ee2454ca6338b82a08270bc49442895..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_keep_alive.py
+++ /dev/null
@@ -1,97 +0,0 @@
-import pytest
-
-
-def test_keep_alive_argument(capture):
- from pybind11_tests import Parent, Child
-
- with capture:
- p = Parent()
- assert capture == "Allocating parent."
- with capture:
- p.addChild(Child())
- pytest.gc_collect()
- assert capture == """
- Allocating child.
- Releasing child.
- """
- with capture:
- del p
- pytest.gc_collect()
- assert capture == "Releasing parent."
-
- with capture:
- p = Parent()
- assert capture == "Allocating parent."
- with capture:
- p.addChildKeepAlive(Child())
- pytest.gc_collect()
- assert capture == "Allocating child."
- with capture:
- del p
- pytest.gc_collect()
- assert capture == """
- Releasing parent.
- Releasing child.
- """
-
-
-def test_keep_alive_return_value(capture):
- from pybind11_tests import Parent
-
- with capture:
- p = Parent()
- assert capture == "Allocating parent."
- with capture:
- p.returnChild()
- pytest.gc_collect()
- assert capture == """
- Allocating child.
- Releasing child.
- """
- with capture:
- del p
- pytest.gc_collect()
- assert capture == "Releasing parent."
-
- with capture:
- p = Parent()
- assert capture == "Allocating parent."
- with capture:
- p.returnChildKeepAlive()
- pytest.gc_collect()
- assert capture == "Allocating child."
- with capture:
- del p
- pytest.gc_collect()
- assert capture == """
- Releasing parent.
- Releasing child.
- """
-
-
-def test_return_none(capture):
- from pybind11_tests import Parent
-
- with capture:
- p = Parent()
- assert capture == "Allocating parent."
- with capture:
- p.returnNullChildKeepAliveChild()
- pytest.gc_collect()
- assert capture == ""
- with capture:
- del p
- pytest.gc_collect()
- assert capture == "Releasing parent."
-
- with capture:
- p = Parent()
- assert capture == "Allocating parent."
- with capture:
- p.returnNullChildKeepAliveParent()
- pytest.gc_collect()
- assert capture == ""
- with capture:
- del p
- pytest.gc_collect()
- assert capture == "Releasing parent."
diff --git a/thirdparty/pybind11/pybind11/tests/test_kwargs_and_defaults.cpp b/thirdparty/pybind11/pybind11/tests/test_kwargs_and_defaults.cpp
deleted file mode 100644
index 3180123dfb11436b96afeebfd0419f8224645026..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_kwargs_and_defaults.cpp
+++ /dev/null
@@ -1,93 +0,0 @@
-/*
- tests/test_kwargs_and_defaults.cpp -- keyword arguments and default values
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include <pybind11/stl.h>
-
-std::string kw_func(int x, int y) { return "x=" + std::to_string(x) + ", y=" + std::to_string(y); }
-
-std::string kw_func4(const std::vector<int> &entries) {
- std::string ret = "{";
- for (int i : entries)
- ret += std::to_string(i) + " ";
- ret.back() = '}';
- return ret;
-}
-
-py::tuple args_function(py::args args) {
- return args;
-}
-
-py::tuple args_kwargs_function(py::args args, py::kwargs kwargs) {
- return py::make_tuple(args, kwargs);
-}
-
-py::tuple mixed_plus_args(int i, double j, py::args args) {
- return py::make_tuple(i, j, args);
-}
-
-py::tuple mixed_plus_kwargs(int i, double j, py::kwargs kwargs) {
- return py::make_tuple(i, j, kwargs);
-}
-
-py::tuple mixed_plus_args_kwargs(int i, double j, py::args args, py::kwargs kwargs) {
- return py::make_tuple(i, j, args, kwargs);
-}
-
-// pybind11 won't allow these to be bound: args and kwargs, if present, must be at the end.
-void bad_args1(py::args, int) {}
-void bad_args2(py::kwargs, int) {}
-void bad_args3(py::kwargs, py::args) {}
-void bad_args4(py::args, int, py::kwargs) {}
-void bad_args5(py::args, py::kwargs, int) {}
-void bad_args6(py::args, py::args) {}
-void bad_args7(py::kwargs, py::kwargs) {}
-
-struct KWClass {
- void foo(int, float) {}
-};
-
-test_initializer arg_keywords_and_defaults([](py::module &m) {
- m.def("kw_func0", &kw_func);
- m.def("kw_func1", &kw_func, py::arg("x"), py::arg("y"));
- m.def("kw_func2", &kw_func, py::arg("x") = 100, py::arg("y") = 200);
- m.def("kw_func3", [](const char *) { }, py::arg("data") = std::string("Hello world!"));
-
- /* A fancier default argument */
- std::vector<int> list;
- list.push_back(13);
- list.push_back(17);
- m.def("kw_func4", &kw_func4, py::arg("myList") = list);
-
- m.def("args_function", &args_function);
- m.def("args_kwargs_function", &args_kwargs_function);
-
- m.def("kw_func_udl", &kw_func, "x"_a, "y"_a=300);
- m.def("kw_func_udl_z", &kw_func, "x"_a, "y"_a=0);
-
- py::class_<KWClass>(m, "KWClass")
- .def("foo0", &KWClass::foo)
- .def("foo1", &KWClass::foo, "x"_a, "y"_a);
-
- m.def("mixed_plus_args", &mixed_plus_args);
- m.def("mixed_plus_kwargs", &mixed_plus_kwargs);
- m.def("mixed_plus_args_kwargs", &mixed_plus_args_kwargs);
-
- m.def("mixed_plus_args_kwargs_defaults", &mixed_plus_args_kwargs,
- py::arg("i") = 1, py::arg("j") = 3.14159);
-
- // Uncomment these to test that the static_assert is indeed working:
-// m.def("bad_args1", &bad_args1);
-// m.def("bad_args2", &bad_args2);
-// m.def("bad_args3", &bad_args3);
-// m.def("bad_args4", &bad_args4);
-// m.def("bad_args5", &bad_args5);
-// m.def("bad_args6", &bad_args6);
-// m.def("bad_args7", &bad_args7);
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_kwargs_and_defaults.py b/thirdparty/pybind11/pybind11/tests/test_kwargs_and_defaults.py
deleted file mode 100644
index 90f8489ed78fd7525685019b0363b0d4809921d5..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_kwargs_and_defaults.py
+++ /dev/null
@@ -1,108 +0,0 @@
-import pytest
-from pybind11_tests import (kw_func0, kw_func1, kw_func2, kw_func3, kw_func4, args_function,
- args_kwargs_function, kw_func_udl, kw_func_udl_z, KWClass)
-
-
-def test_function_signatures(doc):
- assert doc(kw_func0) == "kw_func0(arg0: int, arg1: int) -> str"
- assert doc(kw_func1) == "kw_func1(x: int, y: int) -> str"
- assert doc(kw_func2) == "kw_func2(x: int=100, y: int=200) -> str"
- assert doc(kw_func3) == "kw_func3(data: str='Hello world!') -> None"
- assert doc(kw_func4) == "kw_func4(myList: List[int]=[13, 17]) -> str"
- assert doc(kw_func_udl) == "kw_func_udl(x: int, y: int=300) -> str"
- assert doc(kw_func_udl_z) == "kw_func_udl_z(x: int, y: int=0) -> str"
- assert doc(args_function) == "args_function(*args) -> tuple"
- assert doc(args_kwargs_function) == "args_kwargs_function(*args, **kwargs) -> tuple"
- assert doc(KWClass.foo0) == "foo0(self: m.KWClass, arg0: int, arg1: float) -> None"
- assert doc(KWClass.foo1) == "foo1(self: m.KWClass, x: int, y: float) -> None"
-
-
-def test_named_arguments(msg):
- assert kw_func0(5, 10) == "x=5, y=10"
-
- assert kw_func1(5, 10) == "x=5, y=10"
- assert kw_func1(5, y=10) == "x=5, y=10"
- assert kw_func1(y=10, x=5) == "x=5, y=10"
-
- assert kw_func2() == "x=100, y=200"
- assert kw_func2(5) == "x=5, y=200"
- assert kw_func2(x=5) == "x=5, y=200"
- assert kw_func2(y=10) == "x=100, y=10"
- assert kw_func2(5, 10) == "x=5, y=10"
- assert kw_func2(x=5, y=10) == "x=5, y=10"
-
- with pytest.raises(TypeError) as excinfo:
- # noinspection PyArgumentList
- kw_func2(x=5, y=10, z=12)
- assert excinfo.match(
- r'(?s)^kw_func2\(\): incompatible.*Invoked with: kwargs: ((x=5|y=10|z=12)(, |$))' + '{3}$')
-
- assert kw_func4() == "{13 17}"
- assert kw_func4(myList=[1, 2, 3]) == "{1 2 3}"
-
- assert kw_func_udl(x=5, y=10) == "x=5, y=10"
- assert kw_func_udl_z(x=5) == "x=5, y=0"
-
-
-def test_arg_and_kwargs():
- args = 'arg1_value', 'arg2_value', 3
- assert args_function(*args) == args
-
- args = 'a1', 'a2'
- kwargs = dict(arg3='a3', arg4=4)
- assert args_kwargs_function(*args, **kwargs) == (args, kwargs)
-
-
-def test_mixed_args_and_kwargs(msg):
- from pybind11_tests import (mixed_plus_args, mixed_plus_kwargs, mixed_plus_args_kwargs,
- mixed_plus_args_kwargs_defaults)
- mpa = mixed_plus_args
- mpk = mixed_plus_kwargs
- mpak = mixed_plus_args_kwargs
- mpakd = mixed_plus_args_kwargs_defaults
-
- assert mpa(1, 2.5, 4, 99.5, None) == (1, 2.5, (4, 99.5, None))
- assert mpa(1, 2.5) == (1, 2.5, ())
- with pytest.raises(TypeError) as excinfo:
- assert mpa(1)
- assert msg(excinfo.value) == """
- mixed_plus_args(): incompatible function arguments. The following argument types are supported:
- 1. (arg0: int, arg1: float, *args) -> tuple
-
- Invoked with: 1
- """ # noqa: E501 line too long
- with pytest.raises(TypeError) as excinfo:
- assert mpa()
- assert msg(excinfo.value) == """
- mixed_plus_args(): incompatible function arguments. The following argument types are supported:
- 1. (arg0: int, arg1: float, *args) -> tuple
-
- Invoked with:
- """ # noqa: E501 line too long
-
- assert mpk(-2, 3.5, pi=3.14159, e=2.71828) == (-2, 3.5, {'e': 2.71828, 'pi': 3.14159})
- assert mpak(7, 7.7, 7.77, 7.777, 7.7777, minusseven=-7) == (
- 7, 7.7, (7.77, 7.777, 7.7777), {'minusseven': -7})
- assert mpakd() == (1, 3.14159, (), {})
- assert mpakd(3) == (3, 3.14159, (), {})
- assert mpakd(j=2.71828) == (1, 2.71828, (), {})
- assert mpakd(k=42) == (1, 3.14159, (), {'k': 42})
- assert mpakd(1, 1, 2, 3, 5, 8, then=13, followedby=21) == (
- 1, 1, (2, 3, 5, 8), {'then': 13, 'followedby': 21})
- # Arguments specified both positionally and via kwargs should fail:
- with pytest.raises(TypeError) as excinfo:
- assert mpakd(1, i=1)
- assert msg(excinfo.value) == """
- mixed_plus_args_kwargs_defaults(): incompatible function arguments. The following argument types are supported:
- 1. (i: int=1, j: float=3.14159, *args, **kwargs) -> tuple
-
- Invoked with: 1; kwargs: i=1
- """ # noqa: E501 line too long
- with pytest.raises(TypeError) as excinfo:
- assert mpakd(1, 2, j=1)
- assert msg(excinfo.value) == """
- mixed_plus_args_kwargs_defaults(): incompatible function arguments. The following argument types are supported:
- 1. (i: int=1, j: float=3.14159, *args, **kwargs) -> tuple
-
- Invoked with: 1, 2; kwargs: j=1
- """ # noqa: E501 line too long
diff --git a/thirdparty/pybind11/pybind11/tests/test_methods_and_attributes.cpp b/thirdparty/pybind11/pybind11/tests/test_methods_and_attributes.cpp
deleted file mode 100644
index b7b2edfd83b1b677ce416e3a58a59fd5ed070d91..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_methods_and_attributes.cpp
+++ /dev/null
@@ -1,297 +0,0 @@
-/*
- tests/test_methods_and_attributes.cpp -- constructors, deconstructors, attribute access,
- __str__, argument and return value conventions
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include "constructor_stats.h"
-
-class ExampleMandA {
-public:
- ExampleMandA() { print_default_created(this); }
- ExampleMandA(int value) : value(value) { print_created(this, value); }
- ExampleMandA(const ExampleMandA &e) : value(e.value) { print_copy_created(this); }
- ExampleMandA(ExampleMandA &&e) : value(e.value) { print_move_created(this); }
- ~ExampleMandA() { print_destroyed(this); }
-
- std::string toString() {
- return "ExampleMandA[value=" + std::to_string(value) + "]";
- }
-
- void operator=(const ExampleMandA &e) { print_copy_assigned(this); value = e.value; }
- void operator=(ExampleMandA &&e) { print_move_assigned(this); value = e.value; }
-
- void add1(ExampleMandA other) { value += other.value; } // passing by value
- void add2(ExampleMandA &other) { value += other.value; } // passing by reference
- void add3(const ExampleMandA &other) { value += other.value; } // passing by const reference
- void add4(ExampleMandA *other) { value += other->value; } // passing by pointer
- void add5(const ExampleMandA *other) { value += other->value; } // passing by const pointer
-
- void add6(int other) { value += other; } // passing by value
- void add7(int &other) { value += other; } // passing by reference
- void add8(const int &other) { value += other; } // passing by const reference
- void add9(int *other) { value += *other; } // passing by pointer
- void add10(const int *other) { value += *other; } // passing by const pointer
-
- ExampleMandA self1() { return *this; } // return by value
- ExampleMandA &self2() { return *this; } // return by reference
- const ExampleMandA &self3() { return *this; } // return by const reference
- ExampleMandA *self4() { return this; } // return by pointer
- const ExampleMandA *self5() { return this; } // return by const pointer
-
- int internal1() { return value; } // return by value
- int &internal2() { return value; } // return by reference
- const int &internal3() { return value; } // return by const reference
- int *internal4() { return &value; } // return by pointer
- const int *internal5() { return &value; } // return by const pointer
-
- py::str overloaded(int, float) { return "(int, float)"; }
- py::str overloaded(float, int) { return "(float, int)"; }
- py::str overloaded(int, int) { return "(int, int)"; }
- py::str overloaded(float, float) { return "(float, float)"; }
- py::str overloaded(int, float) const { return "(int, float) const"; }
- py::str overloaded(float, int) const { return "(float, int) const"; }
- py::str overloaded(int, int) const { return "(int, int) const"; }
- py::str overloaded(float, float) const { return "(float, float) const"; }
-
- int value = 0;
-};
-
-struct TestProperties {
- int value = 1;
- static int static_value;
-
- int get() const { return value; }
- void set(int v) { value = v; }
-
- static int static_get() { return static_value; }
- static void static_set(int v) { static_value = v; }
-};
-
-int TestProperties::static_value = 1;
-
-struct SimpleValue { int value = 1; };
-
-struct TestPropRVP {
- SimpleValue v1;
- SimpleValue v2;
- static SimpleValue sv1;
- static SimpleValue sv2;
-
- const SimpleValue &get1() const { return v1; }
- const SimpleValue &get2() const { return v2; }
- SimpleValue get_rvalue() const { return v2; }
- void set1(int v) { v1.value = v; }
- void set2(int v) { v2.value = v; }
-};
-
-SimpleValue TestPropRVP::sv1{};
-SimpleValue TestPropRVP::sv2{};
-
-class DynamicClass {
-public:
- DynamicClass() { print_default_created(this); }
- ~DynamicClass() { print_destroyed(this); }
-};
-
-class CppDerivedDynamicClass : public DynamicClass { };
-
-// py::arg/py::arg_v testing: these arguments just record their argument when invoked
-class ArgInspector1 { public: std::string arg = "(default arg inspector 1)"; };
-class ArgInspector2 { public: std::string arg = "(default arg inspector 2)"; };
-class ArgAlwaysConverts { };
-namespace pybind11 { namespace detail {
-template <> struct type_caster<ArgInspector1> {
-public:
- PYBIND11_TYPE_CASTER(ArgInspector1, _("ArgInspector1"));
-
- bool load(handle src, bool convert) {
- value.arg = "loading ArgInspector1 argument " +
- std::string(convert ? "WITH" : "WITHOUT") + " conversion allowed. "
- "Argument value = " + (std::string) str(src);
- return true;
- }
-
- static handle cast(const ArgInspector1 &src, return_value_policy, handle) {
- return str(src.arg).release();
- }
-};
-template <> struct type_caster<ArgInspector2> {
-public:
- PYBIND11_TYPE_CASTER(ArgInspector2, _("ArgInspector2"));
-
- bool load(handle src, bool convert) {
- value.arg = "loading ArgInspector2 argument " +
- std::string(convert ? "WITH" : "WITHOUT") + " conversion allowed. "
- "Argument value = " + (std::string) str(src);
- return true;
- }
-
- static handle cast(const ArgInspector2 &src, return_value_policy, handle) {
- return str(src.arg).release();
- }
-};
-template <> struct type_caster<ArgAlwaysConverts> {
-public:
- PYBIND11_TYPE_CASTER(ArgAlwaysConverts, _("ArgAlwaysConverts"));
-
- bool load(handle, bool convert) {
- return convert;
- }
-
- static handle cast(const ArgAlwaysConverts &, return_value_policy, handle) {
- return py::none();
- }
-};
-}}
-
-/// Issue/PR #648: bad arg default debugging output
-class NotRegistered {};
-
-test_initializer methods_and_attributes([](py::module &m) {
- py::class_<ExampleMandA>(m, "ExampleMandA")
- .def(py::init<>())
- .def(py::init<int>())
- .def(py::init<const ExampleMandA&>())
- .def("add1", &ExampleMandA::add1)
- .def("add2", &ExampleMandA::add2)
- .def("add3", &ExampleMandA::add3)
- .def("add4", &ExampleMandA::add4)
- .def("add5", &ExampleMandA::add5)
- .def("add6", &ExampleMandA::add6)
- .def("add7", &ExampleMandA::add7)
- .def("add8", &ExampleMandA::add8)
- .def("add9", &ExampleMandA::add9)
- .def("add10", &ExampleMandA::add10)
- .def("self1", &ExampleMandA::self1)
- .def("self2", &ExampleMandA::self2)
- .def("self3", &ExampleMandA::self3)
- .def("self4", &ExampleMandA::self4)
- .def("self5", &ExampleMandA::self5)
- .def("internal1", &ExampleMandA::internal1)
- .def("internal2", &ExampleMandA::internal2)
- .def("internal3", &ExampleMandA::internal3)
- .def("internal4", &ExampleMandA::internal4)
- .def("internal5", &ExampleMandA::internal5)
-#if defined(PYBIND11_OVERLOAD_CAST)
- .def("overloaded", py::overload_cast<int, float>(&ExampleMandA::overloaded))
- .def("overloaded", py::overload_cast<float, int>(&ExampleMandA::overloaded))
- .def("overloaded", py::overload_cast<int, int>(&ExampleMandA::overloaded))
- .def("overloaded", py::overload_cast<float, float>(&ExampleMandA::overloaded))
- .def("overloaded_float", py::overload_cast<float, float>(&ExampleMandA::overloaded))
- .def("overloaded_const", py::overload_cast<int, float>(&ExampleMandA::overloaded, py::const_))
- .def("overloaded_const", py::overload_cast<float, int>(&ExampleMandA::overloaded, py::const_))
- .def("overloaded_const", py::overload_cast<int, int>(&ExampleMandA::overloaded, py::const_))
- .def("overloaded_const", py::overload_cast<float, float>(&ExampleMandA::overloaded, py::const_))
-#else
- .def("overloaded", static_cast<py::str (ExampleMandA::*)(int, float)>(&ExampleMandA::overloaded))
- .def("overloaded", static_cast<py::str (ExampleMandA::*)(float, int)>(&ExampleMandA::overloaded))
- .def("overloaded", static_cast<py::str (ExampleMandA::*)(int, int)>(&ExampleMandA::overloaded))
- .def("overloaded", static_cast<py::str (ExampleMandA::*)(float, float)>(&ExampleMandA::overloaded))
- .def("overloaded_float", static_cast<py::str (ExampleMandA::*)(float, float)>(&ExampleMandA::overloaded))
- .def("overloaded_const", static_cast<py::str (ExampleMandA::*)(int, float) const>(&ExampleMandA::overloaded))
- .def("overloaded_const", static_cast<py::str (ExampleMandA::*)(float, int) const>(&ExampleMandA::overloaded))
- .def("overloaded_const", static_cast<py::str (ExampleMandA::*)(int, int) const>(&ExampleMandA::overloaded))
- .def("overloaded_const", static_cast<py::str (ExampleMandA::*)(float, float) const>(&ExampleMandA::overloaded))
-#endif
- .def("__str__", &ExampleMandA::toString)
- .def_readwrite("value", &ExampleMandA::value);
-
- py::class_<TestProperties>(m, "TestProperties")
- .def(py::init<>())
- .def_readonly("def_readonly", &TestProperties::value)
- .def_readwrite("def_readwrite", &TestProperties::value)
- .def_property_readonly("def_property_readonly", &TestProperties::get)
- .def_property("def_property", &TestProperties::get, &TestProperties::set)
- .def_readonly_static("def_readonly_static", &TestProperties::static_value)
- .def_readwrite_static("def_readwrite_static", &TestProperties::static_value)
- .def_property_readonly_static("def_property_readonly_static",
- [](py::object) { return TestProperties::static_get(); })
- .def_property_static("def_property_static",
- [](py::object) { return TestProperties::static_get(); },
- [](py::object, int v) { TestProperties::static_set(v); })
- .def_property_static("static_cls",
- [](py::object cls) { return cls; },
- [](py::object cls, py::function f) { f(cls); });
-
- py::class_<SimpleValue>(m, "SimpleValue")
- .def_readwrite("value", &SimpleValue::value);
-
- auto static_get1 = [](py::object) -> const SimpleValue & { return TestPropRVP::sv1; };
- auto static_get2 = [](py::object) -> const SimpleValue & { return TestPropRVP::sv2; };
- auto static_set1 = [](py::object, int v) { TestPropRVP::sv1.value = v; };
- auto static_set2 = [](py::object, int v) { TestPropRVP::sv2.value = v; };
- auto rvp_copy = py::return_value_policy::copy;
-
- py::class_<TestPropRVP>(m, "TestPropRVP")
- .def(py::init<>())
- .def_property_readonly("ro_ref", &TestPropRVP::get1)
- .def_property_readonly("ro_copy", &TestPropRVP::get2, rvp_copy)
- .def_property_readonly("ro_func", py::cpp_function(&TestPropRVP::get2, rvp_copy))
- .def_property("rw_ref", &TestPropRVP::get1, &TestPropRVP::set1)
- .def_property("rw_copy", &TestPropRVP::get2, &TestPropRVP::set2, rvp_copy)
- .def_property("rw_func", py::cpp_function(&TestPropRVP::get2, rvp_copy), &TestPropRVP::set2)
- .def_property_readonly_static("static_ro_ref", static_get1)
- .def_property_readonly_static("static_ro_copy", static_get2, rvp_copy)
- .def_property_readonly_static("static_ro_func", py::cpp_function(static_get2, rvp_copy))
- .def_property_static("static_rw_ref", static_get1, static_set1)
- .def_property_static("static_rw_copy", static_get2, static_set2, rvp_copy)
- .def_property_static("static_rw_func", py::cpp_function(static_get2, rvp_copy), static_set2)
- .def_property_readonly("rvalue", &TestPropRVP::get_rvalue)
- .def_property_readonly_static("static_rvalue", [](py::object) { return SimpleValue(); });
-
- struct MetaclassOverride { };
- py::class_<MetaclassOverride>(m, "MetaclassOverride", py::metaclass((PyObject *) &PyType_Type))
- .def_property_readonly_static("readonly", [](py::object) { return 1; });
-
-#if !defined(PYPY_VERSION)
- py::class_<DynamicClass>(m, "DynamicClass", py::dynamic_attr())
- .def(py::init());
-
- py::class_<CppDerivedDynamicClass, DynamicClass>(m, "CppDerivedDynamicClass")
- .def(py::init());
-#endif
-
- // Test converting. The ArgAlwaysConverts is just there to make the first no-conversion pass
- // fail so that our call always ends up happening via the second dispatch (the one that allows
- // some conversion).
- class ArgInspector {
- public:
- ArgInspector1 f(ArgInspector1 a, ArgAlwaysConverts) { return a; }
- std::string g(ArgInspector1 a, const ArgInspector1 &b, int c, ArgInspector2 *d, ArgAlwaysConverts) {
- return a.arg + "\n" + b.arg + "\n" + std::to_string(c) + "\n" + d->arg;
- }
- static ArgInspector2 h(ArgInspector2 a, ArgAlwaysConverts) { return a; }
- };
- py::class_<ArgInspector>(m, "ArgInspector")
- .def(py::init<>())
- .def("f", &ArgInspector::f, py::arg(), py::arg() = ArgAlwaysConverts())
- .def("g", &ArgInspector::g, "a"_a.noconvert(), "b"_a, "c"_a.noconvert()=13, "d"_a=ArgInspector2(), py::arg() = ArgAlwaysConverts())
- .def_static("h", &ArgInspector::h, py::arg().noconvert(), py::arg() = ArgAlwaysConverts())
- ;
- m.def("arg_inspect_func", [](ArgInspector2 a, ArgInspector1 b, ArgAlwaysConverts) { return a.arg + "\n" + b.arg; },
- py::arg().noconvert(false), py::arg_v(nullptr, ArgInspector1()).noconvert(true), py::arg() = ArgAlwaysConverts());
-
- m.def("floats_preferred", [](double f) { return 0.5 * f; }, py::arg("f"));
- m.def("floats_only", [](double f) { return 0.5 * f; }, py::arg("f").noconvert());
-
- /// Issue/PR #648: bad arg default debugging output
-#if !defined(NDEBUG)
- m.attr("debug_enabled") = true;
-#else
- m.attr("debug_enabled") = false;
-#endif
- m.def("bad_arg_def_named", []{
- auto m = py::module::import("pybind11_tests.issues");
- m.def("should_fail", [](int, NotRegistered) {}, py::arg(), py::arg("a") = NotRegistered());
- });
- m.def("bad_arg_def_unnamed", []{
- auto m = py::module::import("pybind11_tests.issues");
- m.def("should_fail", [](int, NotRegistered) {}, py::arg(), py::arg() = NotRegistered());
- });
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_methods_and_attributes.py b/thirdparty/pybind11/pybind11/tests/test_methods_and_attributes.py
deleted file mode 100644
index f185ac26d31ac1f37730806f5b8c40da4175958a..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_methods_and_attributes.py
+++ /dev/null
@@ -1,325 +0,0 @@
-import pytest
-from pybind11_tests import ExampleMandA, ConstructorStats
-
-
-def test_methods_and_attributes():
- instance1 = ExampleMandA()
- instance2 = ExampleMandA(32)
-
- instance1.add1(instance2)
- instance1.add2(instance2)
- instance1.add3(instance2)
- instance1.add4(instance2)
- instance1.add5(instance2)
- instance1.add6(32)
- instance1.add7(32)
- instance1.add8(32)
- instance1.add9(32)
- instance1.add10(32)
-
- assert str(instance1) == "ExampleMandA[value=320]"
- assert str(instance2) == "ExampleMandA[value=32]"
- assert str(instance1.self1()) == "ExampleMandA[value=320]"
- assert str(instance1.self2()) == "ExampleMandA[value=320]"
- assert str(instance1.self3()) == "ExampleMandA[value=320]"
- assert str(instance1.self4()) == "ExampleMandA[value=320]"
- assert str(instance1.self5()) == "ExampleMandA[value=320]"
-
- assert instance1.internal1() == 320
- assert instance1.internal2() == 320
- assert instance1.internal3() == 320
- assert instance1.internal4() == 320
- assert instance1.internal5() == 320
-
- assert instance1.overloaded(1, 1.0) == "(int, float)"
- assert instance1.overloaded(2.0, 2) == "(float, int)"
- assert instance1.overloaded(3, 3) == "(int, int)"
- assert instance1.overloaded(4., 4.) == "(float, float)"
- assert instance1.overloaded_const(5, 5.0) == "(int, float) const"
- assert instance1.overloaded_const(6.0, 6) == "(float, int) const"
- assert instance1.overloaded_const(7, 7) == "(int, int) const"
- assert instance1.overloaded_const(8., 8.) == "(float, float) const"
- assert instance1.overloaded_float(1, 1) == "(float, float)"
- assert instance1.overloaded_float(1, 1.) == "(float, float)"
- assert instance1.overloaded_float(1., 1) == "(float, float)"
- assert instance1.overloaded_float(1., 1.) == "(float, float)"
-
- assert instance1.value == 320
- instance1.value = 100
- assert str(instance1) == "ExampleMandA[value=100]"
-
- cstats = ConstructorStats.get(ExampleMandA)
- assert cstats.alive() == 2
- del instance1, instance2
- assert cstats.alive() == 0
- assert cstats.values() == ["32"]
- assert cstats.default_constructions == 1
- assert cstats.copy_constructions == 3
- assert cstats.move_constructions >= 1
- assert cstats.copy_assignments == 0
- assert cstats.move_assignments == 0
-
-
-def test_properties():
- from pybind11_tests import TestProperties
-
- instance = TestProperties()
-
- assert instance.def_readonly == 1
- with pytest.raises(AttributeError):
- instance.def_readonly = 2
-
- instance.def_readwrite = 2
- assert instance.def_readwrite == 2
-
- assert instance.def_property_readonly == 2
- with pytest.raises(AttributeError):
- instance.def_property_readonly = 3
-
- instance.def_property = 3
- assert instance.def_property == 3
-
-
-def test_static_properties():
- from pybind11_tests import TestProperties as Type
-
- assert Type.def_readonly_static == 1
- with pytest.raises(AttributeError) as excinfo:
- Type.def_readonly_static = 2
- assert "can't set attribute" in str(excinfo)
-
- Type.def_readwrite_static = 2
- assert Type.def_readwrite_static == 2
-
- assert Type.def_property_readonly_static == 2
- with pytest.raises(AttributeError) as excinfo:
- Type.def_property_readonly_static = 3
- assert "can't set attribute" in str(excinfo)
-
- Type.def_property_static = 3
- assert Type.def_property_static == 3
-
- # Static property read and write via instance
- instance = Type()
-
- Type.def_readwrite_static = 0
- assert Type.def_readwrite_static == 0
- assert instance.def_readwrite_static == 0
-
- instance.def_readwrite_static = 2
- assert Type.def_readwrite_static == 2
- assert instance.def_readwrite_static == 2
-
-
-def test_static_cls():
- """Static property getter and setters expect the type object as the their only argument"""
- from pybind11_tests import TestProperties as Type
-
- instance = Type()
- assert Type.static_cls is Type
- assert instance.static_cls is Type
-
- def check_self(self):
- assert self is Type
-
- Type.static_cls = check_self
- instance.static_cls = check_self
-
-
-def test_metaclass_override():
- """Overriding pybind11's default metaclass changes the behavior of `static_property`"""
- from pybind11_tests import MetaclassOverride
-
- assert type(ExampleMandA).__name__ == "pybind11_type"
- assert type(MetaclassOverride).__name__ == "type"
-
- assert MetaclassOverride.readonly == 1
- assert type(MetaclassOverride.__dict__["readonly"]).__name__ == "pybind11_static_property"
-
- # Regular `type` replaces the property instead of calling `__set__()`
- MetaclassOverride.readonly = 2
- assert MetaclassOverride.readonly == 2
- assert isinstance(MetaclassOverride.__dict__["readonly"], int)
-
-
-@pytest.mark.parametrize("access", ["ro", "rw", "static_ro", "static_rw"])
-def test_property_return_value_policies(access):
- from pybind11_tests import TestPropRVP
-
- if not access.startswith("static"):
- obj = TestPropRVP()
- else:
- obj = TestPropRVP
-
- ref = getattr(obj, access + "_ref")
- assert ref.value == 1
- ref.value = 2
- assert getattr(obj, access + "_ref").value == 2
- ref.value = 1 # restore original value for static properties
-
- copy = getattr(obj, access + "_copy")
- assert copy.value == 1
- copy.value = 2
- assert getattr(obj, access + "_copy").value == 1
-
- copy = getattr(obj, access + "_func")
- assert copy.value == 1
- copy.value = 2
- assert getattr(obj, access + "_func").value == 1
-
-
-def test_property_rvalue_policy():
- """When returning an rvalue, the return value policy is automatically changed from
- `reference(_internal)` to `move`. The following would not work otherwise.
- """
- from pybind11_tests import TestPropRVP
-
- instance = TestPropRVP()
- o = instance.rvalue
- assert o.value == 1
-
-
-def test_property_rvalue_policy_static():
- """When returning an rvalue, the return value policy is automatically changed from
- `reference(_internal)` to `move`. The following would not work otherwise.
- """
- from pybind11_tests import TestPropRVP
- o = TestPropRVP.static_rvalue
- assert o.value == 1
-
-
-# https://bitbucket.org/pypy/pypy/issues/2447
-@pytest.unsupported_on_pypy
-def test_dynamic_attributes():
- from pybind11_tests import DynamicClass, CppDerivedDynamicClass
-
- instance = DynamicClass()
- assert not hasattr(instance, "foo")
- assert "foo" not in dir(instance)
-
- # Dynamically add attribute
- instance.foo = 42
- assert hasattr(instance, "foo")
- assert instance.foo == 42
- assert "foo" in dir(instance)
-
- # __dict__ should be accessible and replaceable
- assert "foo" in instance.__dict__
- instance.__dict__ = {"bar": True}
- assert not hasattr(instance, "foo")
- assert hasattr(instance, "bar")
-
- with pytest.raises(TypeError) as excinfo:
- instance.__dict__ = []
- assert str(excinfo.value) == "__dict__ must be set to a dictionary, not a 'list'"
-
- cstats = ConstructorStats.get(DynamicClass)
- assert cstats.alive() == 1
- del instance
- assert cstats.alive() == 0
-
- # Derived classes should work as well
- class PythonDerivedDynamicClass(DynamicClass):
- pass
-
- for cls in CppDerivedDynamicClass, PythonDerivedDynamicClass:
- derived = cls()
- derived.foobar = 100
- assert derived.foobar == 100
-
- assert cstats.alive() == 1
- del derived
- assert cstats.alive() == 0
-
-
-# https://bitbucket.org/pypy/pypy/issues/2447
-@pytest.unsupported_on_pypy
-def test_cyclic_gc():
- from pybind11_tests import DynamicClass
-
- # One object references itself
- instance = DynamicClass()
- instance.circular_reference = instance
-
- cstats = ConstructorStats.get(DynamicClass)
- assert cstats.alive() == 1
- del instance
- assert cstats.alive() == 0
-
- # Two object reference each other
- i1 = DynamicClass()
- i2 = DynamicClass()
- i1.cycle = i2
- i2.cycle = i1
-
- assert cstats.alive() == 2
- del i1, i2
- assert cstats.alive() == 0
-
-
-def test_noconvert_args(msg):
- from pybind11_tests import ArgInspector, arg_inspect_func, floats_only, floats_preferred
-
- a = ArgInspector()
- assert msg(a.f("hi")) == """
- loading ArgInspector1 argument WITH conversion allowed. Argument value = hi
- """
- assert msg(a.g("this is a", "this is b")) == """
- loading ArgInspector1 argument WITHOUT conversion allowed. Argument value = this is a
- loading ArgInspector1 argument WITH conversion allowed. Argument value = this is b
- 13
- loading ArgInspector2 argument WITH conversion allowed. Argument value = (default arg inspector 2)
- """ # noqa: E501 line too long
- assert msg(a.g("this is a", "this is b", 42)) == """
- loading ArgInspector1 argument WITHOUT conversion allowed. Argument value = this is a
- loading ArgInspector1 argument WITH conversion allowed. Argument value = this is b
- 42
- loading ArgInspector2 argument WITH conversion allowed. Argument value = (default arg inspector 2)
- """ # noqa: E501 line too long
- assert msg(a.g("this is a", "this is b", 42, "this is d")) == """
- loading ArgInspector1 argument WITHOUT conversion allowed. Argument value = this is a
- loading ArgInspector1 argument WITH conversion allowed. Argument value = this is b
- 42
- loading ArgInspector2 argument WITH conversion allowed. Argument value = this is d
- """
- assert (a.h("arg 1") ==
- "loading ArgInspector2 argument WITHOUT conversion allowed. Argument value = arg 1")
- assert msg(arg_inspect_func("A1", "A2")) == """
- loading ArgInspector2 argument WITH conversion allowed. Argument value = A1
- loading ArgInspector1 argument WITHOUT conversion allowed. Argument value = A2
- """
-
- assert floats_preferred(4) == 2.0
- assert floats_only(4.0) == 2.0
- with pytest.raises(TypeError) as excinfo:
- floats_only(4)
- assert msg(excinfo.value) == """
- floats_only(): incompatible function arguments. The following argument types are supported:
- 1. (f: float) -> float
-
- Invoked with: 4
- """
-
-
-def test_bad_arg_default(msg):
- from pybind11_tests import debug_enabled, bad_arg_def_named, bad_arg_def_unnamed
-
- with pytest.raises(RuntimeError) as excinfo:
- bad_arg_def_named()
- assert msg(excinfo.value) == (
- "arg(): could not convert default argument 'a: NotRegistered' in function 'should_fail' "
- "into a Python object (type not registered yet?)"
- if debug_enabled else
- "arg(): could not convert default argument into a Python object (type not registered "
- "yet?). Compile in debug mode for more information."
- )
-
- with pytest.raises(RuntimeError) as excinfo:
- bad_arg_def_unnamed()
- assert msg(excinfo.value) == (
- "arg(): could not convert default argument 'NotRegistered' in function 'should_fail' "
- "into a Python object (type not registered yet?)"
- if debug_enabled else
- "arg(): could not convert default argument into a Python object (type not registered "
- "yet?). Compile in debug mode for more information."
- )
diff --git a/thirdparty/pybind11/pybind11/tests/test_modules.cpp b/thirdparty/pybind11/pybind11/tests/test_modules.cpp
deleted file mode 100644
index 50c7d8412c0e4a4fff93233ed6c072023aac2d11..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_modules.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- tests/test_modules.cpp -- nested modules, importing modules, and
- internal references
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include "constructor_stats.h"
-
-std::string submodule_func() {
- return "submodule_func()";
-}
-
-class A {
-public:
- A(int v) : v(v) { print_created(this, v); }
- ~A() { print_destroyed(this); }
- A(const A&) { print_copy_created(this); }
- A& operator=(const A ©) { print_copy_assigned(this); v = copy.v; return *this; }
- std::string toString() { return "A[" + std::to_string(v) + "]"; }
-private:
- int v;
-};
-
-class B {
-public:
- B() { print_default_created(this); }
- ~B() { print_destroyed(this); }
- B(const B&) { print_copy_created(this); }
- B& operator=(const B ©) { print_copy_assigned(this); a1 = copy.a1; a2 = copy.a2; return *this; }
- A &get_a1() { return a1; }
- A &get_a2() { return a2; }
-
- A a1{1};
- A a2{2};
-};
-
-test_initializer modules([](py::module &m) {
- py::module m_sub = m.def_submodule("submodule");
- m_sub.def("submodule_func", &submodule_func);
-
- py::class_<A>(m_sub, "A")
- .def(py::init<int>())
- .def("__repr__", &A::toString);
-
- py::class_<B>(m_sub, "B")
- .def(py::init<>())
- .def("get_a1", &B::get_a1, "Return the internal A 1", py::return_value_policy::reference_internal)
- .def("get_a2", &B::get_a2, "Return the internal A 2", py::return_value_policy::reference_internal)
- .def_readwrite("a1", &B::a1) // def_readonly uses an internal reference return policy by default
- .def_readwrite("a2", &B::a2);
-
- m.attr("OD") = py::module::import("collections").attr("OrderedDict");
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_modules.py b/thirdparty/pybind11/pybind11/tests/test_modules.py
deleted file mode 100644
index 69620949b9612d97051b70fc8b1ff14c8729faa6..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_modules.py
+++ /dev/null
@@ -1,62 +0,0 @@
-
-def test_nested_modules():
- import pybind11_tests
- from pybind11_tests.submodule import submodule_func
-
- assert pybind11_tests.__name__ == "pybind11_tests"
- assert pybind11_tests.submodule.__name__ == "pybind11_tests.submodule"
-
- assert submodule_func() == "submodule_func()"
-
-
-def test_reference_internal():
- from pybind11_tests import ConstructorStats
- from pybind11_tests.submodule import A, B
-
- b = B()
- assert str(b.get_a1()) == "A[1]"
- assert str(b.a1) == "A[1]"
- assert str(b.get_a2()) == "A[2]"
- assert str(b.a2) == "A[2]"
-
- b.a1 = A(42)
- b.a2 = A(43)
- assert str(b.get_a1()) == "A[42]"
- assert str(b.a1) == "A[42]"
- assert str(b.get_a2()) == "A[43]"
- assert str(b.a2) == "A[43]"
-
- astats, bstats = ConstructorStats.get(A), ConstructorStats.get(B)
- assert astats.alive() == 2
- assert bstats.alive() == 1
- del b
- assert astats.alive() == 0
- assert bstats.alive() == 0
- assert astats.values() == ['1', '2', '42', '43']
- assert bstats.values() == []
- assert astats.default_constructions == 0
- assert bstats.default_constructions == 1
- assert astats.copy_constructions == 0
- assert bstats.copy_constructions == 0
- # assert astats.move_constructions >= 0 # Don't invoke any
- # assert bstats.move_constructions >= 0 # Don't invoke any
- assert astats.copy_assignments == 2
- assert bstats.copy_assignments == 0
- assert astats.move_assignments == 0
- assert bstats.move_assignments == 0
-
-
-def test_importing():
- from pybind11_tests import OD
- from collections import OrderedDict
-
- assert OD is OrderedDict
- assert str(OD([(1, 'a'), (2, 'b')])) == "OrderedDict([(1, 'a'), (2, 'b')])"
-
-
-def test_pydoc():
- """Pydoc needs to be able to provide help() for everything inside a pybind11 module"""
- import pybind11_tests
- import pydoc
-
- assert pydoc.text.docmodule(pybind11_tests)
diff --git a/thirdparty/pybind11/pybind11/tests/test_multiple_inheritance.cpp b/thirdparty/pybind11/pybind11/tests/test_multiple_inheritance.cpp
deleted file mode 100644
index 3ebeb202be54a235fb5daaafde08e29a48b568c8..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_multiple_inheritance.cpp
+++ /dev/null
@@ -1,162 +0,0 @@
-/*
- tests/test_multiple_inheritance.cpp -- multiple inheritance,
- implicit MI casts
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-struct Base1 {
- Base1(int i) : i(i) { }
- int foo() { return i; }
- int i;
-};
-
-struct Base2 {
- Base2(int i) : i(i) { }
- int bar() { return i; }
- int i;
-};
-
-struct Base12 : Base1, Base2 {
- Base12(int i, int j) : Base1(i), Base2(j) { }
-};
-
-struct MIType : Base12 {
- MIType(int i, int j) : Base12(i, j) { }
-};
-
-test_initializer multiple_inheritance([](py::module &m) {
- py::class_<Base1> b1(m, "Base1");
- b1.def(py::init<int>())
- .def("foo", &Base1::foo);
-
- py::class_<Base2> b2(m, "Base2");
- b2.def(py::init<int>())
- .def("bar", &Base2::bar);
-
- py::class_<Base12, Base1, Base2>(m, "Base12");
-
- py::class_<MIType, Base12>(m, "MIType")
- .def(py::init<int, int>());
-
- // Uncommenting this should result in a compile time failure (MI can only be specified via
- // template parameters because pybind has to know the types involved; see discussion in #742 for
- // details).
-// struct Base12v2 : Base1, Base2 {
-// Base12v2(int i, int j) : Base1(i), Base2(j) { }
-// };
-// py::class_<Base12v2>(m, "Base12v2", b1, b2)
-// .def(py::init<int, int>());
-});
-
-/* Test the case where not all base classes are specified,
- and where pybind11 requires the py::multiple_inheritance
- flag to perform proper casting between types */
-
-struct Base1a {
- Base1a(int i) : i(i) { }
- int foo() { return i; }
- int i;
-};
-
-struct Base2a {
- Base2a(int i) : i(i) { }
- int bar() { return i; }
- int i;
-};
-
-struct Base12a : Base1a, Base2a {
- Base12a(int i, int j) : Base1a(i), Base2a(j) { }
-};
-
-test_initializer multiple_inheritance_nonexplicit([](py::module &m) {
- py::class_<Base1a, std::shared_ptr<Base1a>>(m, "Base1a")
- .def(py::init<int>())
- .def("foo", &Base1a::foo);
-
- py::class_<Base2a, std::shared_ptr<Base2a>>(m, "Base2a")
- .def(py::init<int>())
- .def("bar", &Base2a::bar);
-
- py::class_<Base12a, /* Base1 missing */ Base2a,
- std::shared_ptr<Base12a>>(m, "Base12a", py::multiple_inheritance())
- .def(py::init<int, int>());
-
- m.def("bar_base2a", [](Base2a *b) { return b->bar(); });
- m.def("bar_base2a_sharedptr", [](std::shared_ptr<Base2a> b) { return b->bar(); });
-});
-
-struct Vanilla {
- std::string vanilla() { return "Vanilla"; };
-};
-
-struct WithStatic1 {
- static std::string static_func1() { return "WithStatic1"; };
- static int static_value1;
-};
-
-struct WithStatic2 {
- static std::string static_func2() { return "WithStatic2"; };
- static int static_value2;
-};
-
-struct WithDict { };
-
-struct VanillaStaticMix1 : Vanilla, WithStatic1, WithStatic2 {
- static std::string static_func() { return "VanillaStaticMix1"; }
- static int static_value;
-};
-
-struct VanillaStaticMix2 : WithStatic1, Vanilla, WithStatic2 {
- static std::string static_func() { return "VanillaStaticMix2"; }
- static int static_value;
-};
-
-struct VanillaDictMix1 : Vanilla, WithDict { };
-struct VanillaDictMix2 : WithDict, Vanilla { };
-
-int WithStatic1::static_value1 = 1;
-int WithStatic2::static_value2 = 2;
-int VanillaStaticMix1::static_value = 12;
-int VanillaStaticMix2::static_value = 12;
-
-test_initializer mi_static_properties([](py::module &pm) {
- auto m = pm.def_submodule("mi");
-
- py::class_<Vanilla>(m, "Vanilla")
- .def(py::init<>())
- .def("vanilla", &Vanilla::vanilla);
-
- py::class_<WithStatic1>(m, "WithStatic1")
- .def(py::init<>())
- .def_static("static_func1", &WithStatic1::static_func1)
- .def_readwrite_static("static_value1", &WithStatic1::static_value1);
-
- py::class_<WithStatic2>(m, "WithStatic2")
- .def(py::init<>())
- .def_static("static_func2", &WithStatic2::static_func2)
- .def_readwrite_static("static_value2", &WithStatic2::static_value2);
-
- py::class_<VanillaStaticMix1, Vanilla, WithStatic1, WithStatic2>(
- m, "VanillaStaticMix1")
- .def(py::init<>())
- .def_static("static_func", &VanillaStaticMix1::static_func)
- .def_readwrite_static("static_value", &VanillaStaticMix1::static_value);
-
- py::class_<VanillaStaticMix2, WithStatic1, Vanilla, WithStatic2>(
- m, "VanillaStaticMix2")
- .def(py::init<>())
- .def_static("static_func", &VanillaStaticMix2::static_func)
- .def_readwrite_static("static_value", &VanillaStaticMix2::static_value);
-
-#if !defined(PYPY_VERSION)
- py::class_<WithDict>(m, "WithDict", py::dynamic_attr()).def(py::init<>());
- py::class_<VanillaDictMix1, Vanilla, WithDict>(m, "VanillaDictMix1").def(py::init<>());
- py::class_<VanillaDictMix2, WithDict, Vanilla>(m, "VanillaDictMix2").def(py::init<>());
-#endif
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_multiple_inheritance.py b/thirdparty/pybind11/pybind11/tests/test_multiple_inheritance.py
deleted file mode 100644
index 7aaab7cd0d8326e68a9b9369c3dec945143f0453..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_multiple_inheritance.py
+++ /dev/null
@@ -1,111 +0,0 @@
-import pytest
-
-
-def test_multiple_inheritance_cpp():
- from pybind11_tests import MIType
-
- mt = MIType(3, 4)
-
- assert mt.foo() == 3
- assert mt.bar() == 4
-
-
-def test_multiple_inheritance_mix1():
- from pybind11_tests import Base2
-
- class Base1:
- def __init__(self, i):
- self.i = i
-
- def foo(self):
- return self.i
-
- class MITypePy(Base1, Base2):
- def __init__(self, i, j):
- Base1.__init__(self, i)
- Base2.__init__(self, j)
-
- mt = MITypePy(3, 4)
-
- assert mt.foo() == 3
- assert mt.bar() == 4
-
-
-def test_multiple_inheritance_mix2():
- from pybind11_tests import Base1
-
- class Base2:
- def __init__(self, i):
- self.i = i
-
- def bar(self):
- return self.i
-
- class MITypePy(Base1, Base2):
- def __init__(self, i, j):
- Base1.__init__(self, i)
- Base2.__init__(self, j)
-
- mt = MITypePy(3, 4)
-
- assert mt.foo() == 3
- assert mt.bar() == 4
-
-
-def test_multiple_inheritance_error():
- """Inheriting from multiple C++ bases in Python is not supported"""
- from pybind11_tests import Base1, Base2
-
- with pytest.raises(TypeError) as excinfo:
- # noinspection PyUnusedLocal
- class MI(Base1, Base2):
- pass
- assert "Can't inherit from multiple C++ classes in Python" in str(excinfo.value)
-
-
-def test_multiple_inheritance_virtbase():
- from pybind11_tests import Base12a, bar_base2a, bar_base2a_sharedptr
-
- class MITypePy(Base12a):
- def __init__(self, i, j):
- Base12a.__init__(self, i, j)
-
- mt = MITypePy(3, 4)
- assert mt.bar() == 4
- assert bar_base2a(mt) == 4
- assert bar_base2a_sharedptr(mt) == 4
-
-
-def test_mi_static_properties():
- """Mixing bases with and without static properties should be possible
- and the result should be independent of base definition order"""
- from pybind11_tests import mi
-
- for d in (mi.VanillaStaticMix1(), mi.VanillaStaticMix2()):
- assert d.vanilla() == "Vanilla"
- assert d.static_func1() == "WithStatic1"
- assert d.static_func2() == "WithStatic2"
- assert d.static_func() == d.__class__.__name__
-
- mi.WithStatic1.static_value1 = 1
- mi.WithStatic2.static_value2 = 2
- assert d.static_value1 == 1
- assert d.static_value2 == 2
- assert d.static_value == 12
-
- d.static_value1 = 0
- assert d.static_value1 == 0
- d.static_value2 = 0
- assert d.static_value2 == 0
- d.static_value = 0
- assert d.static_value == 0
-
-
-@pytest.unsupported_on_pypy
-def test_mi_dynamic_attributes():
- """Mixing bases with and without dynamic attribute support"""
- from pybind11_tests import mi
-
- for d in (mi.VanillaDictMix1(), mi.VanillaDictMix2()):
- d.dynamic = 1
- assert d.dynamic == 1
diff --git a/thirdparty/pybind11/pybind11/tests/test_numpy_array.cpp b/thirdparty/pybind11/pybind11/tests/test_numpy_array.cpp
deleted file mode 100644
index cd6487249b2593085cbd9b470366eb3fd1f0658b..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_numpy_array.cpp
+++ /dev/null
@@ -1,267 +0,0 @@
-/*
- tests/test_numpy_array.cpp -- test core array functionality
-
- Copyright (c) 2016 Ivan Smirnov <i.s.smirnov@gmail.com>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-#include <pybind11/numpy.h>
-#include <pybind11/stl.h>
-
-#include <cstdint>
-#include <vector>
-
-using arr = py::array;
-using arr_t = py::array_t<uint16_t, 0>;
-static_assert(std::is_same<arr_t::value_type, uint16_t>::value, "");
-
-template<typename... Ix> arr data(const arr& a, Ix... index) {
- return arr(a.nbytes() - a.offset_at(index...), (const uint8_t *) a.data(index...));
-}
-
-template<typename... Ix> arr data_t(const arr_t& a, Ix... index) {
- return arr(a.size() - a.index_at(index...), a.data(index...));
-}
-
-arr& mutate_data(arr& a) {
- auto ptr = (uint8_t *) a.mutable_data();
- for (size_t i = 0; i < a.nbytes(); i++)
- ptr[i] = (uint8_t) (ptr[i] * 2);
- return a;
-}
-
-arr_t& mutate_data_t(arr_t& a) {
- auto ptr = a.mutable_data();
- for (size_t i = 0; i < a.size(); i++)
- ptr[i]++;
- return a;
-}
-
-template<typename... Ix> arr& mutate_data(arr& a, Ix... index) {
- auto ptr = (uint8_t *) a.mutable_data(index...);
- for (size_t i = 0; i < a.nbytes() - a.offset_at(index...); i++)
- ptr[i] = (uint8_t) (ptr[i] * 2);
- return a;
-}
-
-template<typename... Ix> arr_t& mutate_data_t(arr_t& a, Ix... index) {
- auto ptr = a.mutable_data(index...);
- for (size_t i = 0; i < a.size() - a.index_at(index...); i++)
- ptr[i]++;
- return a;
-}
-
-template<typename... Ix> size_t index_at(const arr& a, Ix... idx) { return a.index_at(idx...); }
-template<typename... Ix> size_t index_at_t(const arr_t& a, Ix... idx) { return a.index_at(idx...); }
-template<typename... Ix> size_t offset_at(const arr& a, Ix... idx) { return a.offset_at(idx...); }
-template<typename... Ix> size_t offset_at_t(const arr_t& a, Ix... idx) { return a.offset_at(idx...); }
-template<typename... Ix> size_t at_t(const arr_t& a, Ix... idx) { return a.at(idx...); }
-template<typename... Ix> arr_t& mutate_at_t(arr_t& a, Ix... idx) { a.mutable_at(idx...)++; return a; }
-
-#define def_index_fn(name, type) \
- sm.def(#name, [](type a) { return name(a); }); \
- sm.def(#name, [](type a, int i) { return name(a, i); }); \
- sm.def(#name, [](type a, int i, int j) { return name(a, i, j); }); \
- sm.def(#name, [](type a, int i, int j, int k) { return name(a, i, j, k); });
-
-template <typename T, typename T2> py::handle auxiliaries(T &&r, T2 &&r2) {
- if (r.ndim() != 2) throw std::domain_error("error: ndim != 2");
- py::list l;
- l.append(*r.data(0, 0));
- l.append(*r2.mutable_data(0, 0));
- l.append(r.data(0, 1) == r2.mutable_data(0, 1));
- l.append(r.ndim());
- l.append(r.itemsize());
- l.append(r.shape(0));
- l.append(r.shape(1));
- l.append(r.size());
- l.append(r.nbytes());
- return l.release();
-}
-
-test_initializer numpy_array([](py::module &m) {
- auto sm = m.def_submodule("array");
-
- sm.def("ndim", [](const arr& a) { return a.ndim(); });
- sm.def("shape", [](const arr& a) { return arr(a.ndim(), a.shape()); });
- sm.def("shape", [](const arr& a, size_t dim) { return a.shape(dim); });
- sm.def("strides", [](const arr& a) { return arr(a.ndim(), a.strides()); });
- sm.def("strides", [](const arr& a, size_t dim) { return a.strides(dim); });
- sm.def("writeable", [](const arr& a) { return a.writeable(); });
- sm.def("size", [](const arr& a) { return a.size(); });
- sm.def("itemsize", [](const arr& a) { return a.itemsize(); });
- sm.def("nbytes", [](const arr& a) { return a.nbytes(); });
- sm.def("owndata", [](const arr& a) { return a.owndata(); });
-
- def_index_fn(data, const arr&);
- def_index_fn(data_t, const arr_t&);
- def_index_fn(index_at, const arr&);
- def_index_fn(index_at_t, const arr_t&);
- def_index_fn(offset_at, const arr&);
- def_index_fn(offset_at_t, const arr_t&);
- def_index_fn(mutate_data, arr&);
- def_index_fn(mutate_data_t, arr_t&);
- def_index_fn(at_t, const arr_t&);
- def_index_fn(mutate_at_t, arr_t&);
-
- sm.def("make_f_array", [] {
- return py::array_t<float>({ 2, 2 }, { 4, 8 });
- });
-
- sm.def("make_c_array", [] {
- return py::array_t<float>({ 2, 2 }, { 8, 4 });
- });
-
- sm.def("wrap", [](py::array a) {
- return py::array(
- a.dtype(),
- std::vector<size_t>(a.shape(), a.shape() + a.ndim()),
- std::vector<size_t>(a.strides(), a.strides() + a.ndim()),
- a.data(),
- a
- );
- });
-
- struct ArrayClass {
- int data[2] = { 1, 2 };
- ArrayClass() { py::print("ArrayClass()"); }
- ~ArrayClass() { py::print("~ArrayClass()"); }
- };
-
- py::class_<ArrayClass>(sm, "ArrayClass")
- .def(py::init<>())
- .def("numpy_view", [](py::object &obj) {
- py::print("ArrayClass::numpy_view()");
- ArrayClass &a = obj.cast<ArrayClass&>();
- return py::array_t<int>({2}, {4}, a.data, obj);
- }
- );
-
- sm.def("function_taking_uint64", [](uint64_t) { });
-
- sm.def("isinstance_untyped", [](py::object yes, py::object no) {
- return py::isinstance<py::array>(yes) && !py::isinstance<py::array>(no);
- });
-
- sm.def("isinstance_typed", [](py::object o) {
- return py::isinstance<py::array_t<double>>(o) && !py::isinstance<py::array_t<int>>(o);
- });
-
- sm.def("default_constructors", []() {
- return py::dict(
- "array"_a=py::array(),
- "array_t<int32>"_a=py::array_t<std::int32_t>(),
- "array_t<double>"_a=py::array_t<double>()
- );
- });
-
- sm.def("converting_constructors", [](py::object o) {
- return py::dict(
- "array"_a=py::array(o),
- "array_t<int32>"_a=py::array_t<std::int32_t>(o),
- "array_t<double>"_a=py::array_t<double>(o)
- );
- });
-
- // Overload resolution tests:
- sm.def("overloaded", [](py::array_t<double>) { return "double"; });
- sm.def("overloaded", [](py::array_t<float>) { return "float"; });
- sm.def("overloaded", [](py::array_t<int>) { return "int"; });
- sm.def("overloaded", [](py::array_t<unsigned short>) { return "unsigned short"; });
- sm.def("overloaded", [](py::array_t<long long>) { return "long long"; });
- sm.def("overloaded", [](py::array_t<std::complex<double>>) { return "double complex"; });
- sm.def("overloaded", [](py::array_t<std::complex<float>>) { return "float complex"; });
-
- sm.def("overloaded2", [](py::array_t<std::complex<double>>) { return "double complex"; });
- sm.def("overloaded2", [](py::array_t<double>) { return "double"; });
- sm.def("overloaded2", [](py::array_t<std::complex<float>>) { return "float complex"; });
- sm.def("overloaded2", [](py::array_t<float>) { return "float"; });
-
- // Only accept the exact types:
- sm.def("overloaded3", [](py::array_t<int>) { return "int"; }, py::arg().noconvert());
- sm.def("overloaded3", [](py::array_t<double>) { return "double"; }, py::arg().noconvert());
-
- // Make sure we don't do unsafe coercion (e.g. float to int) when not using forcecast, but
- // rather that float gets converted via the safe (conversion to double) overload:
- sm.def("overloaded4", [](py::array_t<long long, 0>) { return "long long"; });
- sm.def("overloaded4", [](py::array_t<double, 0>) { return "double"; });
-
- // But we do allow conversion to int if forcecast is enabled (but only if no overload matches
- // without conversion)
- sm.def("overloaded5", [](py::array_t<unsigned int>) { return "unsigned int"; });
- sm.def("overloaded5", [](py::array_t<double>) { return "double"; });
-
- // Issue 685: ndarray shouldn't go to std::string overload
- sm.def("issue685", [](std::string) { return "string"; });
- sm.def("issue685", [](py::array) { return "array"; });
- sm.def("issue685", [](py::object) { return "other"; });
-
- sm.def("proxy_add2", [](py::array_t<double> a, double v) {
- auto r = a.mutable_unchecked<2>();
- for (size_t i = 0; i < r.shape(0); i++)
- for (size_t j = 0; j < r.shape(1); j++)
- r(i, j) += v;
- }, py::arg().noconvert(), py::arg());
-
- sm.def("proxy_init3", [](double start) {
- py::array_t<double, py::array::c_style> a({ 3, 3, 3 });
- auto r = a.mutable_unchecked<3>();
- for (size_t i = 0; i < r.shape(0); i++)
- for (size_t j = 0; j < r.shape(1); j++)
- for (size_t k = 0; k < r.shape(2); k++)
- r(i, j, k) = start++;
- return a;
- });
- sm.def("proxy_init3F", [](double start) {
- py::array_t<double, py::array::f_style> a({ 3, 3, 3 });
- auto r = a.mutable_unchecked<3>();
- for (size_t k = 0; k < r.shape(2); k++)
- for (size_t j = 0; j < r.shape(1); j++)
- for (size_t i = 0; i < r.shape(0); i++)
- r(i, j, k) = start++;
- return a;
- });
- sm.def("proxy_squared_L2_norm", [](py::array_t<double> a) {
- auto r = a.unchecked<1>();
- double sumsq = 0;
- for (size_t i = 0; i < r.shape(0); i++)
- sumsq += r[i] * r(i); // Either notation works for a 1D array
- return sumsq;
- });
-
- sm.def("proxy_auxiliaries2", [](py::array_t<double> a) {
- auto r = a.unchecked<2>();
- auto r2 = a.mutable_unchecked<2>();
- return auxiliaries(r, r2);
- });
-
- // Same as the above, but without a compile-time dimensions specification:
- sm.def("proxy_add2_dyn", [](py::array_t<double> a, double v) {
- auto r = a.mutable_unchecked();
- if (r.ndim() != 2) throw std::domain_error("error: ndim != 2");
- for (size_t i = 0; i < r.shape(0); i++)
- for (size_t j = 0; j < r.shape(1); j++)
- r(i, j) += v;
- }, py::arg().noconvert(), py::arg());
- sm.def("proxy_init3_dyn", [](double start) {
- py::array_t<double, py::array::c_style> a({ 3, 3, 3 });
- auto r = a.mutable_unchecked();
- if (r.ndim() != 3) throw std::domain_error("error: ndim != 3");
- for (size_t i = 0; i < r.shape(0); i++)
- for (size_t j = 0; j < r.shape(1); j++)
- for (size_t k = 0; k < r.shape(2); k++)
- r(i, j, k) = start++;
- return a;
- });
- sm.def("proxy_auxiliaries2_dyn", [](py::array_t<double> a) {
- return auxiliaries(a.unchecked(), a.mutable_unchecked());
- });
-
- sm.def("array_auxiliaries2", [](py::array_t<double> a) {
- return auxiliaries(a, a);
- });
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_numpy_array.py b/thirdparty/pybind11/pybind11/tests/test_numpy_array.py
deleted file mode 100644
index 14c25b3714a0dbf1c5debd0cfc6d775f9fb34dd8..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_numpy_array.py
+++ /dev/null
@@ -1,379 +0,0 @@
-import pytest
-
-pytestmark = pytest.requires_numpy
-
-with pytest.suppress(ImportError):
- import numpy as np
-
-
-@pytest.fixture(scope='function')
-def arr():
- return np.array([[1, 2, 3], [4, 5, 6]], '=u2')
-
-
-def test_array_attributes():
- from pybind11_tests.array import (
- ndim, shape, strides, writeable, size, itemsize, nbytes, owndata
- )
-
- a = np.array(0, 'f8')
- assert ndim(a) == 0
- assert all(shape(a) == [])
- assert all(strides(a) == [])
- with pytest.raises(IndexError) as excinfo:
- shape(a, 0)
- assert str(excinfo.value) == 'invalid axis: 0 (ndim = 0)'
- with pytest.raises(IndexError) as excinfo:
- strides(a, 0)
- assert str(excinfo.value) == 'invalid axis: 0 (ndim = 0)'
- assert writeable(a)
- assert size(a) == 1
- assert itemsize(a) == 8
- assert nbytes(a) == 8
- assert owndata(a)
-
- a = np.array([[1, 2, 3], [4, 5, 6]], 'u2').view()
- a.flags.writeable = False
- assert ndim(a) == 2
- assert all(shape(a) == [2, 3])
- assert shape(a, 0) == 2
- assert shape(a, 1) == 3
- assert all(strides(a) == [6, 2])
- assert strides(a, 0) == 6
- assert strides(a, 1) == 2
- with pytest.raises(IndexError) as excinfo:
- shape(a, 2)
- assert str(excinfo.value) == 'invalid axis: 2 (ndim = 2)'
- with pytest.raises(IndexError) as excinfo:
- strides(a, 2)
- assert str(excinfo.value) == 'invalid axis: 2 (ndim = 2)'
- assert not writeable(a)
- assert size(a) == 6
- assert itemsize(a) == 2
- assert nbytes(a) == 12
- assert not owndata(a)
-
-
-@pytest.mark.parametrize('args, ret', [([], 0), ([0], 0), ([1], 3), ([0, 1], 1), ([1, 2], 5)])
-def test_index_offset(arr, args, ret):
- from pybind11_tests.array import index_at, index_at_t, offset_at, offset_at_t
- assert index_at(arr, *args) == ret
- assert index_at_t(arr, *args) == ret
- assert offset_at(arr, *args) == ret * arr.dtype.itemsize
- assert offset_at_t(arr, *args) == ret * arr.dtype.itemsize
-
-
-def test_dim_check_fail(arr):
- from pybind11_tests.array import (index_at, index_at_t, offset_at, offset_at_t, data, data_t,
- mutate_data, mutate_data_t)
- for func in (index_at, index_at_t, offset_at, offset_at_t, data, data_t,
- mutate_data, mutate_data_t):
- with pytest.raises(IndexError) as excinfo:
- func(arr, 1, 2, 3)
- assert str(excinfo.value) == 'too many indices for an array: 3 (ndim = 2)'
-
-
-@pytest.mark.parametrize('args, ret',
- [([], [1, 2, 3, 4, 5, 6]),
- ([1], [4, 5, 6]),
- ([0, 1], [2, 3, 4, 5, 6]),
- ([1, 2], [6])])
-def test_data(arr, args, ret):
- from pybind11_tests.array import data, data_t
- from sys import byteorder
- assert all(data_t(arr, *args) == ret)
- assert all(data(arr, *args)[(0 if byteorder == 'little' else 1)::2] == ret)
- assert all(data(arr, *args)[(1 if byteorder == 'little' else 0)::2] == 0)
-
-
-def test_mutate_readonly(arr):
- from pybind11_tests.array import mutate_data, mutate_data_t, mutate_at_t
- arr.flags.writeable = False
- for func, args in (mutate_data, ()), (mutate_data_t, ()), (mutate_at_t, (0, 0)):
- with pytest.raises(ValueError) as excinfo:
- func(arr, *args)
- assert str(excinfo.value) == 'array is not writeable'
-
-
-@pytest.mark.parametrize('dim', [0, 1, 3])
-def test_at_fail(arr, dim):
- from pybind11_tests.array import at_t, mutate_at_t
- for func in at_t, mutate_at_t:
- with pytest.raises(IndexError) as excinfo:
- func(arr, *([0] * dim))
- assert str(excinfo.value) == 'index dimension mismatch: {} (ndim = 2)'.format(dim)
-
-
-def test_at(arr):
- from pybind11_tests.array import at_t, mutate_at_t
-
- assert at_t(arr, 0, 2) == 3
- assert at_t(arr, 1, 0) == 4
-
- assert all(mutate_at_t(arr, 0, 2).ravel() == [1, 2, 4, 4, 5, 6])
- assert all(mutate_at_t(arr, 1, 0).ravel() == [1, 2, 4, 5, 5, 6])
-
-
-def test_mutate_data(arr):
- from pybind11_tests.array import mutate_data, mutate_data_t
-
- assert all(mutate_data(arr).ravel() == [2, 4, 6, 8, 10, 12])
- assert all(mutate_data(arr).ravel() == [4, 8, 12, 16, 20, 24])
- assert all(mutate_data(arr, 1).ravel() == [4, 8, 12, 32, 40, 48])
- assert all(mutate_data(arr, 0, 1).ravel() == [4, 16, 24, 64, 80, 96])
- assert all(mutate_data(arr, 1, 2).ravel() == [4, 16, 24, 64, 80, 192])
-
- assert all(mutate_data_t(arr).ravel() == [5, 17, 25, 65, 81, 193])
- assert all(mutate_data_t(arr).ravel() == [6, 18, 26, 66, 82, 194])
- assert all(mutate_data_t(arr, 1).ravel() == [6, 18, 26, 67, 83, 195])
- assert all(mutate_data_t(arr, 0, 1).ravel() == [6, 19, 27, 68, 84, 196])
- assert all(mutate_data_t(arr, 1, 2).ravel() == [6, 19, 27, 68, 84, 197])
-
-
-def test_bounds_check(arr):
- from pybind11_tests.array import (index_at, index_at_t, data, data_t,
- mutate_data, mutate_data_t, at_t, mutate_at_t)
- funcs = (index_at, index_at_t, data, data_t,
- mutate_data, mutate_data_t, at_t, mutate_at_t)
- for func in funcs:
- with pytest.raises(IndexError) as excinfo:
- func(arr, 2, 0)
- assert str(excinfo.value) == 'index 2 is out of bounds for axis 0 with size 2'
- with pytest.raises(IndexError) as excinfo:
- func(arr, 0, 4)
- assert str(excinfo.value) == 'index 4 is out of bounds for axis 1 with size 3'
-
-
-def test_make_c_f_array():
- from pybind11_tests.array import (
- make_c_array, make_f_array
- )
- assert make_c_array().flags.c_contiguous
- assert not make_c_array().flags.f_contiguous
- assert make_f_array().flags.f_contiguous
- assert not make_f_array().flags.c_contiguous
-
-
-def test_wrap():
- from pybind11_tests.array import wrap
-
- def assert_references(a, b, base=None):
- if base is None:
- base = a
- assert a is not b
- assert a.__array_interface__['data'][0] == b.__array_interface__['data'][0]
- assert a.shape == b.shape
- assert a.strides == b.strides
- assert a.flags.c_contiguous == b.flags.c_contiguous
- assert a.flags.f_contiguous == b.flags.f_contiguous
- assert a.flags.writeable == b.flags.writeable
- assert a.flags.aligned == b.flags.aligned
- assert a.flags.updateifcopy == b.flags.updateifcopy
- assert np.all(a == b)
- assert not b.flags.owndata
- assert b.base is base
- if a.flags.writeable and a.ndim == 2:
- a[0, 0] = 1234
- assert b[0, 0] == 1234
-
- a1 = np.array([1, 2], dtype=np.int16)
- assert a1.flags.owndata and a1.base is None
- a2 = wrap(a1)
- assert_references(a1, a2)
-
- a1 = np.array([[1, 2], [3, 4]], dtype=np.float32, order='F')
- assert a1.flags.owndata and a1.base is None
- a2 = wrap(a1)
- assert_references(a1, a2)
-
- a1 = np.array([[1, 2], [3, 4]], dtype=np.float32, order='C')
- a1.flags.writeable = False
- a2 = wrap(a1)
- assert_references(a1, a2)
-
- a1 = np.random.random((4, 4, 4))
- a2 = wrap(a1)
- assert_references(a1, a2)
-
- a1t = a1.transpose()
- a2 = wrap(a1t)
- assert_references(a1t, a2, a1)
-
- a1d = a1.diagonal()
- a2 = wrap(a1d)
- assert_references(a1d, a2, a1)
-
-
-def test_numpy_view(capture):
- from pybind11_tests.array import ArrayClass
- with capture:
- ac = ArrayClass()
- ac_view_1 = ac.numpy_view()
- ac_view_2 = ac.numpy_view()
- assert np.all(ac_view_1 == np.array([1, 2], dtype=np.int32))
- del ac
- pytest.gc_collect()
- assert capture == """
- ArrayClass()
- ArrayClass::numpy_view()
- ArrayClass::numpy_view()
- """
- ac_view_1[0] = 4
- ac_view_1[1] = 3
- assert ac_view_2[0] == 4
- assert ac_view_2[1] == 3
- with capture:
- del ac_view_1
- del ac_view_2
- pytest.gc_collect()
- pytest.gc_collect()
- assert capture == """
- ~ArrayClass()
- """
-
-
-@pytest.unsupported_on_pypy
-def test_cast_numpy_int64_to_uint64():
- from pybind11_tests.array import function_taking_uint64
- function_taking_uint64(123)
- function_taking_uint64(np.uint64(123))
-
-
-def test_isinstance():
- from pybind11_tests.array import isinstance_untyped, isinstance_typed
-
- assert isinstance_untyped(np.array([1, 2, 3]), "not an array")
- assert isinstance_typed(np.array([1.0, 2.0, 3.0]))
-
-
-def test_constructors():
- from pybind11_tests.array import default_constructors, converting_constructors
-
- defaults = default_constructors()
- for a in defaults.values():
- assert a.size == 0
- assert defaults["array"].dtype == np.array([]).dtype
- assert defaults["array_t<int32>"].dtype == np.int32
- assert defaults["array_t<double>"].dtype == np.float64
-
- results = converting_constructors([1, 2, 3])
- for a in results.values():
- np.testing.assert_array_equal(a, [1, 2, 3])
- assert results["array"].dtype == np.int_
- assert results["array_t<int32>"].dtype == np.int32
- assert results["array_t<double>"].dtype == np.float64
-
-
-def test_overload_resolution(msg):
- from pybind11_tests.array import overloaded, overloaded2, overloaded3, overloaded4, overloaded5
-
- # Exact overload matches:
- assert overloaded(np.array([1], dtype='float64')) == 'double'
- assert overloaded(np.array([1], dtype='float32')) == 'float'
- assert overloaded(np.array([1], dtype='ushort')) == 'unsigned short'
- assert overloaded(np.array([1], dtype='intc')) == 'int'
- assert overloaded(np.array([1], dtype='longlong')) == 'long long'
- assert overloaded(np.array([1], dtype='complex')) == 'double complex'
- assert overloaded(np.array([1], dtype='csingle')) == 'float complex'
-
- # No exact match, should call first convertible version:
- assert overloaded(np.array([1], dtype='uint8')) == 'double'
-
- with pytest.raises(TypeError) as excinfo:
- overloaded("not an array")
- assert msg(excinfo.value) == """
- overloaded(): incompatible function arguments. The following argument types are supported:
- 1. (arg0: numpy.ndarray[float64]) -> str
- 2. (arg0: numpy.ndarray[float32]) -> str
- 3. (arg0: numpy.ndarray[int32]) -> str
- 4. (arg0: numpy.ndarray[uint16]) -> str
- 5. (arg0: numpy.ndarray[int64]) -> str
- 6. (arg0: numpy.ndarray[complex128]) -> str
- 7. (arg0: numpy.ndarray[complex64]) -> str
-
- Invoked with: 'not an array'
- """
-
- assert overloaded2(np.array([1], dtype='float64')) == 'double'
- assert overloaded2(np.array([1], dtype='float32')) == 'float'
- assert overloaded2(np.array([1], dtype='complex64')) == 'float complex'
- assert overloaded2(np.array([1], dtype='complex128')) == 'double complex'
- assert overloaded2(np.array([1], dtype='float32')) == 'float'
-
- assert overloaded3(np.array([1], dtype='float64')) == 'double'
- assert overloaded3(np.array([1], dtype='intc')) == 'int'
- expected_exc = """
- overloaded3(): incompatible function arguments. The following argument types are supported:
- 1. (arg0: numpy.ndarray[int32]) -> str
- 2. (arg0: numpy.ndarray[float64]) -> str
-
- Invoked with:"""
-
- with pytest.raises(TypeError) as excinfo:
- overloaded3(np.array([1], dtype='uintc'))
- assert msg(excinfo.value) == expected_exc + " array([1], dtype=uint32)"
- with pytest.raises(TypeError) as excinfo:
- overloaded3(np.array([1], dtype='float32'))
- assert msg(excinfo.value) == expected_exc + " array([ 1.], dtype=float32)"
- with pytest.raises(TypeError) as excinfo:
- overloaded3(np.array([1], dtype='complex'))
- assert msg(excinfo.value) == expected_exc + " array([ 1.+0.j])"
-
- # Exact matches:
- assert overloaded4(np.array([1], dtype='double')) == 'double'
- assert overloaded4(np.array([1], dtype='longlong')) == 'long long'
- # Non-exact matches requiring conversion. Since float to integer isn't a
- # save conversion, it should go to the double overload, but short can go to
- # either (and so should end up on the first-registered, the long long).
- assert overloaded4(np.array([1], dtype='float32')) == 'double'
- assert overloaded4(np.array([1], dtype='short')) == 'long long'
-
- assert overloaded5(np.array([1], dtype='double')) == 'double'
- assert overloaded5(np.array([1], dtype='uintc')) == 'unsigned int'
- assert overloaded5(np.array([1], dtype='float32')) == 'unsigned int'
-
-
-def test_greedy_string_overload(): # issue 685
- from pybind11_tests.array import issue685
-
- assert issue685("abc") == "string"
- assert issue685(np.array([97, 98, 99], dtype='b')) == "array"
- assert issue685(123) == "other"
-
-
-def test_array_unchecked_fixed_dims(msg):
- from pybind11_tests.array import (proxy_add2, proxy_init3F, proxy_init3, proxy_squared_L2_norm,
- proxy_auxiliaries2, array_auxiliaries2)
-
- z1 = np.array([[1, 2], [3, 4]], dtype='float64')
- proxy_add2(z1, 10)
- assert np.all(z1 == [[11, 12], [13, 14]])
-
- with pytest.raises(ValueError) as excinfo:
- proxy_add2(np.array([1., 2, 3]), 5.0)
- assert msg(excinfo.value) == "array has incorrect number of dimensions: 1; expected 2"
-
- expect_c = np.ndarray(shape=(3, 3, 3), buffer=np.array(range(3, 30)), dtype='int')
- assert np.all(proxy_init3(3.0) == expect_c)
- expect_f = np.transpose(expect_c)
- assert np.all(proxy_init3F(3.0) == expect_f)
-
- assert proxy_squared_L2_norm(np.array(range(6))) == 55
- assert proxy_squared_L2_norm(np.array(range(6), dtype="float64")) == 55
-
- assert proxy_auxiliaries2(z1) == [11, 11, True, 2, 8, 2, 2, 4, 32]
- assert proxy_auxiliaries2(z1) == array_auxiliaries2(z1)
-
-
-def test_array_unchecked_dyn_dims(msg):
- from pybind11_tests.array import (proxy_add2_dyn, proxy_init3_dyn, proxy_auxiliaries2_dyn,
- array_auxiliaries2)
- z1 = np.array([[1, 2], [3, 4]], dtype='float64')
- proxy_add2_dyn(z1, 10)
- assert np.all(z1 == [[11, 12], [13, 14]])
-
- expect_c = np.ndarray(shape=(3, 3, 3), buffer=np.array(range(3, 30)), dtype='int')
- assert np.all(proxy_init3_dyn(3.0) == expect_c)
-
- assert proxy_auxiliaries2_dyn(z1) == [11, 11, True, 2, 8, 2, 2, 4, 32]
- assert proxy_auxiliaries2_dyn(z1) == array_auxiliaries2(z1)
diff --git a/thirdparty/pybind11/pybind11/tests/test_numpy_dtypes.cpp b/thirdparty/pybind11/pybind11/tests/test_numpy_dtypes.cpp
deleted file mode 100644
index 1f6c8570433d80e396c4313fab9a6f4ae6b91364..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_numpy_dtypes.cpp
+++ /dev/null
@@ -1,395 +0,0 @@
-/*
- tests/test_numpy_dtypes.cpp -- Structured and compound NumPy dtypes
-
- Copyright (c) 2016 Ivan Smirnov
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include <pybind11/numpy.h>
-
-#ifdef __GNUC__
-#define PYBIND11_PACKED(cls) cls __attribute__((__packed__))
-#else
-#define PYBIND11_PACKED(cls) __pragma(pack(push, 1)) cls __pragma(pack(pop))
-#endif
-
-namespace py = pybind11;
-
-struct SimpleStruct {
- bool bool_;
- uint32_t uint_;
- float float_;
- long double ldbl_;
-};
-
-std::ostream& operator<<(std::ostream& os, const SimpleStruct& v) {
- return os << "s:" << v.bool_ << "," << v.uint_ << "," << v.float_ << "," << v.ldbl_;
-}
-
-PYBIND11_PACKED(struct PackedStruct {
- bool bool_;
- uint32_t uint_;
- float float_;
- long double ldbl_;
-});
-
-std::ostream& operator<<(std::ostream& os, const PackedStruct& v) {
- return os << "p:" << v.bool_ << "," << v.uint_ << "," << v.float_ << "," << v.ldbl_;
-}
-
-PYBIND11_PACKED(struct NestedStruct {
- SimpleStruct a;
- PackedStruct b;
-});
-
-std::ostream& operator<<(std::ostream& os, const NestedStruct& v) {
- return os << "n:a=" << v.a << ";b=" << v.b;
-}
-
-struct PartialStruct {
- bool bool_;
- uint32_t uint_;
- float float_;
- uint64_t dummy2;
- long double ldbl_;
-};
-
-struct PartialNestedStruct {
- uint64_t dummy1;
- PartialStruct a;
- uint64_t dummy2;
-};
-
-struct UnboundStruct { };
-
-struct StringStruct {
- char a[3];
- std::array<char, 3> b;
-};
-
-PYBIND11_PACKED(struct StructWithUglyNames {
- int8_t __x__;
- uint64_t __y__;
-});
-
-enum class E1 : int64_t { A = -1, B = 1 };
-enum E2 : uint8_t { X = 1, Y = 2 };
-
-PYBIND11_PACKED(struct EnumStruct {
- E1 e1;
- E2 e2;
-});
-
-std::ostream& operator<<(std::ostream& os, const StringStruct& v) {
- os << "a='";
- for (size_t i = 0; i < 3 && v.a[i]; i++) os << v.a[i];
- os << "',b='";
- for (size_t i = 0; i < 3 && v.b[i]; i++) os << v.b[i];
- return os << "'";
-}
-
-std::ostream& operator<<(std::ostream& os, const EnumStruct& v) {
- return os << "e1=" << (v.e1 == E1::A ? "A" : "B") << ",e2=" << (v.e2 == E2::X ? "X" : "Y");
-}
-
-template <typename T>
-py::array mkarray_via_buffer(size_t n) {
- return py::array(py::buffer_info(nullptr, sizeof(T),
- py::format_descriptor<T>::format(),
- 1, { n }, { sizeof(T) }));
-}
-
-#define SET_TEST_VALS(s, i) do { \
- s.bool_ = (i) % 2 != 0; \
- s.uint_ = (uint32_t) (i); \
- s.float_ = (float) (i) * 1.5f; \
- s.ldbl_ = (long double) (i) * -2.5L; } while (0)
-
-template <typename S>
-py::array_t<S, 0> create_recarray(size_t n) {
- auto arr = mkarray_via_buffer<S>(n);
- auto req = arr.request();
- auto ptr = static_cast<S*>(req.ptr);
- for (size_t i = 0; i < n; i++) {
- SET_TEST_VALS(ptr[i], i);
- }
- return arr;
-}
-
-std::string get_format_unbound() {
- return py::format_descriptor<UnboundStruct>::format();
-}
-
-py::array_t<NestedStruct, 0> create_nested(size_t n) {
- auto arr = mkarray_via_buffer<NestedStruct>(n);
- auto req = arr.request();
- auto ptr = static_cast<NestedStruct*>(req.ptr);
- for (size_t i = 0; i < n; i++) {
- SET_TEST_VALS(ptr[i].a, i);
- SET_TEST_VALS(ptr[i].b, i + 1);
- }
- return arr;
-}
-
-py::array_t<PartialNestedStruct, 0> create_partial_nested(size_t n) {
- auto arr = mkarray_via_buffer<PartialNestedStruct>(n);
- auto req = arr.request();
- auto ptr = static_cast<PartialNestedStruct*>(req.ptr);
- for (size_t i = 0; i < n; i++) {
- SET_TEST_VALS(ptr[i].a, i);
- }
- return arr;
-}
-
-py::array_t<StringStruct, 0> create_string_array(bool non_empty) {
- auto arr = mkarray_via_buffer<StringStruct>(non_empty ? 4 : 0);
- if (non_empty) {
- auto req = arr.request();
- auto ptr = static_cast<StringStruct*>(req.ptr);
- for (size_t i = 0; i < req.size * req.itemsize; i++)
- static_cast<char*>(req.ptr)[i] = 0;
- ptr[1].a[0] = 'a'; ptr[1].b[0] = 'a';
- ptr[2].a[0] = 'a'; ptr[2].b[0] = 'a';
- ptr[3].a[0] = 'a'; ptr[3].b[0] = 'a';
-
- ptr[2].a[1] = 'b'; ptr[2].b[1] = 'b';
- ptr[3].a[1] = 'b'; ptr[3].b[1] = 'b';
-
- ptr[3].a[2] = 'c'; ptr[3].b[2] = 'c';
- }
- return arr;
-}
-
-py::array_t<EnumStruct, 0> create_enum_array(size_t n) {
- auto arr = mkarray_via_buffer<EnumStruct>(n);
- auto ptr = (EnumStruct *) arr.mutable_data();
- for (size_t i = 0; i < n; i++) {
- ptr[i].e1 = static_cast<E1>(-1 + ((int) i % 2) * 2);
- ptr[i].e2 = static_cast<E2>(1 + (i % 2));
- }
- return arr;
-}
-
-template <typename S>
-py::list print_recarray(py::array_t<S, 0> arr) {
- const auto req = arr.request();
- const auto ptr = static_cast<S*>(req.ptr);
- auto l = py::list();
- for (size_t i = 0; i < req.size; i++) {
- std::stringstream ss;
- ss << ptr[i];
- l.append(py::str(ss.str()));
- }
- return l;
-}
-
-py::list print_format_descriptors() {
- const auto fmts = {
- py::format_descriptor<SimpleStruct>::format(),
- py::format_descriptor<PackedStruct>::format(),
- py::format_descriptor<NestedStruct>::format(),
- py::format_descriptor<PartialStruct>::format(),
- py::format_descriptor<PartialNestedStruct>::format(),
- py::format_descriptor<StringStruct>::format(),
- py::format_descriptor<EnumStruct>::format()
- };
- auto l = py::list();
- for (const auto &fmt : fmts) {
- l.append(py::cast(fmt));
- }
- return l;
-}
-
-py::list print_dtypes() {
- const auto dtypes = {
- py::str(py::dtype::of<SimpleStruct>()),
- py::str(py::dtype::of<PackedStruct>()),
- py::str(py::dtype::of<NestedStruct>()),
- py::str(py::dtype::of<PartialStruct>()),
- py::str(py::dtype::of<PartialNestedStruct>()),
- py::str(py::dtype::of<StringStruct>()),
- py::str(py::dtype::of<EnumStruct>()),
- py::str(py::dtype::of<StructWithUglyNames>())
- };
- auto l = py::list();
- for (const auto &s : dtypes) {
- l.append(s);
- }
- return l;
-}
-
-py::array_t<int32_t, 0> test_array_ctors(int i) {
- using arr_t = py::array_t<int32_t, 0>;
-
- std::vector<int32_t> data { 1, 2, 3, 4, 5, 6 };
- std::vector<size_t> shape { 3, 2 };
- std::vector<size_t> strides { 8, 4 };
-
- auto ptr = data.data();
- auto vptr = (void *) ptr;
- auto dtype = py::dtype("int32");
-
- py::buffer_info buf_ndim1(vptr, 4, "i", 6);
- py::buffer_info buf_ndim1_null(nullptr, 4, "i", 6);
- py::buffer_info buf_ndim2(vptr, 4, "i", 2, shape, strides);
- py::buffer_info buf_ndim2_null(nullptr, 4, "i", 2, shape, strides);
-
- auto fill = [](py::array arr) {
- auto req = arr.request();
- for (int i = 0; i < 6; i++) ((int32_t *) req.ptr)[i] = i + 1;
- return arr;
- };
-
- switch (i) {
- // shape: (3, 2)
- case 10: return arr_t(shape, strides, ptr);
- case 11: return py::array(shape, strides, ptr);
- case 12: return py::array(dtype, shape, strides, vptr);
- case 13: return arr_t(shape, ptr);
- case 14: return py::array(shape, ptr);
- case 15: return py::array(dtype, shape, vptr);
- case 16: return arr_t(buf_ndim2);
- case 17: return py::array(buf_ndim2);
- // shape: (3, 2) - post-fill
- case 20: return fill(arr_t(shape, strides));
- case 21: return py::array(shape, strides, ptr); // can't have nullptr due to templated ctor
- case 22: return fill(py::array(dtype, shape, strides));
- case 23: return fill(arr_t(shape));
- case 24: return py::array(shape, ptr); // can't have nullptr due to templated ctor
- case 25: return fill(py::array(dtype, shape));
- case 26: return fill(arr_t(buf_ndim2_null));
- case 27: return fill(py::array(buf_ndim2_null));
- // shape: (6, )
- case 30: return arr_t(6, ptr);
- case 31: return py::array(6, ptr);
- case 32: return py::array(dtype, 6, vptr);
- case 33: return arr_t(buf_ndim1);
- case 34: return py::array(buf_ndim1);
- // shape: (6, )
- case 40: return fill(arr_t(6));
- case 41: return py::array(6, ptr); // can't have nullptr due to templated ctor
- case 42: return fill(py::array(dtype, 6));
- case 43: return fill(arr_t(buf_ndim1_null));
- case 44: return fill(py::array(buf_ndim1_null));
- }
- return arr_t();
-}
-
-py::list test_dtype_ctors() {
- py::list list;
- list.append(py::dtype("int32"));
- list.append(py::dtype(std::string("float64")));
- list.append(py::dtype::from_args(py::str("bool")));
- py::list names, offsets, formats;
- py::dict dict;
- names.append(py::str("a")); names.append(py::str("b")); dict["names"] = names;
- offsets.append(py::int_(1)); offsets.append(py::int_(10)); dict["offsets"] = offsets;
- formats.append(py::dtype("int32")); formats.append(py::dtype("float64")); dict["formats"] = formats;
- dict["itemsize"] = py::int_(20);
- list.append(py::dtype::from_args(dict));
- list.append(py::dtype(names, formats, offsets, 20));
- list.append(py::dtype(py::buffer_info((void *) 0, sizeof(unsigned int), "I", 1)));
- list.append(py::dtype(py::buffer_info((void *) 0, 0, "T{i:a:f:b:}", 1)));
- return list;
-}
-
-struct TrailingPaddingStruct {
- int32_t a;
- char b;
-};
-
-py::dtype trailing_padding_dtype() {
- return py::dtype::of<TrailingPaddingStruct>();
-}
-
-py::dtype buffer_to_dtype(py::buffer& buf) {
- return py::dtype(buf.request());
-}
-
-py::list test_dtype_methods() {
- py::list list;
- auto dt1 = py::dtype::of<int32_t>();
- auto dt2 = py::dtype::of<SimpleStruct>();
- list.append(dt1); list.append(dt2);
- list.append(py::bool_(dt1.has_fields())); list.append(py::bool_(dt2.has_fields()));
- list.append(py::int_(dt1.itemsize())); list.append(py::int_(dt2.itemsize()));
- return list;
-}
-
-struct CompareStruct {
- bool x;
- uint32_t y;
- float z;
-};
-
-py::list test_compare_buffer_info() {
- py::list list;
- list.append(py::bool_(py::detail::compare_buffer_info<float>::compare(py::buffer_info(nullptr, sizeof(float), "f", 1))));
- list.append(py::bool_(py::detail::compare_buffer_info<unsigned>::compare(py::buffer_info(nullptr, sizeof(int), "I", 1))));
- list.append(py::bool_(py::detail::compare_buffer_info<long>::compare(py::buffer_info(nullptr, sizeof(long), "l", 1))));
- list.append(py::bool_(py::detail::compare_buffer_info<long>::compare(py::buffer_info(nullptr, sizeof(long), sizeof(long) == sizeof(int) ? "i" : "q", 1))));
- list.append(py::bool_(py::detail::compare_buffer_info<CompareStruct>::compare(py::buffer_info(nullptr, sizeof(CompareStruct), "T{?:x:3xI:y:f:z:}", 1))));
- return list;
-}
-
-test_initializer numpy_dtypes([](py::module &m) {
- try {
- py::module::import("numpy");
- } catch (...) {
- return;
- }
-
- // typeinfo may be registered before the dtype descriptor for scalar casts to work...
- py::class_<SimpleStruct>(m, "SimpleStruct");
-
- PYBIND11_NUMPY_DTYPE(SimpleStruct, bool_, uint_, float_, ldbl_);
- PYBIND11_NUMPY_DTYPE(PackedStruct, bool_, uint_, float_, ldbl_);
- PYBIND11_NUMPY_DTYPE(NestedStruct, a, b);
- PYBIND11_NUMPY_DTYPE(PartialStruct, bool_, uint_, float_, ldbl_);
- PYBIND11_NUMPY_DTYPE(PartialNestedStruct, a);
- PYBIND11_NUMPY_DTYPE(StringStruct, a, b);
- PYBIND11_NUMPY_DTYPE(EnumStruct, e1, e2);
- PYBIND11_NUMPY_DTYPE(TrailingPaddingStruct, a, b);
- PYBIND11_NUMPY_DTYPE(CompareStruct, x, y, z);
-
- // ... or after
- py::class_<PackedStruct>(m, "PackedStruct");
-
- PYBIND11_NUMPY_DTYPE_EX(StructWithUglyNames, __x__, "x", __y__, "y");
-
- // If uncommented, this should produce a static_assert failure telling the user that the struct
- // is not a POD type
-// struct NotPOD { std::string v; NotPOD() : v("hi") {}; };
-// PYBIND11_NUMPY_DTYPE(NotPOD, v);
-
- m.def("create_rec_simple", &create_recarray<SimpleStruct>);
- m.def("create_rec_packed", &create_recarray<PackedStruct>);
- m.def("create_rec_nested", &create_nested);
- m.def("create_rec_partial", &create_recarray<PartialStruct>);
- m.def("create_rec_partial_nested", &create_partial_nested);
- m.def("print_format_descriptors", &print_format_descriptors);
- m.def("print_rec_simple", &print_recarray<SimpleStruct>);
- m.def("print_rec_packed", &print_recarray<PackedStruct>);
- m.def("print_rec_nested", &print_recarray<NestedStruct>);
- m.def("print_dtypes", &print_dtypes);
- m.def("get_format_unbound", &get_format_unbound);
- m.def("create_string_array", &create_string_array);
- m.def("print_string_array", &print_recarray<StringStruct>);
- m.def("create_enum_array", &create_enum_array);
- m.def("print_enum_array", &print_recarray<EnumStruct>);
- m.def("test_array_ctors", &test_array_ctors);
- m.def("test_dtype_ctors", &test_dtype_ctors);
- m.def("test_dtype_methods", &test_dtype_methods);
- m.def("compare_buffer_info", &test_compare_buffer_info);
- m.def("trailing_padding_dtype", &trailing_padding_dtype);
- m.def("buffer_to_dtype", &buffer_to_dtype);
- m.def("f_simple", [](SimpleStruct s) { return s.uint_ * 10; });
- m.def("f_packed", [](PackedStruct s) { return s.uint_ * 10; });
- m.def("f_nested", [](NestedStruct s) { return s.a.uint_ * 10; });
- m.def("register_dtype", []() { PYBIND11_NUMPY_DTYPE(SimpleStruct, bool_, uint_, float_, ldbl_); });
-});
-
-#undef PYBIND11_PACKED
diff --git a/thirdparty/pybind11/pybind11/tests/test_numpy_dtypes.py b/thirdparty/pybind11/pybind11/tests/test_numpy_dtypes.py
deleted file mode 100644
index f63814f9da1eeccb200ca670578439fa058a308c..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_numpy_dtypes.py
+++ /dev/null
@@ -1,272 +0,0 @@
-import re
-import pytest
-
-pytestmark = pytest.requires_numpy
-
-with pytest.suppress(ImportError):
- import numpy as np
-
-
-@pytest.fixture(scope='module')
-def simple_dtype():
- ld = np.dtype('longdouble')
- return np.dtype({'names': ['bool_', 'uint_', 'float_', 'ldbl_'],
- 'formats': ['?', 'u4', 'f4', 'f{}'.format(ld.itemsize)],
- 'offsets': [0, 4, 8, (16 if ld.alignment > 4 else 12)]})
-
-
-@pytest.fixture(scope='module')
-def packed_dtype():
- return np.dtype([('bool_', '?'), ('uint_', 'u4'), ('float_', 'f4'), ('ldbl_', 'g')])
-
-
-def dt_fmt():
- from sys import byteorder
- e = '<' if byteorder == 'little' else '>'
- return ("{{'names':['bool_','uint_','float_','ldbl_'],"
- " 'formats':['?','" + e + "u4','" + e + "f4','" + e + "f{}'],"
- " 'offsets':[0,4,8,{}], 'itemsize':{}}}")
-
-
-def simple_dtype_fmt():
- ld = np.dtype('longdouble')
- simple_ld_off = 12 + 4 * (ld.alignment > 4)
- return dt_fmt().format(ld.itemsize, simple_ld_off, simple_ld_off + ld.itemsize)
-
-
-def packed_dtype_fmt():
- from sys import byteorder
- return "[('bool_', '?'), ('uint_', '{e}u4'), ('float_', '{e}f4'), ('ldbl_', '{e}f{}')]".format(
- np.dtype('longdouble').itemsize, e='<' if byteorder == 'little' else '>')
-
-
-def partial_ld_offset():
- return 12 + 4 * (np.dtype('uint64').alignment > 4) + 8 + 8 * (
- np.dtype('longdouble').alignment > 8)
-
-
-def partial_dtype_fmt():
- ld = np.dtype('longdouble')
- partial_ld_off = partial_ld_offset()
- return dt_fmt().format(ld.itemsize, partial_ld_off, partial_ld_off + ld.itemsize)
-
-
-def partial_nested_fmt():
- ld = np.dtype('longdouble')
- partial_nested_off = 8 + 8 * (ld.alignment > 8)
- partial_ld_off = partial_ld_offset()
- partial_nested_size = partial_nested_off * 2 + partial_ld_off + ld.itemsize
- return "{{'names':['a'], 'formats':[{}], 'offsets':[{}], 'itemsize':{}}}".format(
- partial_dtype_fmt(), partial_nested_off, partial_nested_size)
-
-
-def assert_equal(actual, expected_data, expected_dtype):
- np.testing.assert_equal(actual, np.array(expected_data, dtype=expected_dtype))
-
-
-def test_format_descriptors():
- from pybind11_tests import get_format_unbound, print_format_descriptors
-
- with pytest.raises(RuntimeError) as excinfo:
- get_format_unbound()
- assert re.match('^NumPy type info missing for .*UnboundStruct.*$', str(excinfo.value))
-
- ld = np.dtype('longdouble')
- ldbl_fmt = ('4x' if ld.alignment > 4 else '') + ld.char
- ss_fmt = "T{?:bool_:3xI:uint_:f:float_:" + ldbl_fmt + ":ldbl_:}"
- dbl = np.dtype('double')
- partial_fmt = ("T{?:bool_:3xI:uint_:f:float_:" +
- str(4 * (dbl.alignment > 4) + dbl.itemsize + 8 * (ld.alignment > 8)) +
- "xg:ldbl_:}")
- nested_extra = str(max(8, ld.alignment))
- assert print_format_descriptors() == [
- ss_fmt,
- "T{?:bool_:^I:uint_:^f:float_:^g:ldbl_:}",
- "T{" + ss_fmt + ":a:T{?:bool_:^I:uint_:^f:float_:^g:ldbl_:}:b:}",
- partial_fmt,
- "T{" + nested_extra + "x" + partial_fmt + ":a:" + nested_extra + "x}",
- "T{3s:a:3s:b:}",
- 'T{q:e1:B:e2:}'
- ]
-
-
-def test_dtype(simple_dtype):
- from pybind11_tests import (print_dtypes, test_dtype_ctors, test_dtype_methods,
- trailing_padding_dtype, buffer_to_dtype)
- from sys import byteorder
- e = '<' if byteorder == 'little' else '>'
-
- assert print_dtypes() == [
- simple_dtype_fmt(),
- packed_dtype_fmt(),
- "[('a', {}), ('b', {})]".format(simple_dtype_fmt(), packed_dtype_fmt()),
- partial_dtype_fmt(),
- partial_nested_fmt(),
- "[('a', 'S3'), ('b', 'S3')]",
- "[('e1', '" + e + "i8'), ('e2', 'u1')]",
- "[('x', 'i1'), ('y', '" + e + "u8')]"
- ]
-
- d1 = np.dtype({'names': ['a', 'b'], 'formats': ['int32', 'float64'],
- 'offsets': [1, 10], 'itemsize': 20})
- d2 = np.dtype([('a', 'i4'), ('b', 'f4')])
- assert test_dtype_ctors() == [np.dtype('int32'), np.dtype('float64'),
- np.dtype('bool'), d1, d1, np.dtype('uint32'), d2]
-
- assert test_dtype_methods() == [np.dtype('int32'), simple_dtype, False, True,
- np.dtype('int32').itemsize, simple_dtype.itemsize]
-
- assert trailing_padding_dtype() == buffer_to_dtype(np.zeros(1, trailing_padding_dtype()))
-
-
-def test_recarray(simple_dtype, packed_dtype):
- from pybind11_tests import (create_rec_simple, create_rec_packed, create_rec_nested,
- print_rec_simple, print_rec_packed, print_rec_nested,
- create_rec_partial, create_rec_partial_nested)
-
- elements = [(False, 0, 0.0, -0.0), (True, 1, 1.5, -2.5), (False, 2, 3.0, -5.0)]
-
- for func, dtype in [(create_rec_simple, simple_dtype), (create_rec_packed, packed_dtype)]:
- arr = func(0)
- assert arr.dtype == dtype
- assert_equal(arr, [], simple_dtype)
- assert_equal(arr, [], packed_dtype)
-
- arr = func(3)
- assert arr.dtype == dtype
- assert_equal(arr, elements, simple_dtype)
- assert_equal(arr, elements, packed_dtype)
-
- if dtype == simple_dtype:
- assert print_rec_simple(arr) == [
- "s:0,0,0,-0",
- "s:1,1,1.5,-2.5",
- "s:0,2,3,-5"
- ]
- else:
- assert print_rec_packed(arr) == [
- "p:0,0,0,-0",
- "p:1,1,1.5,-2.5",
- "p:0,2,3,-5"
- ]
-
- nested_dtype = np.dtype([('a', simple_dtype), ('b', packed_dtype)])
-
- arr = create_rec_nested(0)
- assert arr.dtype == nested_dtype
- assert_equal(arr, [], nested_dtype)
-
- arr = create_rec_nested(3)
- assert arr.dtype == nested_dtype
- assert_equal(arr, [((False, 0, 0.0, -0.0), (True, 1, 1.5, -2.5)),
- ((True, 1, 1.5, -2.5), (False, 2, 3.0, -5.0)),
- ((False, 2, 3.0, -5.0), (True, 3, 4.5, -7.5))], nested_dtype)
- assert print_rec_nested(arr) == [
- "n:a=s:0,0,0,-0;b=p:1,1,1.5,-2.5",
- "n:a=s:1,1,1.5,-2.5;b=p:0,2,3,-5",
- "n:a=s:0,2,3,-5;b=p:1,3,4.5,-7.5"
- ]
-
- arr = create_rec_partial(3)
- assert str(arr.dtype) == partial_dtype_fmt()
- partial_dtype = arr.dtype
- assert '' not in arr.dtype.fields
- assert partial_dtype.itemsize > simple_dtype.itemsize
- assert_equal(arr, elements, simple_dtype)
- assert_equal(arr, elements, packed_dtype)
-
- arr = create_rec_partial_nested(3)
- assert str(arr.dtype) == partial_nested_fmt()
- assert '' not in arr.dtype.fields
- assert '' not in arr.dtype.fields['a'][0].fields
- assert arr.dtype.itemsize > partial_dtype.itemsize
- np.testing.assert_equal(arr['a'], create_rec_partial(3))
-
-
-def test_array_constructors():
- from pybind11_tests import test_array_ctors
-
- data = np.arange(1, 7, dtype='int32')
- for i in range(8):
- np.testing.assert_array_equal(test_array_ctors(10 + i), data.reshape((3, 2)))
- np.testing.assert_array_equal(test_array_ctors(20 + i), data.reshape((3, 2)))
- for i in range(5):
- np.testing.assert_array_equal(test_array_ctors(30 + i), data)
- np.testing.assert_array_equal(test_array_ctors(40 + i), data)
-
-
-def test_string_array():
- from pybind11_tests import create_string_array, print_string_array
-
- arr = create_string_array(True)
- assert str(arr.dtype) == "[('a', 'S3'), ('b', 'S3')]"
- assert print_string_array(arr) == [
- "a='',b=''",
- "a='a',b='a'",
- "a='ab',b='ab'",
- "a='abc',b='abc'"
- ]
- dtype = arr.dtype
- assert arr['a'].tolist() == [b'', b'a', b'ab', b'abc']
- assert arr['b'].tolist() == [b'', b'a', b'ab', b'abc']
- arr = create_string_array(False)
- assert dtype == arr.dtype
-
-
-def test_enum_array():
- from pybind11_tests import create_enum_array, print_enum_array
- from sys import byteorder
- e = '<' if byteorder == 'little' else '>'
-
- arr = create_enum_array(3)
- dtype = arr.dtype
- assert dtype == np.dtype([('e1', e + 'i8'), ('e2', 'u1')])
- assert print_enum_array(arr) == [
- "e1=A,e2=X",
- "e1=B,e2=Y",
- "e1=A,e2=X"
- ]
- assert arr['e1'].tolist() == [-1, 1, -1]
- assert arr['e2'].tolist() == [1, 2, 1]
- assert create_enum_array(0).dtype == dtype
-
-
-def test_signature(doc):
- from pybind11_tests import create_rec_nested
-
- assert doc(create_rec_nested) == "create_rec_nested(arg0: int) -> numpy.ndarray[NestedStruct]"
-
-
-def test_scalar_conversion():
- from pybind11_tests import (create_rec_simple, f_simple,
- create_rec_packed, f_packed,
- create_rec_nested, f_nested,
- create_enum_array)
-
- n = 3
- arrays = [create_rec_simple(n), create_rec_packed(n),
- create_rec_nested(n), create_enum_array(n)]
- funcs = [f_simple, f_packed, f_nested]
-
- for i, func in enumerate(funcs):
- for j, arr in enumerate(arrays):
- if i == j and i < 2:
- assert [func(arr[k]) for k in range(n)] == [k * 10 for k in range(n)]
- else:
- with pytest.raises(TypeError) as excinfo:
- func(arr[0])
- assert 'incompatible function arguments' in str(excinfo.value)
-
-
-def test_register_dtype():
- from pybind11_tests import register_dtype
-
- with pytest.raises(RuntimeError) as excinfo:
- register_dtype()
- assert 'dtype is already registered' in str(excinfo.value)
-
-
-@pytest.requires_numpy
-def test_compare_buffer_info():
- from pybind11_tests import compare_buffer_info
- assert all(compare_buffer_info())
diff --git a/thirdparty/pybind11/pybind11/tests/test_numpy_vectorize.cpp b/thirdparty/pybind11/pybind11/tests/test_numpy_vectorize.cpp
deleted file mode 100644
index 8e951c6e1579ad0f32b85b53b567b63b58b268f4..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_numpy_vectorize.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- tests/test_numpy_vectorize.cpp -- auto-vectorize functions over NumPy array
- arguments
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include <pybind11/numpy.h>
-
-double my_func(int x, float y, double z) {
- py::print("my_func(x:int={}, y:float={:.0f}, z:float={:.0f})"_s.format(x, y, z));
- return (float) x*y*z;
-}
-
-std::complex<double> my_func3(std::complex<double> c) {
- return c * std::complex<double>(2.f);
-}
-
-test_initializer numpy_vectorize([](py::module &m) {
- // Vectorize all arguments of a function (though non-vector arguments are also allowed)
- m.def("vectorized_func", py::vectorize(my_func));
-
- // Vectorize a lambda function with a capture object (e.g. to exclude some arguments from the vectorization)
- m.def("vectorized_func2",
- [](py::array_t<int> x, py::array_t<float> y, float z) {
- return py::vectorize([z](int x, float y) { return my_func(x, y, z); })(x, y);
- }
- );
-
- // Vectorize a complex-valued function
- m.def("vectorized_func3", py::vectorize(my_func3));
-
- /// Numpy function which only accepts specific data types
- m.def("selective_func", [](py::array_t<int, py::array::c_style>) { return "Int branch taken."; });
- m.def("selective_func", [](py::array_t<float, py::array::c_style>) { return "Float branch taken."; });
- m.def("selective_func", [](py::array_t<std::complex<float>, py::array::c_style>) { return "Complex float branch taken."; });
-
-
- // Internal optimization test for whether the input is trivially broadcastable:
- py::enum_<py::detail::broadcast_trivial>(m, "trivial")
- .value("f_trivial", py::detail::broadcast_trivial::f_trivial)
- .value("c_trivial", py::detail::broadcast_trivial::c_trivial)
- .value("non_trivial", py::detail::broadcast_trivial::non_trivial);
- m.def("vectorized_is_trivial", [](
- py::array_t<int, py::array::forcecast> arg1,
- py::array_t<float, py::array::forcecast> arg2,
- py::array_t<double, py::array::forcecast> arg3
- ) {
- size_t ndim;
- std::vector<size_t> shape;
- std::array<py::buffer_info, 3> buffers {{ arg1.request(), arg2.request(), arg3.request() }};
- return py::detail::broadcast(buffers, ndim, shape);
- });
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_numpy_vectorize.py b/thirdparty/pybind11/pybind11/tests/test_numpy_vectorize.py
deleted file mode 100644
index 7ae777227d6646b5124535a50a56e37fc0827e7a..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_numpy_vectorize.py
+++ /dev/null
@@ -1,161 +0,0 @@
-import pytest
-
-pytestmark = pytest.requires_numpy
-
-with pytest.suppress(ImportError):
- import numpy as np
-
-
-def test_vectorize(capture):
- from pybind11_tests import vectorized_func, vectorized_func2, vectorized_func3
-
- assert np.isclose(vectorized_func3(np.array(3 + 7j)), [6 + 14j])
-
- for f in [vectorized_func, vectorized_func2]:
- with capture:
- assert np.isclose(f(1, 2, 3), 6)
- assert capture == "my_func(x:int=1, y:float=2, z:float=3)"
- with capture:
- assert np.isclose(f(np.array(1), np.array(2), 3), 6)
- assert capture == "my_func(x:int=1, y:float=2, z:float=3)"
- with capture:
- assert np.allclose(f(np.array([1, 3]), np.array([2, 4]), 3), [6, 36])
- assert capture == """
- my_func(x:int=1, y:float=2, z:float=3)
- my_func(x:int=3, y:float=4, z:float=3)
- """
- with capture:
- a = np.array([[1, 2], [3, 4]], order='F')
- b = np.array([[10, 20], [30, 40]], order='F')
- c = 3
- result = f(a, b, c)
- assert np.allclose(result, a * b * c)
- assert result.flags.f_contiguous
- # All inputs are F order and full or singletons, so we the result is in col-major order:
- assert capture == """
- my_func(x:int=1, y:float=10, z:float=3)
- my_func(x:int=3, y:float=30, z:float=3)
- my_func(x:int=2, y:float=20, z:float=3)
- my_func(x:int=4, y:float=40, z:float=3)
- """
- with capture:
- a, b, c = np.array([[1, 3, 5], [7, 9, 11]]), np.array([[2, 4, 6], [8, 10, 12]]), 3
- assert np.allclose(f(a, b, c), a * b * c)
- assert capture == """
- my_func(x:int=1, y:float=2, z:float=3)
- my_func(x:int=3, y:float=4, z:float=3)
- my_func(x:int=5, y:float=6, z:float=3)
- my_func(x:int=7, y:float=8, z:float=3)
- my_func(x:int=9, y:float=10, z:float=3)
- my_func(x:int=11, y:float=12, z:float=3)
- """
- with capture:
- a, b, c = np.array([[1, 2, 3], [4, 5, 6]]), np.array([2, 3, 4]), 2
- assert np.allclose(f(a, b, c), a * b * c)
- assert capture == """
- my_func(x:int=1, y:float=2, z:float=2)
- my_func(x:int=2, y:float=3, z:float=2)
- my_func(x:int=3, y:float=4, z:float=2)
- my_func(x:int=4, y:float=2, z:float=2)
- my_func(x:int=5, y:float=3, z:float=2)
- my_func(x:int=6, y:float=4, z:float=2)
- """
- with capture:
- a, b, c = np.array([[1, 2, 3], [4, 5, 6]]), np.array([[2], [3]]), 2
- assert np.allclose(f(a, b, c), a * b * c)
- assert capture == """
- my_func(x:int=1, y:float=2, z:float=2)
- my_func(x:int=2, y:float=2, z:float=2)
- my_func(x:int=3, y:float=2, z:float=2)
- my_func(x:int=4, y:float=3, z:float=2)
- my_func(x:int=5, y:float=3, z:float=2)
- my_func(x:int=6, y:float=3, z:float=2)
- """
- with capture:
- a, b, c = np.array([[1, 2, 3], [4, 5, 6]], order='F'), np.array([[2], [3]]), 2
- assert np.allclose(f(a, b, c), a * b * c)
- assert capture == """
- my_func(x:int=1, y:float=2, z:float=2)
- my_func(x:int=2, y:float=2, z:float=2)
- my_func(x:int=3, y:float=2, z:float=2)
- my_func(x:int=4, y:float=3, z:float=2)
- my_func(x:int=5, y:float=3, z:float=2)
- my_func(x:int=6, y:float=3, z:float=2)
- """
- with capture:
- a, b, c = np.array([[1, 2, 3], [4, 5, 6]])[::, ::2], np.array([[2], [3]]), 2
- assert np.allclose(f(a, b, c), a * b * c)
- assert capture == """
- my_func(x:int=1, y:float=2, z:float=2)
- my_func(x:int=3, y:float=2, z:float=2)
- my_func(x:int=4, y:float=3, z:float=2)
- my_func(x:int=6, y:float=3, z:float=2)
- """
- with capture:
- a, b, c = np.array([[1, 2, 3], [4, 5, 6]], order='F')[::, ::2], np.array([[2], [3]]), 2
- assert np.allclose(f(a, b, c), a * b * c)
- assert capture == """
- my_func(x:int=1, y:float=2, z:float=2)
- my_func(x:int=3, y:float=2, z:float=2)
- my_func(x:int=4, y:float=3, z:float=2)
- my_func(x:int=6, y:float=3, z:float=2)
- """
-
-
-def test_type_selection():
- from pybind11_tests import selective_func
-
- assert selective_func(np.array([1], dtype=np.int32)) == "Int branch taken."
- assert selective_func(np.array([1.0], dtype=np.float32)) == "Float branch taken."
- assert selective_func(np.array([1.0j], dtype=np.complex64)) == "Complex float branch taken."
-
-
-def test_docs(doc):
- from pybind11_tests import vectorized_func
-
- assert doc(vectorized_func) == """
- vectorized_func(arg0: numpy.ndarray[int32], arg1: numpy.ndarray[float32], arg2: numpy.ndarray[float64]) -> object
- """ # noqa: E501 line too long
-
-
-def test_trivial_broadcasting():
- from pybind11_tests import vectorized_is_trivial, trivial, vectorized_func
-
- assert vectorized_is_trivial(1, 2, 3) == trivial.c_trivial
- assert vectorized_is_trivial(np.array(1), np.array(2), 3) == trivial.c_trivial
- assert vectorized_is_trivial(np.array([1, 3]), np.array([2, 4]), 3) == trivial.c_trivial
- assert trivial.c_trivial == vectorized_is_trivial(
- np.array([[1, 3, 5], [7, 9, 11]]), np.array([[2, 4, 6], [8, 10, 12]]), 3)
- assert vectorized_is_trivial(
- np.array([[1, 2, 3], [4, 5, 6]]), np.array([2, 3, 4]), 2) == trivial.non_trivial
- assert vectorized_is_trivial(
- np.array([[1, 2, 3], [4, 5, 6]]), np.array([[2], [3]]), 2) == trivial.non_trivial
- z1 = np.array([[1, 2, 3, 4], [5, 6, 7, 8]], dtype='int32')
- z2 = np.array(z1, dtype='float32')
- z3 = np.array(z1, dtype='float64')
- assert vectorized_is_trivial(z1, z2, z3) == trivial.c_trivial
- assert vectorized_is_trivial(1, z2, z3) == trivial.c_trivial
- assert vectorized_is_trivial(z1, 1, z3) == trivial.c_trivial
- assert vectorized_is_trivial(z1, z2, 1) == trivial.c_trivial
- assert vectorized_is_trivial(z1[::2, ::2], 1, 1) == trivial.non_trivial
- assert vectorized_is_trivial(1, 1, z1[::2, ::2]) == trivial.c_trivial
- assert vectorized_is_trivial(1, 1, z3[::2, ::2]) == trivial.non_trivial
- assert vectorized_is_trivial(z1, 1, z3[1::4, 1::4]) == trivial.c_trivial
-
- y1 = np.array(z1, order='F')
- y2 = np.array(y1)
- y3 = np.array(y1)
- assert vectorized_is_trivial(y1, y2, y3) == trivial.f_trivial
- assert vectorized_is_trivial(y1, 1, 1) == trivial.f_trivial
- assert vectorized_is_trivial(1, y2, 1) == trivial.f_trivial
- assert vectorized_is_trivial(1, 1, y3) == trivial.f_trivial
- assert vectorized_is_trivial(y1, z2, 1) == trivial.non_trivial
- assert vectorized_is_trivial(z1[1::4, 1::4], y2, 1) == trivial.f_trivial
- assert vectorized_is_trivial(y1[1::4, 1::4], z2, 1) == trivial.c_trivial
-
- assert vectorized_func(z1, z2, z3).flags.c_contiguous
- assert vectorized_func(y1, y2, y3).flags.f_contiguous
- assert vectorized_func(z1, 1, 1).flags.c_contiguous
- assert vectorized_func(1, y2, 1).flags.f_contiguous
- assert vectorized_func(z1[1::4, 1::4], y2, 1).flags.f_contiguous
- assert vectorized_func(y1[1::4, 1::4], z2, 1).flags.c_contiguous
diff --git a/thirdparty/pybind11/pybind11/tests/test_opaque_types.cpp b/thirdparty/pybind11/pybind11/tests/test_opaque_types.cpp
deleted file mode 100644
index 54f4dc7a5d2ba9789b82858e29362b369cefab47..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_opaque_types.cpp
+++ /dev/null
@@ -1,62 +0,0 @@
-/*
- tests/test_opaque_types.cpp -- opaque types, passing void pointers
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include <pybind11/stl.h>
-#include <vector>
-
-typedef std::vector<std::string> StringList;
-
-class ClassWithSTLVecProperty {
-public:
- StringList stringList;
-};
-
-/* IMPORTANT: Disable internal pybind11 translation mechanisms for STL data structures */
-PYBIND11_MAKE_OPAQUE(StringList);
-
-test_initializer opaque_types([](py::module &m) {
- py::class_<StringList>(m, "StringList")
- .def(py::init<>())
- .def("pop_back", &StringList::pop_back)
- /* There are multiple versions of push_back(), etc. Select the right ones. */
- .def("push_back", (void (StringList::*)(const std::string &)) &StringList::push_back)
- .def("back", (std::string &(StringList::*)()) &StringList::back)
- .def("__len__", [](const StringList &v) { return v.size(); })
- .def("__iter__", [](StringList &v) {
- return py::make_iterator(v.begin(), v.end());
- }, py::keep_alive<0, 1>());
-
- py::class_<ClassWithSTLVecProperty>(m, "ClassWithSTLVecProperty")
- .def(py::init<>())
- .def_readwrite("stringList", &ClassWithSTLVecProperty::stringList);
-
- m.def("print_opaque_list", [](const StringList &l) {
- std::string ret = "Opaque list: [";
- bool first = true;
- for (auto entry : l) {
- if (!first)
- ret += ", ";
- ret += entry;
- first = false;
- }
- return ret + "]";
- });
-
- m.def("return_void_ptr", []() { return (void *) 0x1234; });
- m.def("get_void_ptr_value", [](void *ptr) { return reinterpret_cast<std::intptr_t>(ptr); });
- m.def("return_null_str", []() { return (char *) nullptr; });
- m.def("get_null_str_value", [](char *ptr) { return reinterpret_cast<std::intptr_t>(ptr); });
-
- m.def("return_unique_ptr", []() -> std::unique_ptr<StringList> {
- StringList *result = new StringList();
- result->push_back("some value");
- return std::unique_ptr<StringList>(result);
- });
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_opaque_types.py b/thirdparty/pybind11/pybind11/tests/test_opaque_types.py
deleted file mode 100644
index 1cd410208db0d40d6e80580d72e0c40b1293f0bd..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_opaque_types.py
+++ /dev/null
@@ -1,50 +0,0 @@
-import pytest
-
-
-def test_string_list():
- from pybind11_tests import StringList, ClassWithSTLVecProperty, print_opaque_list
-
- l = StringList()
- l.push_back("Element 1")
- l.push_back("Element 2")
- assert print_opaque_list(l) == "Opaque list: [Element 1, Element 2]"
- assert l.back() == "Element 2"
-
- for i, k in enumerate(l, start=1):
- assert k == "Element {}".format(i)
- l.pop_back()
- assert print_opaque_list(l) == "Opaque list: [Element 1]"
-
- cvp = ClassWithSTLVecProperty()
- assert print_opaque_list(cvp.stringList) == "Opaque list: []"
-
- cvp.stringList = l
- cvp.stringList.push_back("Element 3")
- assert print_opaque_list(cvp.stringList) == "Opaque list: [Element 1, Element 3]"
-
-
-def test_pointers(msg):
- from pybind11_tests import (return_void_ptr, get_void_ptr_value, ExampleMandA,
- print_opaque_list, return_null_str, get_null_str_value,
- return_unique_ptr, ConstructorStats)
-
- living_before = ConstructorStats.get(ExampleMandA).alive()
- assert get_void_ptr_value(return_void_ptr()) == 0x1234
- assert get_void_ptr_value(ExampleMandA()) # Should also work for other C++ types
- assert ConstructorStats.get(ExampleMandA).alive() == living_before
-
- with pytest.raises(TypeError) as excinfo:
- get_void_ptr_value([1, 2, 3]) # This should not work
- assert msg(excinfo.value) == """
- get_void_ptr_value(): incompatible function arguments. The following argument types are supported:
- 1. (arg0: capsule) -> int
-
- Invoked with: [1, 2, 3]
- """ # noqa: E501 line too long
-
- assert return_null_str() is None
- assert get_null_str_value(return_null_str()) is not None
-
- ptr = return_unique_ptr()
- assert "StringList" in repr(ptr)
- assert print_opaque_list(ptr) == "Opaque list: [some value]"
diff --git a/thirdparty/pybind11/pybind11/tests/test_operator_overloading.cpp b/thirdparty/pybind11/pybind11/tests/test_operator_overloading.cpp
deleted file mode 100644
index 93aea8010568dec20120ca290356929135a0c2d2..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_operator_overloading.cpp
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
- tests/test_operator_overloading.cpp -- operator overloading
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include "constructor_stats.h"
-#include <pybind11/operators.h>
-
-class Vector2 {
-public:
- Vector2(float x, float y) : x(x), y(y) { print_created(this, toString()); }
- Vector2(const Vector2 &v) : x(v.x), y(v.y) { print_copy_created(this); }
- Vector2(Vector2 &&v) : x(v.x), y(v.y) { print_move_created(this); v.x = v.y = 0; }
- ~Vector2() { print_destroyed(this); }
-
- std::string toString() const {
- return "[" + std::to_string(x) + ", " + std::to_string(y) + "]";
- }
-
- void operator=(const Vector2 &v) {
- print_copy_assigned(this);
- x = v.x;
- y = v.y;
- }
-
- void operator=(Vector2 &&v) {
- print_move_assigned(this);
- x = v.x; y = v.y; v.x = v.y = 0;
- }
-
- Vector2 operator+(const Vector2 &v) const { return Vector2(x + v.x, y + v.y); }
- Vector2 operator-(const Vector2 &v) const { return Vector2(x - v.x, y - v.y); }
- Vector2 operator-(float value) const { return Vector2(x - value, y - value); }
- Vector2 operator+(float value) const { return Vector2(x + value, y + value); }
- Vector2 operator*(float value) const { return Vector2(x * value, y * value); }
- Vector2 operator/(float value) const { return Vector2(x / value, y / value); }
- Vector2& operator+=(const Vector2 &v) { x += v.x; y += v.y; return *this; }
- Vector2& operator-=(const Vector2 &v) { x -= v.x; y -= v.y; return *this; }
- Vector2& operator*=(float v) { x *= v; y *= v; return *this; }
- Vector2& operator/=(float v) { x /= v; y /= v; return *this; }
-
- friend Vector2 operator+(float f, const Vector2 &v) { return Vector2(f + v.x, f + v.y); }
- friend Vector2 operator-(float f, const Vector2 &v) { return Vector2(f - v.x, f - v.y); }
- friend Vector2 operator*(float f, const Vector2 &v) { return Vector2(f * v.x, f * v.y); }
- friend Vector2 operator/(float f, const Vector2 &v) { return Vector2(f / v.x, f / v.y); }
-private:
- float x, y;
-};
-
-test_initializer operator_overloading([](py::module &m) {
- py::class_<Vector2>(m, "Vector2")
- .def(py::init<float, float>())
- .def(py::self + py::self)
- .def(py::self + float())
- .def(py::self - py::self)
- .def(py::self - float())
- .def(py::self * float())
- .def(py::self / float())
- .def(py::self += py::self)
- .def(py::self -= py::self)
- .def(py::self *= float())
- .def(py::self /= float())
- .def(float() + py::self)
- .def(float() - py::self)
- .def(float() * py::self)
- .def(float() / py::self)
- .def("__str__", &Vector2::toString)
- ;
-
- m.attr("Vector") = m.attr("Vector2");
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_operator_overloading.py b/thirdparty/pybind11/pybind11/tests/test_operator_overloading.py
deleted file mode 100644
index 02ccb9633b548fcd394d005296eb2a4750456af0..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_operator_overloading.py
+++ /dev/null
@@ -1,40 +0,0 @@
-def test_operator_overloading():
- from pybind11_tests import Vector2, Vector, ConstructorStats
-
- v1 = Vector2(1, 2)
- v2 = Vector(3, -1)
- assert str(v1) == "[1.000000, 2.000000]"
- assert str(v2) == "[3.000000, -1.000000]"
-
- assert str(v1 + v2) == "[4.000000, 1.000000]"
- assert str(v1 - v2) == "[-2.000000, 3.000000]"
- assert str(v1 - 8) == "[-7.000000, -6.000000]"
- assert str(v1 + 8) == "[9.000000, 10.000000]"
- assert str(v1 * 8) == "[8.000000, 16.000000]"
- assert str(v1 / 8) == "[0.125000, 0.250000]"
- assert str(8 - v1) == "[7.000000, 6.000000]"
- assert str(8 + v1) == "[9.000000, 10.000000]"
- assert str(8 * v1) == "[8.000000, 16.000000]"
- assert str(8 / v1) == "[8.000000, 4.000000]"
-
- v1 += v2
- v1 *= 2
- assert str(v1) == "[8.000000, 2.000000]"
-
- cstats = ConstructorStats.get(Vector2)
- assert cstats.alive() == 2
- del v1
- assert cstats.alive() == 1
- del v2
- assert cstats.alive() == 0
- assert cstats.values() == ['[1.000000, 2.000000]', '[3.000000, -1.000000]',
- '[4.000000, 1.000000]', '[-2.000000, 3.000000]',
- '[-7.000000, -6.000000]', '[9.000000, 10.000000]',
- '[8.000000, 16.000000]', '[0.125000, 0.250000]',
- '[7.000000, 6.000000]', '[9.000000, 10.000000]',
- '[8.000000, 16.000000]', '[8.000000, 4.000000]']
- assert cstats.default_constructions == 0
- assert cstats.copy_constructions == 0
- assert cstats.move_constructions >= 10
- assert cstats.copy_assignments == 0
- assert cstats.move_assignments == 0
diff --git a/thirdparty/pybind11/pybind11/tests/test_pickling.cpp b/thirdparty/pybind11/pybind11/tests/test_pickling.cpp
deleted file mode 100644
index 52b1dbc30d1de3be71b1f2f9eb2140cdf1929cf7..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_pickling.cpp
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- tests/test_pickling.cpp -- pickle support
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-class Pickleable {
-public:
- Pickleable(const std::string &value) : m_value(value) { }
- const std::string &value() const { return m_value; }
-
- void setExtra1(int extra1) { m_extra1 = extra1; }
- void setExtra2(int extra2) { m_extra2 = extra2; }
- int extra1() const { return m_extra1; }
- int extra2() const { return m_extra2; }
-private:
- std::string m_value;
- int m_extra1 = 0;
- int m_extra2 = 0;
-};
-
-class PickleableWithDict {
-public:
- PickleableWithDict(const std::string &value) : value(value) { }
-
- std::string value;
- int extra;
-};
-
-test_initializer pickling([](py::module &m) {
- py::class_<Pickleable>(m, "Pickleable")
- .def(py::init<std::string>())
- .def("value", &Pickleable::value)
- .def("extra1", &Pickleable::extra1)
- .def("extra2", &Pickleable::extra2)
- .def("setExtra1", &Pickleable::setExtra1)
- .def("setExtra2", &Pickleable::setExtra2)
- // For details on the methods below, refer to
- // http://docs.python.org/3/library/pickle.html#pickling-class-instances
- .def("__getstate__", [](const Pickleable &p) {
- /* Return a tuple that fully encodes the state of the object */
- return py::make_tuple(p.value(), p.extra1(), p.extra2());
- })
- .def("__setstate__", [](Pickleable &p, py::tuple t) {
- if (t.size() != 3)
- throw std::runtime_error("Invalid state!");
- /* Invoke the constructor (need to use in-place version) */
- new (&p) Pickleable(t[0].cast<std::string>());
-
- /* Assign any additional state */
- p.setExtra1(t[1].cast<int>());
- p.setExtra2(t[2].cast<int>());
- });
-
-#if !defined(PYPY_VERSION)
- py::class_<PickleableWithDict>(m, "PickleableWithDict", py::dynamic_attr())
- .def(py::init<std::string>())
- .def_readwrite("value", &PickleableWithDict::value)
- .def_readwrite("extra", &PickleableWithDict::extra)
- .def("__getstate__", [](py::object self) {
- /* Also include __dict__ in state */
- return py::make_tuple(self.attr("value"), self.attr("extra"), self.attr("__dict__"));
- })
- .def("__setstate__", [](py::object self, py::tuple t) {
- if (t.size() != 3)
- throw std::runtime_error("Invalid state!");
- /* Cast and construct */
- auto& p = self.cast<PickleableWithDict&>();
- new (&p) PickleableWithDict(t[0].cast<std::string>());
-
- /* Assign C++ state */
- p.extra = t[1].cast<int>();
-
- /* Assign Python state */
- self.attr("__dict__") = t[2];
- });
-#endif
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_pickling.py b/thirdparty/pybind11/pybind11/tests/test_pickling.py
deleted file mode 100644
index 548c618af26a8d693be997c4b73ce91feeeeabc7..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_pickling.py
+++ /dev/null
@@ -1,35 +0,0 @@
-import pytest
-
-try:
- import cPickle as pickle # Use cPickle on Python 2.7
-except ImportError:
- import pickle
-
-
-def test_roundtrip():
- from pybind11_tests import Pickleable
-
- p = Pickleable("test_value")
- p.setExtra1(15)
- p.setExtra2(48)
-
- data = pickle.dumps(p, 2) # Must use pickle protocol >= 2
- p2 = pickle.loads(data)
- assert p2.value() == p.value()
- assert p2.extra1() == p.extra1()
- assert p2.extra2() == p.extra2()
-
-
-@pytest.unsupported_on_pypy
-def test_roundtrip_with_dict():
- from pybind11_tests import PickleableWithDict
-
- p = PickleableWithDict("test_value")
- p.extra = 15
- p.dynamic = "Attribute"
-
- data = pickle.dumps(p, pickle.HIGHEST_PROTOCOL)
- p2 = pickle.loads(data)
- assert p2.value == p.value
- assert p2.extra == p.extra
- assert p2.dynamic == p.dynamic
diff --git a/thirdparty/pybind11/pybind11/tests/test_python_types.cpp b/thirdparty/pybind11/pybind11/tests/test_python_types.cpp
deleted file mode 100644
index 5696239b4cf4eb4c1cad02a3a03022b1cad8bdfd..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_python_types.cpp
+++ /dev/null
@@ -1,495 +0,0 @@
-/*
- tests/test_python_types.cpp -- singleton design pattern, static functions and
- variables, passing and interacting with Python types
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include "constructor_stats.h"
-#include <pybind11/stl.h>
-
-#ifdef _WIN32
-# include <io.h>
-# include <fcntl.h>
-#endif
-
-#if defined(_MSC_VER)
-# pragma warning(push)
-# pragma warning(disable: 4127) // warning C4127: Conditional expression is constant
-#endif
-
-class ExamplePythonTypes {
-public:
- static ExamplePythonTypes *new_instance() {
- auto *ptr = new ExamplePythonTypes();
- print_created(ptr, "via new_instance");
- return ptr;
- }
- ~ExamplePythonTypes() { print_destroyed(this); }
-
- /* Create and return a Python dictionary */
- py::dict get_dict() {
- py::dict dict;
- dict[py::str("key")] = py::str("value");
- return dict;
- }
-
- /* Create and return a Python set */
- py::set get_set() {
- py::set set;
- set.add(py::str("key1"));
- set.add("key2");
- set.add(std::string("key3"));
- return set;
- }
-
- /* Create and return a C++ dictionary */
- std::map<std::string, std::string> get_dict_2() {
- std::map<std::string, std::string> result;
- result["key"] = "value";
- return result;
- }
-
- /* Create and return a C++ set */
- std::set<std::string> get_set_2() {
- std::set<std::string> result;
- result.insert("key1");
- result.insert("key2");
- return result;
- }
-
- /* Create, manipulate, and return a Python list */
- py::list get_list() {
- py::list list;
- list.append("value");
- py::print("Entry at position 0:", list[0]);
- list[0] = py::str("overwritten");
- return list;
- }
-
- /* C++ STL data types are automatically casted */
- std::vector<std::wstring> get_list_2() {
- std::vector<std::wstring> list;
- list.push_back(L"value");
- return list;
- }
-
- /* C++ STL data types are automatically casted */
- std::array<std::string, 2> get_array() {
- return std::array<std::string, 2> {{ "array entry 1" , "array entry 2"}};
- }
-
- std::valarray<int> get_valarray() {
- return std::valarray<int>({ 1, 4, 9 });
- }
-
- /* Easily iterate over a dictionary using a C++11 range-based for loop */
- void print_dict(py::dict dict) {
- for (auto item : dict)
- py::print("key: {}, value={}"_s.format(item.first, item.second));
- }
-
- /* Easily iterate over a set using a C++11 range-based for loop */
- void print_set(py::set set) {
- for (auto item : set)
- py::print("key:", item);
- }
-
- /* Easily iterate over a list using a C++11 range-based for loop */
- void print_list(py::list list) {
- int index = 0;
- for (auto item : list)
- py::print("list item {}: {}"_s.format(index++, item));
- }
-
- /* STL data types (such as maps) are automatically casted from Python */
- void print_dict_2(const std::map<std::string, std::string> &dict) {
- for (auto item : dict)
- py::print("key: {}, value={}"_s.format(item.first, item.second));
- }
-
- /* STL data types (such as sets) are automatically casted from Python */
- void print_set_2(const std::set<std::string> &set) {
- for (auto item : set)
- py::print("key:", item);
- }
-
- /* STL data types (such as vectors) are automatically casted from Python */
- void print_list_2(std::vector<std::wstring> &list) {
- int index = 0;
- for (auto item : list)
- py::print("list item {}: {}"_s.format(index++, item));
- }
-
- /* pybind automatically translates between C++11 and Python tuples */
- std::pair<std::string, bool> pair_passthrough(std::pair<bool, std::string> input) {
- return std::make_pair(input.second, input.first);
- }
-
- /* pybind automatically translates between C++11 and Python tuples */
- std::tuple<int, std::string, bool> tuple_passthrough(std::tuple<bool, std::string, int> input) {
- return std::make_tuple(std::get<2>(input), std::get<1>(input), std::get<0>(input));
- }
-
- /* STL data types (such as arrays) are automatically casted from Python */
- void print_array(std::array<std::string, 2> &array) {
- int index = 0;
- for (auto item : array)
- py::print("array item {}: {}"_s.format(index++, item));
- }
-
- void print_valarray(std::valarray<int> &varray) {
- int index = 0;
- for (auto item : varray)
- py::print("valarray item {}: {}"_s.format(index++, item));
- }
-
- void throw_exception() {
- throw std::runtime_error("This exception was intentionally thrown.");
- }
-
- py::bytes get_bytes_from_string() {
- return (py::bytes) std::string("foo");
- }
-
- py::bytes get_bytes_from_str() {
- return (py::bytes) py::str("bar", 3);
- }
-
- py::str get_str_from_string() {
- return (py::str) std::string("baz");
- }
-
- py::str get_str_from_bytes() {
- return (py::str) py::bytes("boo", 3);
- }
-
- void test_print(const py::object& obj) {
- py::print(py::str(obj));
- py::print(py::repr(obj));
- }
-
- static int value;
- static const int value2;
-};
-
-int ExamplePythonTypes::value = 0;
-const int ExamplePythonTypes::value2 = 5;
-
-struct MoveOutContainer {
- struct Value { int value; };
-
- std::list<Value> move_list() const { return {{0}, {1}, {2}}; }
-};
-
-
-test_initializer python_types([](py::module &m) {
- /* No constructor is explicitly defined below. An exception is raised when
- trying to construct it directly from Python */
- py::class_<ExamplePythonTypes>(m, "ExamplePythonTypes", "Example 2 documentation")
- .def("get_dict", &ExamplePythonTypes::get_dict, "Return a Python dictionary")
- .def("get_dict_2", &ExamplePythonTypes::get_dict_2, "Return a C++ dictionary")
- .def("get_list", &ExamplePythonTypes::get_list, "Return a Python list")
- .def("get_list_2", &ExamplePythonTypes::get_list_2, "Return a C++ list")
- .def("get_set", &ExamplePythonTypes::get_set, "Return a Python set")
- .def("get_set2", &ExamplePythonTypes::get_set_2, "Return a C++ set")
- .def("get_array", &ExamplePythonTypes::get_array, "Return a C++ array")
- .def("get_valarray", &ExamplePythonTypes::get_valarray, "Return a C++ valarray")
- .def("print_dict", &ExamplePythonTypes::print_dict, "Print entries of a Python dictionary")
- .def("print_dict_2", &ExamplePythonTypes::print_dict_2, "Print entries of a C++ dictionary")
- .def("print_set", &ExamplePythonTypes::print_set, "Print entries of a Python set")
- .def("print_set_2", &ExamplePythonTypes::print_set_2, "Print entries of a C++ set")
- .def("print_list", &ExamplePythonTypes::print_list, "Print entries of a Python list")
- .def("print_list_2", &ExamplePythonTypes::print_list_2, "Print entries of a C++ list")
- .def("print_array", &ExamplePythonTypes::print_array, "Print entries of a C++ array")
- .def("print_valarray", &ExamplePythonTypes::print_valarray, "Print entries of a C++ valarray")
- .def("pair_passthrough", &ExamplePythonTypes::pair_passthrough, "Return a pair in reversed order")
- .def("tuple_passthrough", &ExamplePythonTypes::tuple_passthrough, "Return a triple in reversed order")
- .def("throw_exception", &ExamplePythonTypes::throw_exception, "Throw an exception")
- .def("get_bytes_from_string", &ExamplePythonTypes::get_bytes_from_string, "py::bytes from std::string")
- .def("get_bytes_from_str", &ExamplePythonTypes::get_bytes_from_str, "py::bytes from py::str")
- .def("get_str_from_string", &ExamplePythonTypes::get_str_from_string, "py::str from std::string")
- .def("get_str_from_bytes", &ExamplePythonTypes::get_str_from_bytes, "py::str from py::bytes")
- .def("test_print", &ExamplePythonTypes::test_print, "test the print function")
- .def_static("new_instance", &ExamplePythonTypes::new_instance, "Return an instance")
- .def_readwrite_static("value", &ExamplePythonTypes::value, "Static value member")
- .def_readonly_static("value2", &ExamplePythonTypes::value2, "Static value member (readonly)");
-
- m.def("test_print_function", []() {
- py::print("Hello, World!");
- py::print(1, 2.0, "three", true, std::string("-- multiple args"));
- auto args = py::make_tuple("and", "a", "custom", "separator");
- py::print("*args", *args, "sep"_a="-");
- py::print("no new line here", "end"_a=" -- ");
- py::print("next print");
-
- auto py_stderr = py::module::import("sys").attr("stderr");
- py::print("this goes to stderr", "file"_a=py_stderr);
-
- py::print("flush", "flush"_a=true);
-
- py::print("{a} + {b} = {c}"_s.format("a"_a="py::print", "b"_a="str.format", "c"_a="this"));
- });
-
- m.def("test_str_format", []() {
- auto s1 = "{} + {} = {}"_s.format(1, 2, 3);
- auto s2 = "{a} + {b} = {c}"_s.format("a"_a=1, "b"_a=2, "c"_a=3);
- return py::make_tuple(s1, s2);
- });
-
- m.def("test_dict_keyword_constructor", []() {
- auto d1 = py::dict("x"_a=1, "y"_a=2);
- auto d2 = py::dict("z"_a=3, **d1);
- return d2;
- });
-
- m.def("test_accessor_api", [](py::object o) {
- auto d = py::dict();
-
- d["basic_attr"] = o.attr("basic_attr");
-
- auto l = py::list();
- for (const auto &item : o.attr("begin_end")) {
- l.append(item);
- }
- d["begin_end"] = l;
-
- d["operator[object]"] = o.attr("d")["operator[object]"_s];
- d["operator[char *]"] = o.attr("d")["operator[char *]"];
-
- d["attr(object)"] = o.attr("sub").attr("attr_obj");
- d["attr(char *)"] = o.attr("sub").attr("attr_char");
- try {
- o.attr("sub").attr("missing").ptr();
- } catch (const py::error_already_set &) {
- d["missing_attr_ptr"] = "raised"_s;
- }
- try {
- o.attr("missing").attr("doesn't matter");
- } catch (const py::error_already_set &) {
- d["missing_attr_chain"] = "raised"_s;
- }
-
- d["is_none"] = o.attr("basic_attr").is_none();
-
- d["operator()"] = o.attr("func")(1);
- d["operator*"] = o.attr("func")(*o.attr("begin_end"));
-
- return d;
- });
-
- m.def("test_tuple_accessor", [](py::tuple existing_t) {
- try {
- existing_t[0] = 1;
- } catch (const py::error_already_set &) {
- // --> Python system error
- // Only new tuples (refcount == 1) are mutable
- auto new_t = py::tuple(3);
- for (size_t i = 0; i < new_t.size(); ++i) {
- new_t[i] = i;
- }
- return new_t;
- }
- return py::tuple();
- });
-
- m.def("test_accessor_assignment", []() {
- auto l = py::list(1);
- l[0] = 0;
-
- auto d = py::dict();
- d["get"] = l[0];
- auto var = l[0];
- d["deferred_get"] = var;
- l[0] = 1;
- d["set"] = l[0];
- var = 99; // this assignment should not overwrite l[0]
- d["deferred_set"] = l[0];
- d["var"] = var;
-
- return d;
- });
-
- bool has_optional = false, has_exp_optional = false;
-#ifdef PYBIND11_HAS_OPTIONAL
- has_optional = true;
- using opt_int = std::optional<int>;
- m.def("double_or_zero", [](const opt_int& x) -> int {
- return x.value_or(0) * 2;
- });
- m.def("half_or_none", [](int x) -> opt_int {
- return x ? opt_int(x / 2) : opt_int();
- });
- m.def("test_nullopt", [](opt_int x) {
- return x.value_or(42);
- }, py::arg_v("x", std::nullopt, "None"));
-#endif
-
-#ifdef PYBIND11_HAS_EXP_OPTIONAL
- has_exp_optional = true;
- using exp_opt_int = std::experimental::optional<int>;
- m.def("double_or_zero_exp", [](const exp_opt_int& x) -> int {
- return x.value_or(0) * 2;
- });
- m.def("half_or_none_exp", [](int x) -> exp_opt_int {
- return x ? exp_opt_int(x / 2) : exp_opt_int();
- });
- m.def("test_nullopt_exp", [](exp_opt_int x) {
- return x.value_or(42);
- }, py::arg_v("x", std::experimental::nullopt, "None"));
-#endif
-
- m.attr("has_optional") = has_optional;
- m.attr("has_exp_optional") = has_exp_optional;
-
- m.def("test_default_constructors", []() {
- return py::dict(
- "str"_a=py::str(),
- "bool"_a=py::bool_(),
- "int"_a=py::int_(),
- "float"_a=py::float_(),
- "tuple"_a=py::tuple(),
- "list"_a=py::list(),
- "dict"_a=py::dict(),
- "set"_a=py::set()
- );
- });
-
- m.def("test_converting_constructors", [](py::dict d) {
- return py::dict(
- "str"_a=py::str(d["str"]),
- "bool"_a=py::bool_(d["bool"]),
- "int"_a=py::int_(d["int"]),
- "float"_a=py::float_(d["float"]),
- "tuple"_a=py::tuple(d["tuple"]),
- "list"_a=py::list(d["list"]),
- "dict"_a=py::dict(d["dict"]),
- "set"_a=py::set(d["set"]),
- "memoryview"_a=py::memoryview(d["memoryview"])
- );
- });
-
- m.def("test_cast_functions", [](py::dict d) {
- // When converting between Python types, obj.cast<T>() should be the same as T(obj)
- return py::dict(
- "str"_a=d["str"].cast<py::str>(),
- "bool"_a=d["bool"].cast<py::bool_>(),
- "int"_a=d["int"].cast<py::int_>(),
- "float"_a=d["float"].cast<py::float_>(),
- "tuple"_a=d["tuple"].cast<py::tuple>(),
- "list"_a=d["list"].cast<py::list>(),
- "dict"_a=d["dict"].cast<py::dict>(),
- "set"_a=d["set"].cast<py::set>(),
- "memoryview"_a=d["memoryview"].cast<py::memoryview>()
- );
- });
-
- py::class_<MoveOutContainer::Value>(m, "MoveOutContainerValue")
- .def_readonly("value", &MoveOutContainer::Value::value);
-
- py::class_<MoveOutContainer>(m, "MoveOutContainer")
- .def(py::init<>())
- .def_property_readonly("move_list", &MoveOutContainer::move_list);
-
- m.def("get_implicit_casting", []() {
- py::dict d;
- d["char*_i1"] = "abc";
- const char *c2 = "abc";
- d["char*_i2"] = c2;
- d["char*_e"] = py::cast(c2);
- d["char*_p"] = py::str(c2);
-
- d["int_i1"] = 42;
- int i = 42;
- d["int_i2"] = i;
- i++;
- d["int_e"] = py::cast(i);
- i++;
- d["int_p"] = py::int_(i);
-
- d["str_i1"] = std::string("str");
- std::string s2("str1");
- d["str_i2"] = s2;
- s2[3] = '2';
- d["str_e"] = py::cast(s2);
- s2[3] = '3';
- d["str_p"] = py::str(s2);
-
- py::list l(2);
- l[0] = 3;
- l[1] = py::cast(6);
- l.append(9);
- l.append(py::cast(12));
- l.append(py::int_(15));
-
- return py::dict(
- "d"_a=d,
- "l"_a=l
- );
- });
-
- // Some test characters in utf16 and utf32 encodings. The last one (the ð€) contains a null byte
- char32_t a32 = 0x61 /*a*/, z32 = 0x7a /*z*/, ib32 = 0x203d /*‽*/, cake32 = 0x1f382 /*🎂*/, mathbfA32 = 0x1d400 /*ð€*/;
- char16_t b16 = 0x62 /*b*/, z16 = 0x7a, ib16 = 0x203d, cake16_1 = 0xd83c, cake16_2 = 0xdf82, mathbfA16_1 = 0xd835, mathbfA16_2 = 0xdc00;
- std::wstring wstr;
- wstr.push_back(0x61); // a
- wstr.push_back(0x2e18); // ⸘
- if (sizeof(wchar_t) == 2) { wstr.push_back(mathbfA16_1); wstr.push_back(mathbfA16_2); } // ð€, utf16
- else { wstr.push_back((wchar_t) mathbfA32); } // ð€, utf32
- wstr.push_back(0x7a); // z
-
- m.def("good_utf8_string", []() { return std::string(u8"Say utf8\u203d \U0001f382 \U0001d400"); }); // Say utf8‽ 🎂 ð€
- m.def("good_utf16_string", [=]() { return std::u16string({ b16, ib16, cake16_1, cake16_2, mathbfA16_1, mathbfA16_2, z16 }); }); // b‽🎂ð€z
- m.def("good_utf32_string", [=]() { return std::u32string({ a32, mathbfA32, cake32, ib32, z32 }); }); // að€ðŸŽ‚‽z
- m.def("good_wchar_string", [=]() { return wstr; }); // a‽ð€z
- m.def("bad_utf8_string", []() { return std::string("abc\xd0" "def"); });
- m.def("bad_utf16_string", [=]() { return std::u16string({ b16, char16_t(0xd800), z16 }); });
- // Under Python 2.7, invalid unicode UTF-32 characters don't appear to trigger UnicodeDecodeError
- if (PY_MAJOR_VERSION >= 3)
- m.def("bad_utf32_string", [=]() { return std::u32string({ a32, char32_t(0xd800), z32 }); });
- if (PY_MAJOR_VERSION >= 3 || sizeof(wchar_t) == 2)
- m.def("bad_wchar_string", [=]() { return std::wstring({ wchar_t(0x61), wchar_t(0xd800) }); });
- m.def("u8_Z", []() -> char { return 'Z'; });
- m.def("u8_eacute", []() -> char { return '\xe9'; });
- m.def("u16_ibang", [=]() -> char16_t { return ib16; });
- m.def("u32_mathbfA", [=]() -> char32_t { return mathbfA32; });
- m.def("wchar_heart", []() -> wchar_t { return 0x2665; });
-
- m.attr("wchar_size") = py::cast(sizeof(wchar_t));
- m.def("ord_char", [](char c) -> int { return static_cast<unsigned char>(c); });
- m.def("ord_char16", [](char16_t c) -> uint16_t { return c; });
- m.def("ord_char32", [](char32_t c) -> uint32_t { return c; });
- m.def("ord_wchar", [](wchar_t c) -> int { return c; });
-
- m.def("return_none_string", []() -> std::string * { return nullptr; });
- m.def("return_none_char", []() -> const char * { return nullptr; });
- m.def("return_none_bool", []() -> bool * { return nullptr; });
- m.def("return_none_int", []() -> int * { return nullptr; });
- m.def("return_none_float", []() -> float * { return nullptr; });
-
- m.def("return_capsule_with_destructor",
- []() {
- py::print("creating capsule");
- return py::capsule([]() {
- py::print("destructing capsule");
- });
- }
- );
-
- m.def("return_capsule_with_destructor_2",
- []() {
- py::print("creating capsule");
- return py::capsule((void *) 1234, [](void *ptr) {
- py::print("destructing capsule: {}"_s.format((size_t) ptr));
- });
- }
- );
-});
-
-#if defined(_MSC_VER)
-# pragma warning(pop)
-#endif
diff --git a/thirdparty/pybind11/pybind11/tests/test_python_types.py b/thirdparty/pybind11/pybind11/tests/test_python_types.py
deleted file mode 100644
index 7956c7cc66193c5bab60b863405870dea431bb57..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_python_types.py
+++ /dev/null
@@ -1,535 +0,0 @@
-# Python < 3 needs this: coding=utf-8
-import pytest
-
-from pybind11_tests import ExamplePythonTypes, ConstructorStats, has_optional, has_exp_optional
-
-
-def test_repr():
- # In Python 3.3+, repr() accesses __qualname__
- assert "pybind11_type" in repr(type(ExamplePythonTypes))
- assert "ExamplePythonTypes" in repr(ExamplePythonTypes)
-
-
-def test_static():
- ExamplePythonTypes.value = 15
- assert ExamplePythonTypes.value == 15
- assert ExamplePythonTypes.value2 == 5
-
- with pytest.raises(AttributeError) as excinfo:
- ExamplePythonTypes.value2 = 15
- assert str(excinfo.value) == "can't set attribute"
-
-
-def test_instance(capture):
- with pytest.raises(TypeError) as excinfo:
- ExamplePythonTypes()
- assert str(excinfo.value) == "pybind11_tests.ExamplePythonTypes: No constructor defined!"
-
- instance = ExamplePythonTypes.new_instance()
-
- with capture:
- dict_result = instance.get_dict()
- dict_result['key2'] = 'value2'
- instance.print_dict(dict_result)
- assert capture.unordered == """
- key: key, value=value
- key: key2, value=value2
- """
- with capture:
- dict_result = instance.get_dict_2()
- dict_result['key2'] = 'value2'
- instance.print_dict_2(dict_result)
- assert capture.unordered == """
- key: key, value=value
- key: key2, value=value2
- """
- with capture:
- set_result = instance.get_set()
- set_result.add('key4')
- instance.print_set(set_result)
- assert capture.unordered == """
- key: key1
- key: key2
- key: key3
- key: key4
- """
- with capture:
- set_result = instance.get_set2()
- set_result.add('key3')
- instance.print_set_2(set_result)
- assert capture.unordered == """
- key: key1
- key: key2
- key: key3
- """
- with capture:
- list_result = instance.get_list()
- list_result.append('value2')
- instance.print_list(list_result)
- assert capture.unordered == """
- Entry at position 0: value
- list item 0: overwritten
- list item 1: value2
- """
- with capture:
- list_result = instance.get_list_2()
- list_result.append('value2')
- instance.print_list_2(list_result)
- assert capture.unordered == """
- list item 0: value
- list item 1: value2
- """
- with capture:
- list_result = instance.get_list_2()
- list_result.append('value2')
- instance.print_list_2(tuple(list_result))
- assert capture.unordered == """
- list item 0: value
- list item 1: value2
- """
- array_result = instance.get_array()
- assert array_result == ['array entry 1', 'array entry 2']
- with capture:
- instance.print_array(array_result)
- assert capture.unordered == """
- array item 0: array entry 1
- array item 1: array entry 2
- """
- varray_result = instance.get_valarray()
- assert varray_result == [1, 4, 9]
- with capture:
- instance.print_valarray(varray_result)
- assert capture.unordered == """
- valarray item 0: 1
- valarray item 1: 4
- valarray item 2: 9
- """
- with pytest.raises(RuntimeError) as excinfo:
- instance.throw_exception()
- assert str(excinfo.value) == "This exception was intentionally thrown."
-
- assert instance.pair_passthrough((True, "test")) == ("test", True)
- assert instance.tuple_passthrough((True, "test", 5)) == (5, "test", True)
- # Any sequence can be cast to a std::pair or std::tuple
- assert instance.pair_passthrough([True, "test"]) == ("test", True)
- assert instance.tuple_passthrough([True, "test", 5]) == (5, "test", True)
-
- assert instance.get_bytes_from_string().decode() == "foo"
- assert instance.get_bytes_from_str().decode() == "bar"
- assert instance.get_str_from_string().encode().decode() == "baz"
- assert instance.get_str_from_bytes().encode().decode() == "boo"
-
- class A(object):
- def __str__(self):
- return "this is a str"
-
- def __repr__(self):
- return "this is a repr"
-
- with capture:
- instance.test_print(A())
- assert capture == """
- this is a str
- this is a repr
- """
-
- cstats = ConstructorStats.get(ExamplePythonTypes)
- assert cstats.alive() == 1
- del instance
- assert cstats.alive() == 0
-
-
-# PyPy does not seem to propagate the tp_docs field at the moment
-def test_class_docs(doc):
- assert doc(ExamplePythonTypes) == "Example 2 documentation"
-
-
-def test_method_docs(doc):
- assert doc(ExamplePythonTypes.get_dict) == """
- get_dict(self: m.ExamplePythonTypes) -> dict
-
- Return a Python dictionary
- """
- assert doc(ExamplePythonTypes.get_dict_2) == """
- get_dict_2(self: m.ExamplePythonTypes) -> Dict[str, str]
-
- Return a C++ dictionary
- """
- assert doc(ExamplePythonTypes.get_list) == """
- get_list(self: m.ExamplePythonTypes) -> list
-
- Return a Python list
- """
- assert doc(ExamplePythonTypes.get_list_2) == """
- get_list_2(self: m.ExamplePythonTypes) -> List[str]
-
- Return a C++ list
- """
- assert doc(ExamplePythonTypes.get_dict) == """
- get_dict(self: m.ExamplePythonTypes) -> dict
-
- Return a Python dictionary
- """
- assert doc(ExamplePythonTypes.get_set) == """
- get_set(self: m.ExamplePythonTypes) -> set
-
- Return a Python set
- """
- assert doc(ExamplePythonTypes.get_set2) == """
- get_set2(self: m.ExamplePythonTypes) -> Set[str]
-
- Return a C++ set
- """
- assert doc(ExamplePythonTypes.get_array) == """
- get_array(self: m.ExamplePythonTypes) -> List[str[2]]
-
- Return a C++ array
- """
- assert doc(ExamplePythonTypes.get_valarray) == """
- get_valarray(self: m.ExamplePythonTypes) -> List[int]
-
- Return a C++ valarray
- """
- assert doc(ExamplePythonTypes.print_dict) == """
- print_dict(self: m.ExamplePythonTypes, arg0: dict) -> None
-
- Print entries of a Python dictionary
- """
- assert doc(ExamplePythonTypes.print_dict_2) == """
- print_dict_2(self: m.ExamplePythonTypes, arg0: Dict[str, str]) -> None
-
- Print entries of a C++ dictionary
- """
- assert doc(ExamplePythonTypes.print_set) == """
- print_set(self: m.ExamplePythonTypes, arg0: set) -> None
-
- Print entries of a Python set
- """
- assert doc(ExamplePythonTypes.print_set_2) == """
- print_set_2(self: m.ExamplePythonTypes, arg0: Set[str]) -> None
-
- Print entries of a C++ set
- """
- assert doc(ExamplePythonTypes.print_list) == """
- print_list(self: m.ExamplePythonTypes, arg0: list) -> None
-
- Print entries of a Python list
- """
- assert doc(ExamplePythonTypes.print_list_2) == """
- print_list_2(self: m.ExamplePythonTypes, arg0: List[str]) -> None
-
- Print entries of a C++ list
- """
- assert doc(ExamplePythonTypes.print_array) == """
- print_array(self: m.ExamplePythonTypes, arg0: List[str[2]]) -> None
-
- Print entries of a C++ array
- """
- assert doc(ExamplePythonTypes.pair_passthrough) == """
- pair_passthrough(self: m.ExamplePythonTypes, arg0: Tuple[bool, str]) -> Tuple[str, bool]
-
- Return a pair in reversed order
- """
- assert doc(ExamplePythonTypes.tuple_passthrough) == """
- tuple_passthrough(self: m.ExamplePythonTypes, arg0: Tuple[bool, str, int]) -> Tuple[int, str, bool]
-
- Return a triple in reversed order
- """ # noqa: E501 line too long
- assert doc(ExamplePythonTypes.throw_exception) == """
- throw_exception(self: m.ExamplePythonTypes) -> None
-
- Throw an exception
- """
- assert doc(ExamplePythonTypes.new_instance) == """
- new_instance() -> m.ExamplePythonTypes
-
- Return an instance
- """
-
-
-def test_module():
- import pybind11_tests
-
- assert pybind11_tests.__name__ == "pybind11_tests"
- assert ExamplePythonTypes.__name__ == "ExamplePythonTypes"
- assert ExamplePythonTypes.__module__ == "pybind11_tests"
- assert ExamplePythonTypes.get_set.__name__ == "get_set"
- assert ExamplePythonTypes.get_set.__module__ == "pybind11_tests"
-
-
-def test_print(capture):
- from pybind11_tests import test_print_function
-
- with capture:
- test_print_function()
- assert capture == """
- Hello, World!
- 1 2.0 three True -- multiple args
- *args-and-a-custom-separator
- no new line here -- next print
- flush
- py::print + str.format = this
- """
- assert capture.stderr == "this goes to stderr"
-
-
-def test_str_api():
- from pybind11_tests import test_str_format
-
- s1, s2 = test_str_format()
- assert s1 == "1 + 2 = 3"
- assert s1 == s2
-
-
-def test_dict_api():
- from pybind11_tests import test_dict_keyword_constructor
-
- assert test_dict_keyword_constructor() == {"x": 1, "y": 2, "z": 3}
-
-
-def test_accessors():
- from pybind11_tests import test_accessor_api, test_tuple_accessor, test_accessor_assignment
-
- class SubTestObject:
- attr_obj = 1
- attr_char = 2
-
- class TestObject:
- basic_attr = 1
- begin_end = [1, 2, 3]
- d = {"operator[object]": 1, "operator[char *]": 2}
- sub = SubTestObject()
-
- def func(self, x, *args):
- return self.basic_attr + x + sum(args)
-
- d = test_accessor_api(TestObject())
- assert d["basic_attr"] == 1
- assert d["begin_end"] == [1, 2, 3]
- assert d["operator[object]"] == 1
- assert d["operator[char *]"] == 2
- assert d["attr(object)"] == 1
- assert d["attr(char *)"] == 2
- assert d["missing_attr_ptr"] == "raised"
- assert d["missing_attr_chain"] == "raised"
- assert d["is_none"] is False
- assert d["operator()"] == 2
- assert d["operator*"] == 7
-
- assert test_tuple_accessor(tuple()) == (0, 1, 2)
-
- d = test_accessor_assignment()
- assert d["get"] == 0
- assert d["deferred_get"] == 0
- assert d["set"] == 1
- assert d["deferred_set"] == 1
- assert d["var"] == 99
-
-
-@pytest.mark.skipif(not has_optional, reason='no <optional>')
-def test_optional():
- from pybind11_tests import double_or_zero, half_or_none, test_nullopt
-
- assert double_or_zero(None) == 0
- assert double_or_zero(42) == 84
- pytest.raises(TypeError, double_or_zero, 'foo')
-
- assert half_or_none(0) is None
- assert half_or_none(42) == 21
- pytest.raises(TypeError, half_or_none, 'foo')
-
- assert test_nullopt() == 42
- assert test_nullopt(None) == 42
- assert test_nullopt(42) == 42
- assert test_nullopt(43) == 43
-
-
-@pytest.mark.skipif(not has_exp_optional, reason='no <experimental/optional>')
-def test_exp_optional():
- from pybind11_tests import double_or_zero_exp, half_or_none_exp, test_nullopt_exp
-
- assert double_or_zero_exp(None) == 0
- assert double_or_zero_exp(42) == 84
- pytest.raises(TypeError, double_or_zero_exp, 'foo')
-
- assert half_or_none_exp(0) is None
- assert half_or_none_exp(42) == 21
- pytest.raises(TypeError, half_or_none_exp, 'foo')
-
- assert test_nullopt_exp() == 42
- assert test_nullopt_exp(None) == 42
- assert test_nullopt_exp(42) == 42
- assert test_nullopt_exp(43) == 43
-
-
-def test_constructors():
- """C++ default and converting constructors are equivalent to type calls in Python"""
- from pybind11_tests import (test_default_constructors, test_converting_constructors,
- test_cast_functions)
-
- types = [str, bool, int, float, tuple, list, dict, set]
- expected = {t.__name__: t() for t in types}
- assert test_default_constructors() == expected
-
- data = {
- str: 42,
- bool: "Not empty",
- int: "42",
- float: "+1e3",
- tuple: range(3),
- list: range(3),
- dict: [("two", 2), ("one", 1), ("three", 3)],
- set: [4, 4, 5, 6, 6, 6],
- memoryview: b'abc'
- }
- inputs = {k.__name__: v for k, v in data.items()}
- expected = {k.__name__: k(v) for k, v in data.items()}
- assert test_converting_constructors(inputs) == expected
- assert test_cast_functions(inputs) == expected
-
-
-def test_move_out_container():
- """Properties use the `reference_internal` policy by default. If the underlying function
- returns an rvalue, the policy is automatically changed to `move` to avoid referencing
- a temporary. In case the return value is a container of user-defined types, the policy
- also needs to be applied to the elements, not just the container."""
- from pybind11_tests import MoveOutContainer
-
- c = MoveOutContainer()
- moved_out_list = c.move_list
- assert [x.value for x in moved_out_list] == [0, 1, 2]
-
-
-def test_implicit_casting():
- """Tests implicit casting when assigning or appending to dicts and lists."""
- from pybind11_tests import get_implicit_casting
-
- z = get_implicit_casting()
- assert z['d'] == {
- 'char*_i1': 'abc', 'char*_i2': 'abc', 'char*_e': 'abc', 'char*_p': 'abc',
- 'str_i1': 'str', 'str_i2': 'str1', 'str_e': 'str2', 'str_p': 'str3',
- 'int_i1': 42, 'int_i2': 42, 'int_e': 43, 'int_p': 44
- }
- assert z['l'] == [3, 6, 9, 12, 15]
-
-
-def test_unicode_conversion():
- """Tests unicode conversion and error reporting."""
- import pybind11_tests
- from pybind11_tests import (good_utf8_string, bad_utf8_string,
- good_utf16_string, bad_utf16_string,
- good_utf32_string, # bad_utf32_string,
- good_wchar_string, # bad_wchar_string,
- u8_Z, u8_eacute, u16_ibang, u32_mathbfA, wchar_heart)
-
- assert good_utf8_string() == u"Say utf8‽ 🎂 ð€"
- assert good_utf16_string() == u"b‽🎂ð€z"
- assert good_utf32_string() == u"að€ðŸŽ‚‽z"
- assert good_wchar_string() == u"a⸘ð€z"
-
- with pytest.raises(UnicodeDecodeError):
- bad_utf8_string()
-
- with pytest.raises(UnicodeDecodeError):
- bad_utf16_string()
-
- # These are provided only if they actually fail (they don't when 32-bit and under Python 2.7)
- if hasattr(pybind11_tests, "bad_utf32_string"):
- with pytest.raises(UnicodeDecodeError):
- pybind11_tests.bad_utf32_string()
- if hasattr(pybind11_tests, "bad_wchar_string"):
- with pytest.raises(UnicodeDecodeError):
- pybind11_tests.bad_wchar_string()
-
- assert u8_Z() == 'Z'
- assert u8_eacute() == u'é'
- assert u16_ibang() == u'‽'
- assert u32_mathbfA() == u'ð€'
- assert wchar_heart() == u'♥'
-
-
-def test_single_char_arguments():
- """Tests failures for passing invalid inputs to char-accepting functions"""
- from pybind11_tests import ord_char, ord_char16, ord_char32, ord_wchar, wchar_size
-
- def toobig_message(r):
- return "Character code point not in range({0:#x})".format(r)
- toolong_message = "Expected a character, but multi-character string found"
-
- assert ord_char(u'a') == 0x61 # simple ASCII
- assert ord_char(u'é') == 0xE9 # requires 2 bytes in utf-8, but can be stuffed in a char
- with pytest.raises(ValueError) as excinfo:
- assert ord_char(u'Ä€') == 0x100 # requires 2 bytes, doesn't fit in a char
- assert str(excinfo.value) == toobig_message(0x100)
- with pytest.raises(ValueError) as excinfo:
- assert ord_char(u'ab')
- assert str(excinfo.value) == toolong_message
-
- assert ord_char16(u'a') == 0x61
- assert ord_char16(u'é') == 0xE9
- assert ord_char16(u'Ä€') == 0x100
- assert ord_char16(u'‽') == 0x203d
- assert ord_char16(u'♥') == 0x2665
- with pytest.raises(ValueError) as excinfo:
- assert ord_char16(u'🎂') == 0x1F382 # requires surrogate pair
- assert str(excinfo.value) == toobig_message(0x10000)
- with pytest.raises(ValueError) as excinfo:
- assert ord_char16(u'aa')
- assert str(excinfo.value) == toolong_message
-
- assert ord_char32(u'a') == 0x61
- assert ord_char32(u'é') == 0xE9
- assert ord_char32(u'Ä€') == 0x100
- assert ord_char32(u'‽') == 0x203d
- assert ord_char32(u'♥') == 0x2665
- assert ord_char32(u'🎂') == 0x1F382
- with pytest.raises(ValueError) as excinfo:
- assert ord_char32(u'aa')
- assert str(excinfo.value) == toolong_message
-
- assert ord_wchar(u'a') == 0x61
- assert ord_wchar(u'é') == 0xE9
- assert ord_wchar(u'Ä€') == 0x100
- assert ord_wchar(u'‽') == 0x203d
- assert ord_wchar(u'♥') == 0x2665
- if wchar_size == 2:
- with pytest.raises(ValueError) as excinfo:
- assert ord_wchar(u'🎂') == 0x1F382 # requires surrogate pair
- assert str(excinfo.value) == toobig_message(0x10000)
- else:
- assert ord_wchar(u'🎂') == 0x1F382
- with pytest.raises(ValueError) as excinfo:
- assert ord_wchar(u'aa')
- assert str(excinfo.value) == toolong_message
-
-
-def test_builtins_cast_return_none():
- """Casters produced with PYBIND11_TYPE_CASTER() should convert nullptr to None"""
- import pybind11_tests as m
-
- assert m.return_none_string() is None
- assert m.return_none_char() is None
- assert m.return_none_bool() is None
- assert m.return_none_int() is None
- assert m.return_none_float() is None
-
-
-def test_capsule_with_destructor(capture):
- import pybind11_tests as m
- with capture:
- a = m.return_capsule_with_destructor()
- del a
- pytest.gc_collect()
- assert capture.unordered == """
- creating capsule
- destructing capsule
- """
-
- with capture:
- a = m.return_capsule_with_destructor_2()
- del a
- pytest.gc_collect()
- assert capture.unordered == """
- creating capsule
- destructing capsule: 1234
- """
diff --git a/thirdparty/pybind11/pybind11/tests/test_sequences_and_iterators.cpp b/thirdparty/pybind11/pybind11/tests/test_sequences_and_iterators.cpp
deleted file mode 100644
index c2051fadb7663fcc5a20b84b7c70827b79cf14ee..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_sequences_and_iterators.cpp
+++ /dev/null
@@ -1,354 +0,0 @@
-/*
- tests/test_sequences_and_iterators.cpp -- supporting Pythons' sequence protocol, iterators,
- etc.
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include "constructor_stats.h"
-#include <pybind11/operators.h>
-#include <pybind11/stl.h>
-
-class Sequence {
-public:
- Sequence(size_t size) : m_size(size) {
- print_created(this, "of size", m_size);
- m_data = new float[size];
- memset(m_data, 0, sizeof(float) * size);
- }
-
- Sequence(const std::vector<float> &value) : m_size(value.size()) {
- print_created(this, "of size", m_size, "from std::vector");
- m_data = new float[m_size];
- memcpy(m_data, &value[0], sizeof(float) * m_size);
- }
-
- Sequence(const Sequence &s) : m_size(s.m_size) {
- print_copy_created(this);
- m_data = new float[m_size];
- memcpy(m_data, s.m_data, sizeof(float)*m_size);
- }
-
- Sequence(Sequence &&s) : m_size(s.m_size), m_data(s.m_data) {
- print_move_created(this);
- s.m_size = 0;
- s.m_data = nullptr;
- }
-
- ~Sequence() {
- print_destroyed(this);
- delete[] m_data;
- }
-
- Sequence &operator=(const Sequence &s) {
- if (&s != this) {
- delete[] m_data;
- m_size = s.m_size;
- m_data = new float[m_size];
- memcpy(m_data, s.m_data, sizeof(float)*m_size);
- }
-
- print_copy_assigned(this);
-
- return *this;
- }
-
- Sequence &operator=(Sequence &&s) {
- if (&s != this) {
- delete[] m_data;
- m_size = s.m_size;
- m_data = s.m_data;
- s.m_size = 0;
- s.m_data = nullptr;
- }
-
- print_move_assigned(this);
-
- return *this;
- }
-
- bool operator==(const Sequence &s) const {
- if (m_size != s.size())
- return false;
- for (size_t i=0; i<m_size; ++i)
- if (m_data[i] != s[i])
- return false;
- return true;
- }
-
- bool operator!=(const Sequence &s) const {
- return !operator==(s);
- }
-
- float operator[](size_t index) const {
- return m_data[index];
- }
-
- float &operator[](size_t index) {
- return m_data[index];
- }
-
- bool contains(float v) const {
- for (size_t i=0; i<m_size; ++i)
- if (v == m_data[i])
- return true;
- return false;
- }
-
- Sequence reversed() const {
- Sequence result(m_size);
- for (size_t i=0; i<m_size; ++i)
- result[m_size-i-1] = m_data[i];
- return result;
- }
-
- size_t size() const { return m_size; }
-
- const float *begin() const { return m_data; }
- const float *end() const { return m_data+m_size; }
-
-private:
- size_t m_size;
- float *m_data;
-};
-
-class IntPairs {
-public:
- IntPairs(std::vector<std::pair<int, int>> data) : data_(std::move(data)) {}
- const std::pair<int, int>* begin() const { return data_.data(); }
-
-private:
- std::vector<std::pair<int, int>> data_;
-};
-
-// Interface of a map-like object that isn't (directly) an unordered_map, but provides some basic
-// map-like functionality.
-class StringMap {
-public:
- StringMap() = default;
- StringMap(std::unordered_map<std::string, std::string> init)
- : map(std::move(init)) {}
-
- void set(std::string key, std::string val) {
- map[key] = val;
- }
-
- std::string get(std::string key) const {
- return map.at(key);
- }
-
- size_t size() const {
- return map.size();
- }
-
-private:
- std::unordered_map<std::string, std::string> map;
-
-public:
- decltype(map.cbegin()) begin() const { return map.cbegin(); }
- decltype(map.cend()) end() const { return map.cend(); }
-};
-
-template<typename T>
-class NonZeroIterator {
- const T* ptr_;
-public:
- NonZeroIterator(const T* ptr) : ptr_(ptr) {}
- const T& operator*() const { return *ptr_; }
- NonZeroIterator& operator++() { ++ptr_; return *this; }
-};
-
-class NonZeroSentinel {};
-
-template<typename A, typename B>
-bool operator==(const NonZeroIterator<std::pair<A, B>>& it, const NonZeroSentinel&) {
- return !(*it).first || !(*it).second;
-}
-
-template <typename PythonType>
-py::list test_random_access_iterator(PythonType x) {
- if (x.size() < 5)
- throw py::value_error("Please provide at least 5 elements for testing.");
-
- auto checks = py::list();
- auto assert_equal = [&checks](py::handle a, py::handle b) {
- auto result = PyObject_RichCompareBool(a.ptr(), b.ptr(), Py_EQ);
- if (result == -1) { throw py::error_already_set(); }
- checks.append(result != 0);
- };
-
- auto it = x.begin();
- assert_equal(x[0], *it);
- assert_equal(x[0], it[0]);
- assert_equal(x[1], it[1]);
-
- assert_equal(x[1], *(++it));
- assert_equal(x[1], *(it++));
- assert_equal(x[2], *it);
- assert_equal(x[3], *(it += 1));
- assert_equal(x[2], *(--it));
- assert_equal(x[2], *(it--));
- assert_equal(x[1], *it);
- assert_equal(x[0], *(it -= 1));
-
- assert_equal(it->attr("real"), x[0].attr("real"));
- assert_equal((it + 1)->attr("real"), x[1].attr("real"));
-
- assert_equal(x[1], *(it + 1));
- assert_equal(x[1], *(1 + it));
- it += 3;
- assert_equal(x[1], *(it - 2));
-
- checks.append(static_cast<std::size_t>(x.end() - x.begin()) == x.size());
- checks.append((x.begin() + static_cast<std::ptrdiff_t>(x.size())) == x.end());
- checks.append(x.begin() < x.end());
-
- return checks;
-}
-
-test_initializer sequences_and_iterators([](py::module &pm) {
- auto m = pm.def_submodule("sequences_and_iterators");
-
- py::class_<Sequence> seq(m, "Sequence");
-
- seq.def(py::init<size_t>())
- .def(py::init<const std::vector<float>&>())
- /// Bare bones interface
- .def("__getitem__", [](const Sequence &s, size_t i) {
- if (i >= s.size())
- throw py::index_error();
- return s[i];
- })
- .def("__setitem__", [](Sequence &s, size_t i, float v) {
- if (i >= s.size())
- throw py::index_error();
- s[i] = v;
- })
- .def("__len__", &Sequence::size)
- /// Optional sequence protocol operations
- .def("__iter__", [](const Sequence &s) { return py::make_iterator(s.begin(), s.end()); },
- py::keep_alive<0, 1>() /* Essential: keep object alive while iterator exists */)
- .def("__contains__", [](const Sequence &s, float v) { return s.contains(v); })
- .def("__reversed__", [](const Sequence &s) -> Sequence { return s.reversed(); })
- /// Slicing protocol (optional)
- .def("__getitem__", [](const Sequence &s, py::slice slice) -> Sequence* {
- size_t start, stop, step, slicelength;
- if (!slice.compute(s.size(), &start, &stop, &step, &slicelength))
- throw py::error_already_set();
- Sequence *seq = new Sequence(slicelength);
- for (size_t i=0; i<slicelength; ++i) {
- (*seq)[i] = s[start]; start += step;
- }
- return seq;
- })
- .def("__setitem__", [](Sequence &s, py::slice slice, const Sequence &value) {
- size_t start, stop, step, slicelength;
- if (!slice.compute(s.size(), &start, &stop, &step, &slicelength))
- throw py::error_already_set();
- if (slicelength != value.size())
- throw std::runtime_error("Left and right hand size of slice assignment have different sizes!");
- for (size_t i=0; i<slicelength; ++i) {
- s[start] = value[i]; start += step;
- }
- })
- /// Comparisons
- .def(py::self == py::self)
- .def(py::self != py::self);
- // Could also define py::self + py::self for concatenation, etc.
-
- py::class_<StringMap> map(m, "StringMap");
-
- map .def(py::init<>())
- .def(py::init<std::unordered_map<std::string, std::string>>())
- .def("__getitem__", [](const StringMap &map, std::string key) {
- try { return map.get(key); }
- catch (const std::out_of_range&) {
- throw py::key_error("key '" + key + "' does not exist");
- }
- })
- .def("__setitem__", &StringMap::set)
- .def("__len__", &StringMap::size)
- .def("__iter__", [](const StringMap &map) { return py::make_key_iterator(map.begin(), map.end()); },
- py::keep_alive<0, 1>())
- .def("items", [](const StringMap &map) { return py::make_iterator(map.begin(), map.end()); },
- py::keep_alive<0, 1>())
- ;
-
- py::class_<IntPairs>(m, "IntPairs")
- .def(py::init<std::vector<std::pair<int, int>>>())
- .def("nonzero", [](const IntPairs& s) {
- return py::make_iterator(NonZeroIterator<std::pair<int, int>>(s.begin()), NonZeroSentinel());
- }, py::keep_alive<0, 1>())
- .def("nonzero_keys", [](const IntPairs& s) {
- return py::make_key_iterator(NonZeroIterator<std::pair<int, int>>(s.begin()), NonZeroSentinel());
- }, py::keep_alive<0, 1>());
-
-
-#if 0
- // Obsolete: special data structure for exposing custom iterator types to python
- // kept here for illustrative purposes because there might be some use cases which
- // are not covered by the much simpler py::make_iterator
-
- struct PySequenceIterator {
- PySequenceIterator(const Sequence &seq, py::object ref) : seq(seq), ref(ref) { }
-
- float next() {
- if (index == seq.size())
- throw py::stop_iteration();
- return seq[index++];
- }
-
- const Sequence &seq;
- py::object ref; // keep a reference
- size_t index = 0;
- };
-
- py::class_<PySequenceIterator>(seq, "Iterator")
- .def("__iter__", [](PySequenceIterator &it) -> PySequenceIterator& { return it; })
- .def("__next__", &PySequenceIterator::next);
-
- On the actual Sequence object, the iterator would be constructed as follows:
- .def("__iter__", [](py::object s) { return PySequenceIterator(s.cast<const Sequence &>(), s); })
-#endif
-
- m.def("object_to_list", [](py::object o) {
- auto l = py::list();
- for (auto item : o) {
- l.append(item);
- }
- return l;
- });
-
- m.def("iterator_to_list", [](py::iterator it) {
- auto l = py::list();
- while (it != py::iterator::sentinel()) {
- l.append(*it);
- ++it;
- }
- return l;
- });
-
- // Make sure that py::iterator works with std algorithms
- m.def("count_none", [](py::object o) {
- return std::count_if(o.begin(), o.end(), [](py::handle h) { return h.is_none(); });
- });
-
- m.def("find_none", [](py::object o) {
- auto it = std::find_if(o.begin(), o.end(), [](py::handle h) { return h.is_none(); });
- return it->is_none();
- });
-
- m.def("count_nonzeros", [](py::dict d) {
- return std::count_if(d.begin(), d.end(), [](std::pair<py::handle, py::handle> p) {
- return p.second.cast<int>() != 0;
- });
- });
-
- m.def("tuple_iterator", [](py::tuple x) { return test_random_access_iterator(x); });
- m.def("list_iterator", [](py::list x) { return test_random_access_iterator(x); });
- m.def("sequence_iterator", [](py::sequence x) { return test_random_access_iterator(x); });
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_sequences_and_iterators.py b/thirdparty/pybind11/pybind11/tests/test_sequences_and_iterators.py
deleted file mode 100644
index 30b6aaf4bd46ebfed1ad24e3629f8257e792ee66..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_sequences_and_iterators.py
+++ /dev/null
@@ -1,125 +0,0 @@
-import pytest
-
-
-def isclose(a, b, rel_tol=1e-05, abs_tol=0.0):
- """Like math.isclose() from Python 3.5"""
- return abs(a - b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol)
-
-
-def allclose(a_list, b_list, rel_tol=1e-05, abs_tol=0.0):
- return all(isclose(a, b, rel_tol=rel_tol, abs_tol=abs_tol) for a, b in zip(a_list, b_list))
-
-
-def test_generalized_iterators():
- from pybind11_tests.sequences_and_iterators import IntPairs
-
- assert list(IntPairs([(1, 2), (3, 4), (0, 5)]).nonzero()) == [(1, 2), (3, 4)]
- assert list(IntPairs([(1, 2), (2, 0), (0, 3), (4, 5)]).nonzero()) == [(1, 2)]
- assert list(IntPairs([(0, 3), (1, 2), (3, 4)]).nonzero()) == []
-
- assert list(IntPairs([(1, 2), (3, 4), (0, 5)]).nonzero_keys()) == [1, 3]
- assert list(IntPairs([(1, 2), (2, 0), (0, 3), (4, 5)]).nonzero_keys()) == [1]
- assert list(IntPairs([(0, 3), (1, 2), (3, 4)]).nonzero_keys()) == []
-
-
-def test_sequence():
- from pybind11_tests import ConstructorStats
- from pybind11_tests.sequences_and_iterators import Sequence
-
- cstats = ConstructorStats.get(Sequence)
-
- s = Sequence(5)
- assert cstats.values() == ['of size', '5']
-
- assert "Sequence" in repr(s)
- assert len(s) == 5
- assert s[0] == 0 and s[3] == 0
- assert 12.34 not in s
- s[0], s[3] = 12.34, 56.78
- assert 12.34 in s
- assert isclose(s[0], 12.34) and isclose(s[3], 56.78)
-
- rev = reversed(s)
- assert cstats.values() == ['of size', '5']
-
- rev2 = s[::-1]
- assert cstats.values() == ['of size', '5']
-
- expected = [0, 56.78, 0, 0, 12.34]
- assert allclose(rev, expected)
- assert allclose(rev2, expected)
- assert rev == rev2
-
- rev[0::2] = Sequence([2.0, 2.0, 2.0])
- assert cstats.values() == ['of size', '3', 'from std::vector']
-
- assert allclose(rev, [2, 56.78, 2, 0, 2])
-
- assert cstats.alive() == 3
- del s
- assert cstats.alive() == 2
- del rev
- assert cstats.alive() == 1
- del rev2
- assert cstats.alive() == 0
-
- assert cstats.values() == []
- assert cstats.default_constructions == 0
- assert cstats.copy_constructions == 0
- assert cstats.move_constructions >= 1
- assert cstats.copy_assignments == 0
- assert cstats.move_assignments == 0
-
-
-def test_map_iterator():
- from pybind11_tests.sequences_and_iterators import StringMap
-
- m = StringMap({'hi': 'bye', 'black': 'white'})
- assert m['hi'] == 'bye'
- assert len(m) == 2
- assert m['black'] == 'white'
-
- with pytest.raises(KeyError):
- assert m['orange']
- m['orange'] = 'banana'
- assert m['orange'] == 'banana'
-
- expected = {'hi': 'bye', 'black': 'white', 'orange': 'banana'}
- for k in m:
- assert m[k] == expected[k]
- for k, v in m.items():
- assert v == expected[k]
-
-
-def test_python_iterator_in_cpp():
- import pybind11_tests.sequences_and_iterators as m
-
- t = (1, 2, 3)
- assert m.object_to_list(t) == [1, 2, 3]
- assert m.object_to_list(iter(t)) == [1, 2, 3]
- assert m.iterator_to_list(iter(t)) == [1, 2, 3]
-
- with pytest.raises(TypeError) as excinfo:
- m.object_to_list(1)
- assert "object is not iterable" in str(excinfo.value)
-
- with pytest.raises(TypeError) as excinfo:
- m.iterator_to_list(1)
- assert "incompatible function arguments" in str(excinfo.value)
-
- def bad_next_call():
- raise RuntimeError("py::iterator::advance() should propagate errors")
-
- with pytest.raises(RuntimeError) as excinfo:
- m.iterator_to_list(iter(bad_next_call, None))
- assert str(excinfo.value) == "py::iterator::advance() should propagate errors"
-
- l = [1, None, 0, None]
- assert m.count_none(l) == 2
- assert m.find_none(l) is True
- assert m.count_nonzeros({"a": 0, "b": 1, "c": 2}) == 2
-
- r = range(5)
- assert all(m.tuple_iterator(tuple(r)))
- assert all(m.list_iterator(list(r)))
- assert all(m.sequence_iterator(r))
diff --git a/thirdparty/pybind11/pybind11/tests/test_smart_ptr.cpp b/thirdparty/pybind11/pybind11/tests/test_smart_ptr.cpp
deleted file mode 100644
index 83c1c018a87fac9b48e7be983c67b10d07f8662f..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_smart_ptr.cpp
+++ /dev/null
@@ -1,274 +0,0 @@
-/*
- tests/test_smart_ptr.cpp -- binding classes with custom reference counting,
- implicit conversions between types
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include "object.h"
-
-/// Custom object with builtin reference counting (see 'object.h' for the implementation)
-class MyObject1 : public Object {
-public:
- MyObject1(int value) : value(value) {
- print_created(this, toString());
- }
-
- std::string toString() const {
- return "MyObject1[" + std::to_string(value) + "]";
- }
-
-protected:
- virtual ~MyObject1() {
- print_destroyed(this);
- }
-
-private:
- int value;
-};
-
-/// Object managed by a std::shared_ptr<>
-class MyObject2 {
-public:
- MyObject2(int value) : value(value) {
- print_created(this, toString());
- }
-
- std::string toString() const {
- return "MyObject2[" + std::to_string(value) + "]";
- }
-
- virtual ~MyObject2() {
- print_destroyed(this);
- }
-
-private:
- int value;
-};
-
-/// Object managed by a std::shared_ptr<>, additionally derives from std::enable_shared_from_this<>
-class MyObject3 : public std::enable_shared_from_this<MyObject3> {
-public:
- MyObject3(int value) : value(value) {
- print_created(this, toString());
- }
-
- std::string toString() const {
- return "MyObject3[" + std::to_string(value) + "]";
- }
-
- virtual ~MyObject3() {
- print_destroyed(this);
- }
-
-private:
- int value;
-};
-
-class MyObject4 {
-public:
- MyObject4(int value) : value{value} {
- print_created(this);
- }
- int value;
-private:
- ~MyObject4() {
- print_destroyed(this);
- }
-};
-
-/// Make pybind aware of the ref-counted wrapper type (s)
-
-// ref<T> is a wrapper for 'Object' which uses intrusive reference counting
-// It is always possible to construct a ref<T> from an Object* pointer without
-// possible incosistencies, hence the 'true' argument at the end.
-PYBIND11_DECLARE_HOLDER_TYPE(T, ref<T>, true);
-PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr<T>); // Not required any more for std::shared_ptr,
- // but it should compile without error
-
-// Make pybind11 aware of the non-standard getter member function
-namespace pybind11 { namespace detail {
- template <typename T>
- struct holder_helper<ref<T>> {
- static const T *get(const ref<T> &p) { return p.get_ptr(); }
- };
-}}
-
-Object *make_object_1() { return new MyObject1(1); }
-ref<Object> make_object_2() { return new MyObject1(2); }
-
-MyObject1 *make_myobject1_1() { return new MyObject1(4); }
-ref<MyObject1> make_myobject1_2() { return new MyObject1(5); }
-
-MyObject2 *make_myobject2_1() { return new MyObject2(6); }
-std::shared_ptr<MyObject2> make_myobject2_2() { return std::make_shared<MyObject2>(7); }
-
-MyObject3 *make_myobject3_1() { return new MyObject3(8); }
-std::shared_ptr<MyObject3> make_myobject3_2() { return std::make_shared<MyObject3>(9); }
-
-void print_object_1(const Object *obj) { py::print(obj->toString()); }
-void print_object_2(ref<Object> obj) { py::print(obj->toString()); }
-void print_object_3(const ref<Object> &obj) { py::print(obj->toString()); }
-void print_object_4(const ref<Object> *obj) { py::print((*obj)->toString()); }
-
-void print_myobject1_1(const MyObject1 *obj) { py::print(obj->toString()); }
-void print_myobject1_2(ref<MyObject1> obj) { py::print(obj->toString()); }
-void print_myobject1_3(const ref<MyObject1> &obj) { py::print(obj->toString()); }
-void print_myobject1_4(const ref<MyObject1> *obj) { py::print((*obj)->toString()); }
-
-void print_myobject2_1(const MyObject2 *obj) { py::print(obj->toString()); }
-void print_myobject2_2(std::shared_ptr<MyObject2> obj) { py::print(obj->toString()); }
-void print_myobject2_3(const std::shared_ptr<MyObject2> &obj) { py::print(obj->toString()); }
-void print_myobject2_4(const std::shared_ptr<MyObject2> *obj) { py::print((*obj)->toString()); }
-
-void print_myobject3_1(const MyObject3 *obj) { py::print(obj->toString()); }
-void print_myobject3_2(std::shared_ptr<MyObject3> obj) { py::print(obj->toString()); }
-void print_myobject3_3(const std::shared_ptr<MyObject3> &obj) { py::print(obj->toString()); }
-void print_myobject3_4(const std::shared_ptr<MyObject3> *obj) { py::print((*obj)->toString()); }
-
-test_initializer smart_ptr([](py::module &m) {
- py::class_<Object, ref<Object>> obj(m, "Object");
- obj.def("getRefCount", &Object::getRefCount);
-
- py::class_<MyObject1, ref<MyObject1>>(m, "MyObject1", obj)
- .def(py::init<int>());
-
- m.def("test_object1_refcounting",
- []() -> bool {
- ref<MyObject1> o = new MyObject1(0);
- bool good = o->getRefCount() == 1;
- py::object o2 = py::cast(o, py::return_value_policy::reference);
- // always request (partial) ownership for objects with intrusive
- // reference counting even when using the 'reference' RVP
- good &= o->getRefCount() == 2;
- return good;
- }
- );
-
- m.def("make_object_1", &make_object_1);
- m.def("make_object_2", &make_object_2);
- m.def("make_myobject1_1", &make_myobject1_1);
- m.def("make_myobject1_2", &make_myobject1_2);
- m.def("print_object_1", &print_object_1);
- m.def("print_object_2", &print_object_2);
- m.def("print_object_3", &print_object_3);
- m.def("print_object_4", &print_object_4);
- m.def("print_myobject1_1", &print_myobject1_1);
- m.def("print_myobject1_2", &print_myobject1_2);
- m.def("print_myobject1_3", &print_myobject1_3);
- m.def("print_myobject1_4", &print_myobject1_4);
-
- py::class_<MyObject2, std::shared_ptr<MyObject2>>(m, "MyObject2")
- .def(py::init<int>());
- m.def("make_myobject2_1", &make_myobject2_1);
- m.def("make_myobject2_2", &make_myobject2_2);
- m.def("print_myobject2_1", &print_myobject2_1);
- m.def("print_myobject2_2", &print_myobject2_2);
- m.def("print_myobject2_3", &print_myobject2_3);
- m.def("print_myobject2_4", &print_myobject2_4);
-
- py::class_<MyObject3, std::shared_ptr<MyObject3>>(m, "MyObject3")
- .def(py::init<int>());
- m.def("make_myobject3_1", &make_myobject3_1);
- m.def("make_myobject3_2", &make_myobject3_2);
- m.def("print_myobject3_1", &print_myobject3_1);
- m.def("print_myobject3_2", &print_myobject3_2);
- m.def("print_myobject3_3", &print_myobject3_3);
- m.def("print_myobject3_4", &print_myobject3_4);
-
- py::class_<MyObject4, std::unique_ptr<MyObject4, py::nodelete>>(m, "MyObject4")
- .def(py::init<int>())
- .def_readwrite("value", &MyObject4::value);
-
- py::implicitly_convertible<py::int_, MyObject1>();
-
- // Expose constructor stats for the ref type
- m.def("cstats_ref", &ConstructorStats::get<ref_tag>);
-});
-
-struct SharedPtrRef {
- struct A {
- A() { print_created(this); }
- A(const A &) { print_copy_created(this); }
- A(A &&) { print_move_created(this); }
- ~A() { print_destroyed(this); }
- };
-
- A value = {};
- std::shared_ptr<A> shared = std::make_shared<A>();
-};
-
-struct SharedFromThisRef {
- struct B : std::enable_shared_from_this<B> {
- B() { print_created(this); }
- B(const B &) : std::enable_shared_from_this<B>() { print_copy_created(this); }
- B(B &&) : std::enable_shared_from_this<B>() { print_move_created(this); }
- ~B() { print_destroyed(this); }
- };
-
- B value = {};
- std::shared_ptr<B> shared = std::make_shared<B>();
-};
-
-template <typename T>
-class CustomUniquePtr {
- std::unique_ptr<T> impl;
-
-public:
- CustomUniquePtr(T* p) : impl(p) { }
- T* get() const { return impl.get(); }
- T* release_ptr() { return impl.release(); }
-};
-
-PYBIND11_DECLARE_HOLDER_TYPE(T, CustomUniquePtr<T>);
-
-test_initializer smart_ptr_and_references([](py::module &pm) {
- auto m = pm.def_submodule("smart_ptr");
-
- using A = SharedPtrRef::A;
- py::class_<A, std::shared_ptr<A>>(m, "A");
-
- py::class_<SharedPtrRef>(m, "SharedPtrRef")
- .def(py::init<>())
- .def_readonly("ref", &SharedPtrRef::value)
- .def_property_readonly("copy", [](const SharedPtrRef &s) { return s.value; },
- py::return_value_policy::copy)
- .def_readonly("holder_ref", &SharedPtrRef::shared)
- .def_property_readonly("holder_copy", [](const SharedPtrRef &s) { return s.shared; },
- py::return_value_policy::copy)
- .def("set_ref", [](SharedPtrRef &, const A &) { return true; })
- .def("set_holder", [](SharedPtrRef &, std::shared_ptr<A>) { return true; });
-
- using B = SharedFromThisRef::B;
- py::class_<B, std::shared_ptr<B>>(m, "B");
-
- py::class_<SharedFromThisRef>(m, "SharedFromThisRef")
- .def(py::init<>())
- .def_readonly("bad_wp", &SharedFromThisRef::value)
- .def_property_readonly("ref", [](const SharedFromThisRef &s) -> const B & { return *s.shared; })
- .def_property_readonly("copy", [](const SharedFromThisRef &s) { return s.value; },
- py::return_value_policy::copy)
- .def_readonly("holder_ref", &SharedFromThisRef::shared)
- .def_property_readonly("holder_copy", [](const SharedFromThisRef &s) { return s.shared; },
- py::return_value_policy::copy)
- .def("set_ref", [](SharedFromThisRef &, const B &) { return true; })
- .def("set_holder", [](SharedFromThisRef &, std::shared_ptr<B>) { return true; });
-
- struct C {
- C() { print_created(this); }
- ~C() { print_destroyed(this); }
- };
-
- py::class_<C, CustomUniquePtr<C>>(m, "TypeWithMoveOnlyHolder")
- .def_static("make", []() { return CustomUniquePtr<C>(new C); });
-
- struct HeldByDefaultHolder { };
-
- py::class_<HeldByDefaultHolder>(m, "HeldByDefaultHolder")
- .def(py::init<>())
- .def_static("load_shared_ptr", [](std::shared_ptr<HeldByDefaultHolder>) {});
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_smart_ptr.py b/thirdparty/pybind11/pybind11/tests/test_smart_ptr.py
deleted file mode 100644
index b5af3bd389d427d63bdfefe51bdbee319507db49..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_smart_ptr.py
+++ /dev/null
@@ -1,222 +0,0 @@
-import pytest
-from pybind11_tests import ConstructorStats
-
-
-def test_smart_ptr(capture):
- # Object1
- from pybind11_tests import (MyObject1, make_object_1, make_object_2,
- print_object_1, print_object_2, print_object_3, print_object_4)
-
- for i, o in enumerate([make_object_1(), make_object_2(), MyObject1(3)], start=1):
- assert o.getRefCount() == 1
- with capture:
- print_object_1(o)
- print_object_2(o)
- print_object_3(o)
- print_object_4(o)
- assert capture == "MyObject1[{i}]\n".format(i=i) * 4
-
- from pybind11_tests import (make_myobject1_1, make_myobject1_2,
- print_myobject1_1, print_myobject1_2,
- print_myobject1_3, print_myobject1_4)
-
- for i, o in enumerate([make_myobject1_1(), make_myobject1_2(), MyObject1(6), 7], start=4):
- print(o)
- with capture:
- if not isinstance(o, int):
- print_object_1(o)
- print_object_2(o)
- print_object_3(o)
- print_object_4(o)
- print_myobject1_1(o)
- print_myobject1_2(o)
- print_myobject1_3(o)
- print_myobject1_4(o)
- assert capture == "MyObject1[{i}]\n".format(i=i) * (4 if isinstance(o, int) else 8)
-
- cstats = ConstructorStats.get(MyObject1)
- assert cstats.alive() == 0
- expected_values = ['MyObject1[{}]'.format(i) for i in range(1, 7)] + ['MyObject1[7]'] * 4
- assert cstats.values() == expected_values
- assert cstats.default_constructions == 0
- assert cstats.copy_constructions == 0
- # assert cstats.move_constructions >= 0 # Doesn't invoke any
- assert cstats.copy_assignments == 0
- assert cstats.move_assignments == 0
-
- # Object2
- from pybind11_tests import (MyObject2, make_myobject2_1, make_myobject2_2,
- make_myobject3_1, make_myobject3_2,
- print_myobject2_1, print_myobject2_2,
- print_myobject2_3, print_myobject2_4)
-
- for i, o in zip([8, 6, 7], [MyObject2(8), make_myobject2_1(), make_myobject2_2()]):
- print(o)
- with capture:
- print_myobject2_1(o)
- print_myobject2_2(o)
- print_myobject2_3(o)
- print_myobject2_4(o)
- assert capture == "MyObject2[{i}]\n".format(i=i) * 4
-
- cstats = ConstructorStats.get(MyObject2)
- assert cstats.alive() == 1
- o = None
- assert cstats.alive() == 0
- assert cstats.values() == ['MyObject2[8]', 'MyObject2[6]', 'MyObject2[7]']
- assert cstats.default_constructions == 0
- assert cstats.copy_constructions == 0
- # assert cstats.move_constructions >= 0 # Doesn't invoke any
- assert cstats.copy_assignments == 0
- assert cstats.move_assignments == 0
-
- # Object3
- from pybind11_tests import (MyObject3, print_myobject3_1, print_myobject3_2,
- print_myobject3_3, print_myobject3_4)
-
- for i, o in zip([9, 8, 9], [MyObject3(9), make_myobject3_1(), make_myobject3_2()]):
- print(o)
- with capture:
- print_myobject3_1(o)
- print_myobject3_2(o)
- print_myobject3_3(o)
- print_myobject3_4(o)
- assert capture == "MyObject3[{i}]\n".format(i=i) * 4
-
- cstats = ConstructorStats.get(MyObject3)
- assert cstats.alive() == 1
- o = None
- assert cstats.alive() == 0
- assert cstats.values() == ['MyObject3[9]', 'MyObject3[8]', 'MyObject3[9]']
- assert cstats.default_constructions == 0
- assert cstats.copy_constructions == 0
- # assert cstats.move_constructions >= 0 # Doesn't invoke any
- assert cstats.copy_assignments == 0
- assert cstats.move_assignments == 0
-
- # Object and ref
- from pybind11_tests import Object, cstats_ref
-
- cstats = ConstructorStats.get(Object)
- assert cstats.alive() == 0
- assert cstats.values() == []
- assert cstats.default_constructions == 10
- assert cstats.copy_constructions == 0
- # assert cstats.move_constructions >= 0 # Doesn't invoke any
- assert cstats.copy_assignments == 0
- assert cstats.move_assignments == 0
-
- cstats = cstats_ref()
- assert cstats.alive() == 0
- assert cstats.values() == ['from pointer'] * 10
- assert cstats.default_constructions == 30
- assert cstats.copy_constructions == 12
- # assert cstats.move_constructions >= 0 # Doesn't invoke any
- assert cstats.copy_assignments == 30
- assert cstats.move_assignments == 0
-
-
-def test_smart_ptr_refcounting():
- from pybind11_tests import test_object1_refcounting
- assert test_object1_refcounting()
-
-
-def test_unique_nodelete():
- from pybind11_tests import MyObject4
- o = MyObject4(23)
- assert o.value == 23
- cstats = ConstructorStats.get(MyObject4)
- assert cstats.alive() == 1
- del o
- cstats = ConstructorStats.get(MyObject4)
- assert cstats.alive() == 1 # Leak, but that's intentional
-
-
-def test_shared_ptr_and_references():
- from pybind11_tests.smart_ptr import SharedPtrRef, A
-
- s = SharedPtrRef()
- stats = ConstructorStats.get(A)
- assert stats.alive() == 2
-
- ref = s.ref # init_holder_helper(holder_ptr=false, owned=false)
- assert stats.alive() == 2
- assert s.set_ref(ref)
- with pytest.raises(RuntimeError) as excinfo:
- assert s.set_holder(ref)
- assert "Unable to cast from non-held to held instance" in str(excinfo.value)
-
- copy = s.copy # init_holder_helper(holder_ptr=false, owned=true)
- assert stats.alive() == 3
- assert s.set_ref(copy)
- assert s.set_holder(copy)
-
- holder_ref = s.holder_ref # init_holder_helper(holder_ptr=true, owned=false)
- assert stats.alive() == 3
- assert s.set_ref(holder_ref)
- assert s.set_holder(holder_ref)
-
- holder_copy = s.holder_copy # init_holder_helper(holder_ptr=true, owned=true)
- assert stats.alive() == 3
- assert s.set_ref(holder_copy)
- assert s.set_holder(holder_copy)
-
- del ref, copy, holder_ref, holder_copy, s
- assert stats.alive() == 0
-
-
-def test_shared_ptr_from_this_and_references():
- from pybind11_tests.smart_ptr import SharedFromThisRef, B
-
- s = SharedFromThisRef()
- stats = ConstructorStats.get(B)
- assert stats.alive() == 2
-
- ref = s.ref # init_holder_helper(holder_ptr=false, owned=false, bad_wp=false)
- assert stats.alive() == 2
- assert s.set_ref(ref)
- assert s.set_holder(ref) # std::enable_shared_from_this can create a holder from a reference
-
- bad_wp = s.bad_wp # init_holder_helper(holder_ptr=false, owned=false, bad_wp=true)
- assert stats.alive() == 2
- assert s.set_ref(bad_wp)
- with pytest.raises(RuntimeError) as excinfo:
- assert s.set_holder(bad_wp)
- assert "Unable to cast from non-held to held instance" in str(excinfo.value)
-
- copy = s.copy # init_holder_helper(holder_ptr=false, owned=true, bad_wp=false)
- assert stats.alive() == 3
- assert s.set_ref(copy)
- assert s.set_holder(copy)
-
- holder_ref = s.holder_ref # init_holder_helper(holder_ptr=true, owned=false, bad_wp=false)
- assert stats.alive() == 3
- assert s.set_ref(holder_ref)
- assert s.set_holder(holder_ref)
-
- holder_copy = s.holder_copy # init_holder_helper(holder_ptr=true, owned=true, bad_wp=false)
- assert stats.alive() == 3
- assert s.set_ref(holder_copy)
- assert s.set_holder(holder_copy)
-
- del ref, bad_wp, copy, holder_ref, holder_copy, s
- assert stats.alive() == 0
-
-
-def test_move_only_holder():
- from pybind11_tests.smart_ptr import TypeWithMoveOnlyHolder
-
- a = TypeWithMoveOnlyHolder.make()
- stats = ConstructorStats.get(TypeWithMoveOnlyHolder)
- assert stats.alive() == 1
- del a
- assert stats.alive() == 0
-
-
-def test_smart_ptr_from_default():
- from pybind11_tests.smart_ptr import HeldByDefaultHolder
-
- instance = HeldByDefaultHolder()
- with pytest.raises(RuntimeError) as excinfo:
- HeldByDefaultHolder.load_shared_ptr(instance)
- assert "Unable to load a custom holder type from a default-holder instance" in str(excinfo)
diff --git a/thirdparty/pybind11/pybind11/tests/test_stl_binders.cpp b/thirdparty/pybind11/pybind11/tests/test_stl_binders.cpp
deleted file mode 100644
index f636c0b55ecb330aa7d909af368e8cbc23d114f4..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_stl_binders.cpp
+++ /dev/null
@@ -1,128 +0,0 @@
-/*
- tests/test_stl_binders.cpp -- Usage of stl_binders functions
-
- Copyright (c) 2016 Sergey Lyskov
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-
-#include <pybind11/stl_bind.h>
-#include <pybind11/numpy.h>
-#include <map>
-#include <deque>
-#include <unordered_map>
-
-#ifdef _MSC_VER
-// We get some really long type names here which causes MSVC to emit warnings
-# pragma warning(disable: 4503) // warning C4503: decorated name length exceeded, name was truncated
-#endif
-
-class El {
-public:
- El() = delete;
- El(int v) : a(v) { }
-
- int a;
-};
-
-std::ostream & operator<<(std::ostream &s, El const&v) {
- s << "El{" << v.a << '}';
- return s;
-}
-
-/// Issue #487: binding std::vector<E> with E non-copyable
-class E_nc {
-public:
- explicit E_nc(int i) : value{i} {}
- E_nc(const E_nc &) = delete;
- E_nc &operator=(const E_nc &) = delete;
- E_nc(E_nc &&) = default;
- E_nc &operator=(E_nc &&) = default;
-
- int value;
-};
-
-template <class Container> Container *one_to_n(int n) {
- auto v = new Container();
- for (int i = 1; i <= n; i++)
- v->emplace_back(i);
- return v;
-}
-
-template <class Map> Map *times_ten(int n) {
- auto m = new Map();
- for (int i = 1; i <= n; i++)
- m->emplace(int(i), E_nc(10*i));
- return m;
-}
-
-struct VStruct {
- bool w;
- uint32_t x;
- double y;
- bool z;
-};
-
-struct VUndeclStruct { //dtype not declared for this version
- bool w;
- uint32_t x;
- double y;
- bool z;
-};
-
-test_initializer stl_binder_vector([](py::module &m) {
- py::class_<El>(m, "El")
- .def(py::init<int>());
-
- py::bind_vector<std::vector<unsigned char>>(m, "VectorUChar", py::buffer_protocol());
- py::bind_vector<std::vector<unsigned int>>(m, "VectorInt", py::buffer_protocol());
- py::bind_vector<std::vector<bool>>(m, "VectorBool");
-
- py::bind_vector<std::vector<El>>(m, "VectorEl");
-
- py::bind_vector<std::vector<std::vector<El>>>(m, "VectorVectorEl");
-
- m.def("create_undeclstruct", [m] () mutable {
- py::bind_vector<std::vector<VUndeclStruct>>(m, "VectorUndeclStruct", py::buffer_protocol());
- });
-
- try {
- py::module::import("numpy");
- } catch (...) {
- return;
- }
- PYBIND11_NUMPY_DTYPE(VStruct, w, x, y, z);
- py::class_<VStruct>(m, "VStruct").def_readwrite("x", &VStruct::x);
- py::bind_vector<std::vector<VStruct>>(m, "VectorStruct", py::buffer_protocol());
- m.def("get_vectorstruct", [] {return std::vector<VStruct> {{0, 5, 3.0, 1}, {1, 30, -1e4, 0}};});
-});
-
-test_initializer stl_binder_map([](py::module &m) {
- py::bind_map<std::map<std::string, double>>(m, "MapStringDouble");
- py::bind_map<std::unordered_map<std::string, double>>(m, "UnorderedMapStringDouble");
-
- py::bind_map<std::map<std::string, double const>>(m, "MapStringDoubleConst");
- py::bind_map<std::unordered_map<std::string, double const>>(m, "UnorderedMapStringDoubleConst");
-
-});
-
-test_initializer stl_binder_noncopyable([](py::module &m) {
- py::class_<E_nc>(m, "ENC")
- .def(py::init<int>())
- .def_readwrite("value", &E_nc::value);
-
- py::bind_vector<std::vector<E_nc>>(m, "VectorENC");
- m.def("get_vnc", &one_to_n<std::vector<E_nc>>, py::return_value_policy::reference);
-
- py::bind_vector<std::deque<E_nc>>(m, "DequeENC");
- m.def("get_dnc", &one_to_n<std::deque<E_nc>>, py::return_value_policy::reference);
-
- py::bind_map<std::map<int, E_nc>>(m, "MapENC");
- m.def("get_mnc", ×_ten<std::map<int, E_nc>>, py::return_value_policy::reference);
-
- py::bind_map<std::unordered_map<int, E_nc>>(m, "UmapENC");
- m.def("get_umnc", ×_ten<std::unordered_map<int, E_nc>>, py::return_value_policy::reference);
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_stl_binders.py b/thirdparty/pybind11/pybind11/tests/test_stl_binders.py
deleted file mode 100644
index 0edf9e26ee5b4c075ef880fc72c7216c048a4cfd..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_stl_binders.py
+++ /dev/null
@@ -1,198 +0,0 @@
-import pytest
-import sys
-
-with pytest.suppress(ImportError):
- import numpy as np
-
-
-def test_vector_int():
- from pybind11_tests import VectorInt
-
- v_int = VectorInt([0, 0])
- assert len(v_int) == 2
- assert bool(v_int) is True
-
- v_int2 = VectorInt([0, 0])
- assert v_int == v_int2
- v_int2[1] = 1
- assert v_int != v_int2
-
- v_int2.append(2)
- v_int2.append(3)
- v_int2.insert(0, 1)
- v_int2.insert(0, 2)
- v_int2.insert(0, 3)
- assert str(v_int2) == "VectorInt[3, 2, 1, 0, 1, 2, 3]"
-
- v_int.append(99)
- v_int2[2:-2] = v_int
- assert v_int2 == VectorInt([3, 2, 0, 0, 99, 2, 3])
- del v_int2[1:3]
- assert v_int2 == VectorInt([3, 0, 99, 2, 3])
- del v_int2[0]
- assert v_int2 == VectorInt([0, 99, 2, 3])
-
-
-@pytest.unsupported_on_pypy
-def test_vector_buffer():
- from pybind11_tests import VectorUChar, create_undeclstruct
- b = bytearray([1, 2, 3, 4])
- v = VectorUChar(b)
- assert v[1] == 2
- v[2] = 5
- m = memoryview(v) # We expose the buffer interface
- if sys.version_info.major > 2:
- assert m[2] == 5
- m[2] = 6
- else:
- assert m[2] == '\x05'
- m[2] = '\x06'
- assert v[2] == 6
-
- with pytest.raises(RuntimeError):
- create_undeclstruct() # Undeclared struct contents, no buffer interface
-
-
-@pytest.requires_numpy
-def test_vector_buffer_numpy():
- from pybind11_tests import VectorInt, VectorStruct, get_vectorstruct
-
- a = np.array([1, 2, 3, 4], dtype=np.int32)
- with pytest.raises(TypeError):
- VectorInt(a)
-
- a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]], dtype=np.uintc)
- v = VectorInt(a[0, :])
- assert len(v) == 4
- assert v[2] == 3
- m = np.asarray(v)
- m[2] = 5
- assert v[2] == 5
-
- v = VectorInt(a[:, 1])
- assert len(v) == 3
- assert v[2] == 10
-
- v = get_vectorstruct()
- assert v[0].x == 5
- m = np.asarray(v)
- m[1]['x'] = 99
- assert v[1].x == 99
-
- v = VectorStruct(np.zeros(3, dtype=np.dtype([('w', 'bool'), ('x', 'I'),
- ('y', 'float64'), ('z', 'bool')], align=True)))
- assert len(v) == 3
-
-
-def test_vector_custom():
- from pybind11_tests import El, VectorEl, VectorVectorEl
-
- v_a = VectorEl()
- v_a.append(El(1))
- v_a.append(El(2))
- assert str(v_a) == "VectorEl[El{1}, El{2}]"
-
- vv_a = VectorVectorEl()
- vv_a.append(v_a)
- vv_b = vv_a[0]
- assert str(vv_b) == "VectorEl[El{1}, El{2}]"
-
-
-def test_vector_bool():
- from pybind11_tests import VectorBool
-
- vv_c = VectorBool()
- for i in range(10):
- vv_c.append(i % 2 == 0)
- for i in range(10):
- assert vv_c[i] == (i % 2 == 0)
- assert str(vv_c) == "VectorBool[1, 0, 1, 0, 1, 0, 1, 0, 1, 0]"
-
-
-def test_map_string_double():
- from pybind11_tests import MapStringDouble, UnorderedMapStringDouble
-
- m = MapStringDouble()
- m['a'] = 1
- m['b'] = 2.5
-
- assert list(m) == ['a', 'b']
- assert list(m.items()) == [('a', 1), ('b', 2.5)]
- assert str(m) == "MapStringDouble{a: 1, b: 2.5}"
-
- um = UnorderedMapStringDouble()
- um['ua'] = 1.1
- um['ub'] = 2.6
-
- assert sorted(list(um)) == ['ua', 'ub']
- assert sorted(list(um.items())) == [('ua', 1.1), ('ub', 2.6)]
- assert "UnorderedMapStringDouble" in str(um)
-
-
-def test_map_string_double_const():
- from pybind11_tests import MapStringDoubleConst, UnorderedMapStringDoubleConst
-
- mc = MapStringDoubleConst()
- mc['a'] = 10
- mc['b'] = 20.5
- assert str(mc) == "MapStringDoubleConst{a: 10, b: 20.5}"
-
- umc = UnorderedMapStringDoubleConst()
- umc['a'] = 11
- umc['b'] = 21.5
-
- str(umc)
-
-
-def test_noncopyable_vector():
- from pybind11_tests import get_vnc
-
- vnc = get_vnc(5)
- for i in range(0, 5):
- assert vnc[i].value == i + 1
-
- for i, j in enumerate(vnc, start=1):
- assert j.value == i
-
-
-def test_noncopyable_deque():
- from pybind11_tests import get_dnc
-
- dnc = get_dnc(5)
- for i in range(0, 5):
- assert dnc[i].value == i + 1
-
- i = 1
- for j in dnc:
- assert(j.value == i)
- i += 1
-
-
-def test_noncopyable_map():
- from pybind11_tests import get_mnc
-
- mnc = get_mnc(5)
- for i in range(1, 6):
- assert mnc[i].value == 10 * i
-
- vsum = 0
- for k, v in mnc.items():
- assert v.value == 10 * k
- vsum += v.value
-
- assert vsum == 150
-
-
-def test_noncopyable_unordered_map():
- from pybind11_tests import get_umnc
-
- mnc = get_umnc(5)
- for i in range(1, 6):
- assert mnc[i].value == 10 * i
-
- vsum = 0
- for k, v in mnc.items():
- assert v.value == 10 * k
- vsum += v.value
-
- assert vsum == 150
diff --git a/thirdparty/pybind11/pybind11/tests/test_virtual_functions.cpp b/thirdparty/pybind11/pybind11/tests/test_virtual_functions.cpp
deleted file mode 100644
index 0f8ed2afb247058af27178e2d48ed1f50ec7dd51..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_virtual_functions.cpp
+++ /dev/null
@@ -1,347 +0,0 @@
-/*
- tests/test_virtual_functions.cpp -- overriding virtual functions from Python
-
- Copyright (c) 2016 Wenzel Jakob <wenzel.jakob@epfl.ch>
-
- All rights reserved. Use of this source code is governed by a
- BSD-style license that can be found in the LICENSE file.
-*/
-
-#include "pybind11_tests.h"
-#include "constructor_stats.h"
-#include <pybind11/functional.h>
-
-/* This is an example class that we'll want to be able to extend from Python */
-class ExampleVirt {
-public:
- ExampleVirt(int state) : state(state) { print_created(this, state); }
- ExampleVirt(const ExampleVirt &e) : state(e.state) { print_copy_created(this); }
- ExampleVirt(ExampleVirt &&e) : state(e.state) { print_move_created(this); e.state = 0; }
- ~ExampleVirt() { print_destroyed(this); }
-
- virtual int run(int value) {
- py::print("Original implementation of "
- "ExampleVirt::run(state={}, value={}, str1={}, str2={})"_s.format(state, value, get_string1(), *get_string2()));
- return state + value;
- }
-
- virtual bool run_bool() = 0;
- virtual void pure_virtual() = 0;
-
- // Returning a reference/pointer to a type converted from python (numbers, strings, etc.) is a
- // bit trickier, because the actual int& or std::string& or whatever only exists temporarily, so
- // we have to handle it specially in the trampoline class (see below).
- virtual const std::string &get_string1() { return str1; }
- virtual const std::string *get_string2() { return &str2; }
-
-private:
- int state;
- const std::string str1{"default1"}, str2{"default2"};
-};
-
-/* This is a wrapper class that must be generated */
-class PyExampleVirt : public ExampleVirt {
-public:
- using ExampleVirt::ExampleVirt; /* Inherit constructors */
-
- int run(int value) override {
- /* Generate wrapping code that enables native function overloading */
- PYBIND11_OVERLOAD(
- int, /* Return type */
- ExampleVirt, /* Parent class */
- run, /* Name of function */
- value /* Argument(s) */
- );
- }
-
- bool run_bool() override {
- PYBIND11_OVERLOAD_PURE(
- bool, /* Return type */
- ExampleVirt, /* Parent class */
- run_bool, /* Name of function */
- /* This function has no arguments. The trailing comma
- in the previous line is needed for some compilers */
- );
- }
-
- void pure_virtual() override {
- PYBIND11_OVERLOAD_PURE(
- void, /* Return type */
- ExampleVirt, /* Parent class */
- pure_virtual, /* Name of function */
- /* This function has no arguments. The trailing comma
- in the previous line is needed for some compilers */
- );
- }
-
- // We can return reference types for compatibility with C++ virtual interfaces that do so, but
- // note they have some significant limitations (see the documentation).
- const std::string &get_string1() override {
- PYBIND11_OVERLOAD(
- const std::string &, /* Return type */
- ExampleVirt, /* Parent class */
- get_string1, /* Name of function */
- /* (no arguments) */
- );
- }
-
- const std::string *get_string2() override {
- PYBIND11_OVERLOAD(
- const std::string *, /* Return type */
- ExampleVirt, /* Parent class */
- get_string2, /* Name of function */
- /* (no arguments) */
- );
- }
-
-};
-
-class NonCopyable {
-public:
- NonCopyable(int a, int b) : value{new int(a*b)} { print_created(this, a, b); }
- NonCopyable(NonCopyable &&o) { value = std::move(o.value); print_move_created(this); }
- NonCopyable(const NonCopyable &) = delete;
- NonCopyable() = delete;
- void operator=(const NonCopyable &) = delete;
- void operator=(NonCopyable &&) = delete;
- std::string get_value() const {
- if (value) return std::to_string(*value); else return "(null)";
- }
- ~NonCopyable() { print_destroyed(this); }
-
-private:
- std::unique_ptr<int> value;
-};
-
-// This is like the above, but is both copy and movable. In effect this means it should get moved
-// when it is not referenced elsewhere, but copied if it is still referenced.
-class Movable {
-public:
- Movable(int a, int b) : value{a+b} { print_created(this, a, b); }
- Movable(const Movable &m) { value = m.value; print_copy_created(this); }
- Movable(Movable &&m) { value = std::move(m.value); print_move_created(this); }
- std::string get_value() const { return std::to_string(value); }
- ~Movable() { print_destroyed(this); }
-private:
- int value;
-};
-
-class NCVirt {
-public:
- virtual NonCopyable get_noncopyable(int a, int b) { return NonCopyable(a, b); }
- virtual Movable get_movable(int a, int b) = 0;
-
- std::string print_nc(int a, int b) { return get_noncopyable(a, b).get_value(); }
- std::string print_movable(int a, int b) { return get_movable(a, b).get_value(); }
-};
-class NCVirtTrampoline : public NCVirt {
-#if !defined(__INTEL_COMPILER)
- NonCopyable get_noncopyable(int a, int b) override {
- PYBIND11_OVERLOAD(NonCopyable, NCVirt, get_noncopyable, a, b);
- }
-#endif
- Movable get_movable(int a, int b) override {
- PYBIND11_OVERLOAD_PURE(Movable, NCVirt, get_movable, a, b);
- }
-};
-
-int runExampleVirt(ExampleVirt *ex, int value) {
- return ex->run(value);
-}
-
-bool runExampleVirtBool(ExampleVirt* ex) {
- return ex->run_bool();
-}
-
-void runExampleVirtVirtual(ExampleVirt *ex) {
- ex->pure_virtual();
-}
-
-
-// Inheriting virtual methods. We do two versions here: the repeat-everything version and the
-// templated trampoline versions mentioned in docs/advanced.rst.
-//
-// These base classes are exactly the same, but we technically need distinct
-// classes for this example code because we need to be able to bind them
-// properly (pybind11, sensibly, doesn't allow us to bind the same C++ class to
-// multiple python classes).
-class A_Repeat {
-#define A_METHODS \
-public: \
- virtual int unlucky_number() = 0; \
- virtual std::string say_something(unsigned times) { \
- std::string s = ""; \
- for (unsigned i = 0; i < times; ++i) \
- s += "hi"; \
- return s; \
- } \
- std::string say_everything() { \
- return say_something(1) + " " + std::to_string(unlucky_number()); \
- }
-A_METHODS
-};
-class B_Repeat : public A_Repeat {
-#define B_METHODS \
-public: \
- int unlucky_number() override { return 13; } \
- std::string say_something(unsigned times) override { \
- return "B says hi " + std::to_string(times) + " times"; \
- } \
- virtual double lucky_number() { return 7.0; }
-B_METHODS
-};
-class C_Repeat : public B_Repeat {
-#define C_METHODS \
-public: \
- int unlucky_number() override { return 4444; } \
- double lucky_number() override { return 888; }
-C_METHODS
-};
-class D_Repeat : public C_Repeat {
-#define D_METHODS // Nothing overridden.
-D_METHODS
-};
-
-// Base classes for templated inheritance trampolines. Identical to the repeat-everything version:
-class A_Tpl { A_METHODS };
-class B_Tpl : public A_Tpl { B_METHODS };
-class C_Tpl : public B_Tpl { C_METHODS };
-class D_Tpl : public C_Tpl { D_METHODS };
-
-
-// Inheritance approach 1: each trampoline gets every virtual method (11 in total)
-class PyA_Repeat : public A_Repeat {
-public:
- using A_Repeat::A_Repeat;
- int unlucky_number() override { PYBIND11_OVERLOAD_PURE(int, A_Repeat, unlucky_number, ); }
- std::string say_something(unsigned times) override { PYBIND11_OVERLOAD(std::string, A_Repeat, say_something, times); }
-};
-class PyB_Repeat : public B_Repeat {
-public:
- using B_Repeat::B_Repeat;
- int unlucky_number() override { PYBIND11_OVERLOAD(int, B_Repeat, unlucky_number, ); }
- std::string say_something(unsigned times) override { PYBIND11_OVERLOAD(std::string, B_Repeat, say_something, times); }
- double lucky_number() override { PYBIND11_OVERLOAD(double, B_Repeat, lucky_number, ); }
-};
-class PyC_Repeat : public C_Repeat {
-public:
- using C_Repeat::C_Repeat;
- int unlucky_number() override { PYBIND11_OVERLOAD(int, C_Repeat, unlucky_number, ); }
- std::string say_something(unsigned times) override { PYBIND11_OVERLOAD(std::string, C_Repeat, say_something, times); }
- double lucky_number() override { PYBIND11_OVERLOAD(double, C_Repeat, lucky_number, ); }
-};
-class PyD_Repeat : public D_Repeat {
-public:
- using D_Repeat::D_Repeat;
- int unlucky_number() override { PYBIND11_OVERLOAD(int, D_Repeat, unlucky_number, ); }
- std::string say_something(unsigned times) override { PYBIND11_OVERLOAD(std::string, D_Repeat, say_something, times); }
- double lucky_number() override { PYBIND11_OVERLOAD(double, D_Repeat, lucky_number, ); }
-};
-
-// Inheritance approach 2: templated trampoline classes.
-//
-// Advantages:
-// - we have only 2 (template) class and 4 method declarations (one per virtual method, plus one for
-// any override of a pure virtual method), versus 4 classes and 6 methods (MI) or 4 classes and 11
-// methods (repeat).
-// - Compared to MI, we also don't have to change the non-trampoline inheritance to virtual, and can
-// properly inherit constructors.
-//
-// Disadvantage:
-// - the compiler must still generate and compile 14 different methods (more, even, than the 11
-// required for the repeat approach) instead of the 6 required for MI. (If there was no pure
-// method (or no pure method override), the number would drop down to the same 11 as the repeat
-// approach).
-template <class Base = A_Tpl>
-class PyA_Tpl : public Base {
-public:
- using Base::Base; // Inherit constructors
- int unlucky_number() override { PYBIND11_OVERLOAD_PURE(int, Base, unlucky_number, ); }
- std::string say_something(unsigned times) override { PYBIND11_OVERLOAD(std::string, Base, say_something, times); }
-};
-template <class Base = B_Tpl>
-class PyB_Tpl : public PyA_Tpl<Base> {
-public:
- using PyA_Tpl<Base>::PyA_Tpl; // Inherit constructors (via PyA_Tpl's inherited constructors)
- int unlucky_number() override { PYBIND11_OVERLOAD(int, Base, unlucky_number, ); }
- double lucky_number() override { PYBIND11_OVERLOAD(double, Base, lucky_number, ); }
-};
-// Since C_Tpl and D_Tpl don't declare any new virtual methods, we don't actually need these (we can
-// use PyB_Tpl<C_Tpl> and PyB_Tpl<D_Tpl> for the trampoline classes instead):
-/*
-template <class Base = C_Tpl> class PyC_Tpl : public PyB_Tpl<Base> {
-public:
- using PyB_Tpl<Base>::PyB_Tpl;
-};
-template <class Base = D_Tpl> class PyD_Tpl : public PyC_Tpl<Base> {
-public:
- using PyC_Tpl<Base>::PyC_Tpl;
-};
-*/
-
-
-void initialize_inherited_virtuals(py::module &m) {
- // Method 1: repeat
- py::class_<A_Repeat, PyA_Repeat>(m, "A_Repeat")
- .def(py::init<>())
- .def("unlucky_number", &A_Repeat::unlucky_number)
- .def("say_something", &A_Repeat::say_something)
- .def("say_everything", &A_Repeat::say_everything);
- py::class_<B_Repeat, A_Repeat, PyB_Repeat>(m, "B_Repeat")
- .def(py::init<>())
- .def("lucky_number", &B_Repeat::lucky_number);
- py::class_<C_Repeat, B_Repeat, PyC_Repeat>(m, "C_Repeat")
- .def(py::init<>());
- py::class_<D_Repeat, C_Repeat, PyD_Repeat>(m, "D_Repeat")
- .def(py::init<>());
-
- // Method 2: Templated trampolines
- py::class_<A_Tpl, PyA_Tpl<>>(m, "A_Tpl")
- .def(py::init<>())
- .def("unlucky_number", &A_Tpl::unlucky_number)
- .def("say_something", &A_Tpl::say_something)
- .def("say_everything", &A_Tpl::say_everything);
- py::class_<B_Tpl, A_Tpl, PyB_Tpl<>>(m, "B_Tpl")
- .def(py::init<>())
- .def("lucky_number", &B_Tpl::lucky_number);
- py::class_<C_Tpl, B_Tpl, PyB_Tpl<C_Tpl>>(m, "C_Tpl")
- .def(py::init<>());
- py::class_<D_Tpl, C_Tpl, PyB_Tpl<D_Tpl>>(m, "D_Tpl")
- .def(py::init<>());
-
-};
-
-
-test_initializer virtual_functions([](py::module &m) {
- /* Important: indicate the trampoline class PyExampleVirt using the third
- argument to py::class_. The second argument with the unique pointer
- is simply the default holder type used by pybind11. */
- py::class_<ExampleVirt, PyExampleVirt>(m, "ExampleVirt")
- .def(py::init<int>())
- /* Reference original class in function definitions */
- .def("run", &ExampleVirt::run)
- .def("run_bool", &ExampleVirt::run_bool)
- .def("pure_virtual", &ExampleVirt::pure_virtual);
-
- py::class_<NonCopyable>(m, "NonCopyable")
- .def(py::init<int, int>());
-
- py::class_<Movable>(m, "Movable")
- .def(py::init<int, int>());
-
-#if !defined(__INTEL_COMPILER)
- py::class_<NCVirt, NCVirtTrampoline>(m, "NCVirt")
- .def(py::init<>())
- .def("get_noncopyable", &NCVirt::get_noncopyable)
- .def("get_movable", &NCVirt::get_movable)
- .def("print_nc", &NCVirt::print_nc)
- .def("print_movable", &NCVirt::print_movable);
-#endif
-
- m.def("runExampleVirt", &runExampleVirt);
- m.def("runExampleVirtBool", &runExampleVirtBool);
- m.def("runExampleVirtVirtual", &runExampleVirtVirtual);
-
- m.def("cstats_debug", &ConstructorStats::get<ExampleVirt>);
- initialize_inherited_virtuals(m);
-});
diff --git a/thirdparty/pybind11/pybind11/tests/test_virtual_functions.py b/thirdparty/pybind11/pybind11/tests/test_virtual_functions.py
deleted file mode 100644
index b11c699dfa4892a4ad8d647088ce71d5ed71933e..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tests/test_virtual_functions.py
+++ /dev/null
@@ -1,259 +0,0 @@
-import pytest
-import pybind11_tests
-from pybind11_tests import ConstructorStats
-
-
-def test_override(capture, msg):
- from pybind11_tests import (ExampleVirt, runExampleVirt, runExampleVirtVirtual,
- runExampleVirtBool)
-
- class ExtendedExampleVirt(ExampleVirt):
- def __init__(self, state):
- super(ExtendedExampleVirt, self).__init__(state + 1)
- self.data = "Hello world"
-
- def run(self, value):
- print('ExtendedExampleVirt::run(%i), calling parent..' % value)
- return super(ExtendedExampleVirt, self).run(value + 1)
-
- def run_bool(self):
- print('ExtendedExampleVirt::run_bool()')
- return False
-
- def get_string1(self):
- return "override1"
-
- def pure_virtual(self):
- print('ExtendedExampleVirt::pure_virtual(): %s' % self.data)
-
- class ExtendedExampleVirt2(ExtendedExampleVirt):
- def __init__(self, state):
- super(ExtendedExampleVirt2, self).__init__(state + 1)
-
- def get_string2(self):
- return "override2"
-
- ex12 = ExampleVirt(10)
- with capture:
- assert runExampleVirt(ex12, 20) == 30
- assert capture == """
- Original implementation of ExampleVirt::run(state=10, value=20, str1=default1, str2=default2)
- """ # noqa: E501 line too long
-
- with pytest.raises(RuntimeError) as excinfo:
- runExampleVirtVirtual(ex12)
- assert msg(excinfo.value) == 'Tried to call pure virtual function "ExampleVirt::pure_virtual"'
-
- ex12p = ExtendedExampleVirt(10)
- with capture:
- assert runExampleVirt(ex12p, 20) == 32
- assert capture == """
- ExtendedExampleVirt::run(20), calling parent..
- Original implementation of ExampleVirt::run(state=11, value=21, str1=override1, str2=default2)
- """ # noqa: E501 line too long
- with capture:
- assert runExampleVirtBool(ex12p) is False
- assert capture == "ExtendedExampleVirt::run_bool()"
- with capture:
- runExampleVirtVirtual(ex12p)
- assert capture == "ExtendedExampleVirt::pure_virtual(): Hello world"
-
- ex12p2 = ExtendedExampleVirt2(15)
- with capture:
- assert runExampleVirt(ex12p2, 50) == 68
- assert capture == """
- ExtendedExampleVirt::run(50), calling parent..
- Original implementation of ExampleVirt::run(state=17, value=51, str1=override1, str2=override2)
- """ # noqa: E501 line too long
-
- cstats = ConstructorStats.get(ExampleVirt)
- assert cstats.alive() == 3
- del ex12, ex12p, ex12p2
- assert cstats.alive() == 0
- assert cstats.values() == ['10', '11', '17']
- assert cstats.copy_constructions == 0
- assert cstats.move_constructions >= 0
-
-
-def test_inheriting_repeat():
- from pybind11_tests import A_Repeat, B_Repeat, C_Repeat, D_Repeat, A_Tpl, B_Tpl, C_Tpl, D_Tpl
-
- class AR(A_Repeat):
- def unlucky_number(self):
- return 99
-
- class AT(A_Tpl):
- def unlucky_number(self):
- return 999
-
- obj = AR()
- assert obj.say_something(3) == "hihihi"
- assert obj.unlucky_number() == 99
- assert obj.say_everything() == "hi 99"
-
- obj = AT()
- assert obj.say_something(3) == "hihihi"
- assert obj.unlucky_number() == 999
- assert obj.say_everything() == "hi 999"
-
- for obj in [B_Repeat(), B_Tpl()]:
- assert obj.say_something(3) == "B says hi 3 times"
- assert obj.unlucky_number() == 13
- assert obj.lucky_number() == 7.0
- assert obj.say_everything() == "B says hi 1 times 13"
-
- for obj in [C_Repeat(), C_Tpl()]:
- assert obj.say_something(3) == "B says hi 3 times"
- assert obj.unlucky_number() == 4444
- assert obj.lucky_number() == 888.0
- assert obj.say_everything() == "B says hi 1 times 4444"
-
- class CR(C_Repeat):
- def lucky_number(self):
- return C_Repeat.lucky_number(self) + 1.25
-
- obj = CR()
- assert obj.say_something(3) == "B says hi 3 times"
- assert obj.unlucky_number() == 4444
- assert obj.lucky_number() == 889.25
- assert obj.say_everything() == "B says hi 1 times 4444"
-
- class CT(C_Tpl):
- pass
-
- obj = CT()
- assert obj.say_something(3) == "B says hi 3 times"
- assert obj.unlucky_number() == 4444
- assert obj.lucky_number() == 888.0
- assert obj.say_everything() == "B says hi 1 times 4444"
-
- class CCR(CR):
- def lucky_number(self):
- return CR.lucky_number(self) * 10
-
- obj = CCR()
- assert obj.say_something(3) == "B says hi 3 times"
- assert obj.unlucky_number() == 4444
- assert obj.lucky_number() == 8892.5
- assert obj.say_everything() == "B says hi 1 times 4444"
-
- class CCT(CT):
- def lucky_number(self):
- return CT.lucky_number(self) * 1000
-
- obj = CCT()
- assert obj.say_something(3) == "B says hi 3 times"
- assert obj.unlucky_number() == 4444
- assert obj.lucky_number() == 888000.0
- assert obj.say_everything() == "B says hi 1 times 4444"
-
- class DR(D_Repeat):
- def unlucky_number(self):
- return 123
-
- def lucky_number(self):
- return 42.0
-
- for obj in [D_Repeat(), D_Tpl()]:
- assert obj.say_something(3) == "B says hi 3 times"
- assert obj.unlucky_number() == 4444
- assert obj.lucky_number() == 888.0
- assert obj.say_everything() == "B says hi 1 times 4444"
-
- obj = DR()
- assert obj.say_something(3) == "B says hi 3 times"
- assert obj.unlucky_number() == 123
- assert obj.lucky_number() == 42.0
- assert obj.say_everything() == "B says hi 1 times 123"
-
- class DT(D_Tpl):
- def say_something(self, times):
- return "DT says:" + (' quack' * times)
-
- def unlucky_number(self):
- return 1234
-
- def lucky_number(self):
- return -4.25
-
- obj = DT()
- assert obj.say_something(3) == "DT says: quack quack quack"
- assert obj.unlucky_number() == 1234
- assert obj.lucky_number() == -4.25
- assert obj.say_everything() == "DT says: quack 1234"
-
- class DT2(DT):
- def say_something(self, times):
- return "DT2: " + ('QUACK' * times)
-
- def unlucky_number(self):
- return -3
-
- class BT(B_Tpl):
- def say_something(self, times):
- return "BT" * times
-
- def unlucky_number(self):
- return -7
-
- def lucky_number(self):
- return -1.375
-
- obj = BT()
- assert obj.say_something(3) == "BTBTBT"
- assert obj.unlucky_number() == -7
- assert obj.lucky_number() == -1.375
- assert obj.say_everything() == "BT -7"
-
-
-# PyPy: Reference count > 1 causes call with noncopyable instance
-# to fail in ncv1.print_nc()
-@pytest.unsupported_on_pypy
-@pytest.mark.skipif(not hasattr(pybind11_tests, 'NCVirt'),
- reason="NCVirt test broken on ICPC")
-def test_move_support():
- from pybind11_tests import NCVirt, NonCopyable, Movable
-
- class NCVirtExt(NCVirt):
- def get_noncopyable(self, a, b):
- # Constructs and returns a new instance:
- nc = NonCopyable(a * a, b * b)
- return nc
-
- def get_movable(self, a, b):
- # Return a referenced copy
- self.movable = Movable(a, b)
- return self.movable
-
- class NCVirtExt2(NCVirt):
- def get_noncopyable(self, a, b):
- # Keep a reference: this is going to throw an exception
- self.nc = NonCopyable(a, b)
- return self.nc
-
- def get_movable(self, a, b):
- # Return a new instance without storing it
- return Movable(a, b)
-
- ncv1 = NCVirtExt()
- assert ncv1.print_nc(2, 3) == "36"
- assert ncv1.print_movable(4, 5) == "9"
- ncv2 = NCVirtExt2()
- assert ncv2.print_movable(7, 7) == "14"
- # Don't check the exception message here because it differs under debug/non-debug mode
- with pytest.raises(RuntimeError):
- ncv2.print_nc(9, 9)
-
- nc_stats = ConstructorStats.get(NonCopyable)
- mv_stats = ConstructorStats.get(Movable)
- assert nc_stats.alive() == 1
- assert mv_stats.alive() == 1
- del ncv1, ncv2
- assert nc_stats.alive() == 0
- assert mv_stats.alive() == 0
- assert nc_stats.values() == ['4', '9', '9', '9']
- assert mv_stats.values() == ['4', '5', '7', '7']
- assert nc_stats.copy_constructions == 0
- assert mv_stats.copy_constructions == 1
- assert nc_stats.move_constructions >= 0
- assert mv_stats.move_constructions >= 0
diff --git a/thirdparty/pybind11/pybind11/tools/FindEigen3.cmake b/thirdparty/pybind11/pybind11/tools/FindEigen3.cmake
deleted file mode 100644
index 9c546a05d859b18c49554d7ee7221cc486b7760e..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tools/FindEigen3.cmake
+++ /dev/null
@@ -1,81 +0,0 @@
-# - Try to find Eigen3 lib
-#
-# This module supports requiring a minimum version, e.g. you can do
-# find_package(Eigen3 3.1.2)
-# to require version 3.1.2 or newer of Eigen3.
-#
-# Once done this will define
-#
-# EIGEN3_FOUND - system has eigen lib with correct version
-# EIGEN3_INCLUDE_DIR - the eigen include directory
-# EIGEN3_VERSION - eigen version
-
-# Copyright (c) 2006, 2007 Montel Laurent, <montel@kde.org>
-# Copyright (c) 2008, 2009 Gael Guennebaud, <g.gael@free.fr>
-# Copyright (c) 2009 Benoit Jacob <jacob.benoit.1@gmail.com>
-# Redistribution and use is allowed according to the terms of the 2-clause BSD license.
-
-if(NOT Eigen3_FIND_VERSION)
- if(NOT Eigen3_FIND_VERSION_MAJOR)
- set(Eigen3_FIND_VERSION_MAJOR 2)
- endif(NOT Eigen3_FIND_VERSION_MAJOR)
- if(NOT Eigen3_FIND_VERSION_MINOR)
- set(Eigen3_FIND_VERSION_MINOR 91)
- endif(NOT Eigen3_FIND_VERSION_MINOR)
- if(NOT Eigen3_FIND_VERSION_PATCH)
- set(Eigen3_FIND_VERSION_PATCH 0)
- endif(NOT Eigen3_FIND_VERSION_PATCH)
-
- set(Eigen3_FIND_VERSION "${Eigen3_FIND_VERSION_MAJOR}.${Eigen3_FIND_VERSION_MINOR}.${Eigen3_FIND_VERSION_PATCH}")
-endif(NOT Eigen3_FIND_VERSION)
-
-macro(_eigen3_check_version)
- file(READ "${EIGEN3_INCLUDE_DIR}/Eigen/src/Core/util/Macros.h" _eigen3_version_header)
-
- string(REGEX MATCH "define[ \t]+EIGEN_WORLD_VERSION[ \t]+([0-9]+)" _eigen3_world_version_match "${_eigen3_version_header}")
- set(EIGEN3_WORLD_VERSION "${CMAKE_MATCH_1}")
- string(REGEX MATCH "define[ \t]+EIGEN_MAJOR_VERSION[ \t]+([0-9]+)" _eigen3_major_version_match "${_eigen3_version_header}")
- set(EIGEN3_MAJOR_VERSION "${CMAKE_MATCH_1}")
- string(REGEX MATCH "define[ \t]+EIGEN_MINOR_VERSION[ \t]+([0-9]+)" _eigen3_minor_version_match "${_eigen3_version_header}")
- set(EIGEN3_MINOR_VERSION "${CMAKE_MATCH_1}")
-
- set(EIGEN3_VERSION ${EIGEN3_WORLD_VERSION}.${EIGEN3_MAJOR_VERSION}.${EIGEN3_MINOR_VERSION})
- if(${EIGEN3_VERSION} VERSION_LESS ${Eigen3_FIND_VERSION})
- set(EIGEN3_VERSION_OK FALSE)
- else(${EIGEN3_VERSION} VERSION_LESS ${Eigen3_FIND_VERSION})
- set(EIGEN3_VERSION_OK TRUE)
- endif(${EIGEN3_VERSION} VERSION_LESS ${Eigen3_FIND_VERSION})
-
- if(NOT EIGEN3_VERSION_OK)
-
- message(STATUS "Eigen3 version ${EIGEN3_VERSION} found in ${EIGEN3_INCLUDE_DIR}, "
- "but at least version ${Eigen3_FIND_VERSION} is required")
- endif(NOT EIGEN3_VERSION_OK)
-endmacro(_eigen3_check_version)
-
-if (EIGEN3_INCLUDE_DIR)
-
- # in cache already
- _eigen3_check_version()
- set(EIGEN3_FOUND ${EIGEN3_VERSION_OK})
-
-else (EIGEN3_INCLUDE_DIR)
-
- find_path(EIGEN3_INCLUDE_DIR NAMES signature_of_eigen3_matrix_library
- PATHS
- ${CMAKE_INSTALL_PREFIX}/include
- ${KDE4_INCLUDE_DIR}
- PATH_SUFFIXES eigen3 eigen
- )
-
- if(EIGEN3_INCLUDE_DIR)
- _eigen3_check_version()
- endif(EIGEN3_INCLUDE_DIR)
-
- include(FindPackageHandleStandardArgs)
- find_package_handle_standard_args(Eigen3 DEFAULT_MSG EIGEN3_INCLUDE_DIR EIGEN3_VERSION_OK)
-
- mark_as_advanced(EIGEN3_INCLUDE_DIR)
-
-endif(EIGEN3_INCLUDE_DIR)
-
diff --git a/thirdparty/pybind11/pybind11/tools/FindPythonLibsNew.cmake b/thirdparty/pybind11/pybind11/tools/FindPythonLibsNew.cmake
deleted file mode 100644
index dc44a9df5486d7f5c4d9d0cd56972fc5e7460cbf..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tools/FindPythonLibsNew.cmake
+++ /dev/null
@@ -1,194 +0,0 @@
-# - Find python libraries
-# This module finds the libraries corresponding to the Python interpeter
-# FindPythonInterp provides.
-# This code sets the following variables:
-#
-# PYTHONLIBS_FOUND - have the Python libs been found
-# PYTHON_PREFIX - path to the Python installation
-# PYTHON_LIBRARIES - path to the python library
-# PYTHON_INCLUDE_DIRS - path to where Python.h is found
-# PYTHON_MODULE_EXTENSION - lib extension, e.g. '.so' or '.pyd'
-# PYTHON_MODULE_PREFIX - lib name prefix: usually an empty string
-# PYTHON_SITE_PACKAGES - path to installation site-packages
-# PYTHON_IS_DEBUG - whether the Python interpreter is a debug build
-#
-# Thanks to talljimbo for the patch adding the 'LDVERSION' config
-# variable usage.
-
-#=============================================================================
-# Copyright 2001-2009 Kitware, Inc.
-# Copyright 2012 Continuum Analytics, Inc.
-#
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-#
-# * Redistributions of source code must retain the above copyright
-# notice, this list of conditions and the following disclaimer.
-#
-# * Redistributions in binary form must reproduce the above copyright
-# notice, this list of conditions and the following disclaimer in the
-# documentation and/or other materials provided with the distribution.
-#
-# * Neither the names of Kitware, Inc., the Insight Software Consortium,
-# nor the names of their contributors may be used to endorse or promote
-# products derived from this software without specific prior written
-# permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-# # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-#=============================================================================
-
-if(PYTHONLIBS_FOUND)
- return()
-endif()
-
-# Use the Python interpreter to find the libs.
-if(PythonLibsNew_FIND_REQUIRED)
- find_package(PythonInterp ${PythonLibsNew_FIND_VERSION} REQUIRED)
-else()
- find_package(PythonInterp ${PythonLibsNew_FIND_VERSION})
-endif()
-
-if(NOT PYTHONINTERP_FOUND)
- set(PYTHONLIBS_FOUND FALSE)
- return()
-endif()
-
-# According to http://stackoverflow.com/questions/646518/python-how-to-detect-debug-interpreter
-# testing whether sys has the gettotalrefcount function is a reliable, cross-platform
-# way to detect a CPython debug interpreter.
-#
-# The library suffix is from the config var LDVERSION sometimes, otherwise
-# VERSION. VERSION will typically be like "2.7" on unix, and "27" on windows.
-execute_process(COMMAND "${PYTHON_EXECUTABLE}" "-c"
- "from distutils import sysconfig as s;import sys;import struct;
-print('.'.join(str(v) for v in sys.version_info));
-print(sys.prefix);
-print(s.get_python_inc(plat_specific=True));
-print(s.get_python_lib(plat_specific=True));
-print(s.get_config_var('SO'));
-print(hasattr(sys, 'gettotalrefcount')+0);
-print(struct.calcsize('@P'));
-print(s.get_config_var('LDVERSION') or s.get_config_var('VERSION'));
-print(s.get_config_var('LIBDIR') or '');
-print(s.get_config_var('MULTIARCH') or '');
-"
- RESULT_VARIABLE _PYTHON_SUCCESS
- OUTPUT_VARIABLE _PYTHON_VALUES
- ERROR_VARIABLE _PYTHON_ERROR_VALUE)
-
-if(NOT _PYTHON_SUCCESS MATCHES 0)
- if(PythonLibsNew_FIND_REQUIRED)
- message(FATAL_ERROR
- "Python config failure:\n${_PYTHON_ERROR_VALUE}")
- endif()
- set(PYTHONLIBS_FOUND FALSE)
- return()
-endif()
-
-# Convert the process output into a list
-string(REGEX REPLACE ";" "\\\\;" _PYTHON_VALUES ${_PYTHON_VALUES})
-string(REGEX REPLACE "\n" ";" _PYTHON_VALUES ${_PYTHON_VALUES})
-list(GET _PYTHON_VALUES 0 _PYTHON_VERSION_LIST)
-list(GET _PYTHON_VALUES 1 PYTHON_PREFIX)
-list(GET _PYTHON_VALUES 2 PYTHON_INCLUDE_DIR)
-list(GET _PYTHON_VALUES 3 PYTHON_SITE_PACKAGES)
-list(GET _PYTHON_VALUES 4 PYTHON_MODULE_EXTENSION)
-list(GET _PYTHON_VALUES 5 PYTHON_IS_DEBUG)
-list(GET _PYTHON_VALUES 6 PYTHON_SIZEOF_VOID_P)
-list(GET _PYTHON_VALUES 7 PYTHON_LIBRARY_SUFFIX)
-list(GET _PYTHON_VALUES 8 PYTHON_LIBDIR)
-list(GET _PYTHON_VALUES 9 PYTHON_MULTIARCH)
-
-# Make sure the Python has the same pointer-size as the chosen compiler
-# Skip if CMAKE_SIZEOF_VOID_P is not defined
-if(CMAKE_SIZEOF_VOID_P AND (NOT "${PYTHON_SIZEOF_VOID_P}" STREQUAL "${CMAKE_SIZEOF_VOID_P}"))
- if(PythonLibsNew_FIND_REQUIRED)
- math(EXPR _PYTHON_BITS "${PYTHON_SIZEOF_VOID_P} * 8")
- math(EXPR _CMAKE_BITS "${CMAKE_SIZEOF_VOID_P} * 8")
- message(FATAL_ERROR
- "Python config failure: Python is ${_PYTHON_BITS}-bit, "
- "chosen compiler is ${_CMAKE_BITS}-bit")
- endif()
- set(PYTHONLIBS_FOUND FALSE)
- return()
-endif()
-
-# The built-in FindPython didn't always give the version numbers
-string(REGEX REPLACE "\\." ";" _PYTHON_VERSION_LIST ${_PYTHON_VERSION_LIST})
-list(GET _PYTHON_VERSION_LIST 0 PYTHON_VERSION_MAJOR)
-list(GET _PYTHON_VERSION_LIST 1 PYTHON_VERSION_MINOR)
-list(GET _PYTHON_VERSION_LIST 2 PYTHON_VERSION_PATCH)
-
-# Make sure all directory separators are '/'
-string(REGEX REPLACE "\\\\" "/" PYTHON_PREFIX ${PYTHON_PREFIX})
-string(REGEX REPLACE "\\\\" "/" PYTHON_INCLUDE_DIR ${PYTHON_INCLUDE_DIR})
-string(REGEX REPLACE "\\\\" "/" PYTHON_SITE_PACKAGES ${PYTHON_SITE_PACKAGES})
-
-if(CMAKE_HOST_WIN32)
- set(PYTHON_LIBRARY
- "${PYTHON_PREFIX}/libs/Python${PYTHON_LIBRARY_SUFFIX}.lib")
-
- # when run in a venv, PYTHON_PREFIX points to it. But the libraries remain in the
- # original python installation. They may be found relative to PYTHON_INCLUDE_DIR.
- if(NOT EXISTS "${PYTHON_LIBRARY}")
- get_filename_component(_PYTHON_ROOT ${PYTHON_INCLUDE_DIR} DIRECTORY)
- set(PYTHON_LIBRARY
- "${_PYTHON_ROOT}/libs/Python${PYTHON_LIBRARY_SUFFIX}.lib")
- endif()
-
- # raise an error if the python libs are still not found.
- if(NOT EXISTS "${PYTHON_LIBRARY}")
- message(FATAL_ERROR "Python libraries not found")
- endif()
-
-else()
- if(PYTHON_MULTIARCH)
- set(_PYTHON_LIBS_SEARCH "${PYTHON_LIBDIR}/${PYTHON_MULTIARCH}" "${PYTHON_LIBDIR}")
- else()
- set(_PYTHON_LIBS_SEARCH "${PYTHON_LIBDIR}")
- endif()
- #message(STATUS "Searching for Python libs in ${_PYTHON_LIBS_SEARCH}")
- # Probably this needs to be more involved. It would be nice if the config
- # information the python interpreter itself gave us were more complete.
- find_library(PYTHON_LIBRARY
- NAMES "python${PYTHON_LIBRARY_SUFFIX}"
- PATHS ${_PYTHON_LIBS_SEARCH}
- NO_DEFAULT_PATH)
-
- # If all else fails, just set the name/version and let the linker figure out the path.
- if(NOT PYTHON_LIBRARY)
- set(PYTHON_LIBRARY python${PYTHON_LIBRARY_SUFFIX})
- endif()
-endif()
-
-MARK_AS_ADVANCED(
- PYTHON_LIBRARY
- PYTHON_INCLUDE_DIR
-)
-
-# We use PYTHON_INCLUDE_DIR, PYTHON_LIBRARY and PYTHON_DEBUG_LIBRARY for the
-# cache entries because they are meant to specify the location of a single
-# library. We now set the variables listed by the documentation for this
-# module.
-SET(PYTHON_INCLUDE_DIRS "${PYTHON_INCLUDE_DIR}")
-SET(PYTHON_LIBRARIES "${PYTHON_LIBRARY}")
-SET(PYTHON_DEBUG_LIBRARIES "${PYTHON_DEBUG_LIBRARY}")
-
-find_package_message(PYTHON
- "Found PythonLibs: ${PYTHON_LIBRARY}"
- "${PYTHON_EXECUTABLE}${PYTHON_VERSION}")
-
-set(PYTHONLIBS_FOUND TRUE)
diff --git a/thirdparty/pybind11/pybind11/tools/check-style.sh b/thirdparty/pybind11/pybind11/tools/check-style.sh
deleted file mode 100755
index b87cb16e6ff6a06f9ec9d879c288bf81d65d2043..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tools/check-style.sh
+++ /dev/null
@@ -1,83 +0,0 @@
-#!/bin/bash
-#
-# Script to check include/test code for common pybind11 code style errors.
-#
-# This script currently checks for
-#
-# 1. use of tabs instead of spaces
-# 2. MSDOS-style CRLF endings
-# 3. trailing spaces
-# 4. missing space between keyword and parenthesis, e.g.: for(, if(, while(
-# 5. Missing space between right parenthesis and brace, e.g. 'for (...){'
-# 6. opening brace on its own line. It should always be on the same line as the
-# if/while/for/do statment.
-#
-# Invoke as: tools/check-style.sh
-#
-
-errors=0
-IFS=$'\n'
-found=
-# The mt=41 sets a red background for matched tabs:
-exec 3< <(GREP_COLORS='mt=41' grep $'\t' include/ tests/*.{cpp,py,h} docs/*.rst -rn --color=always)
-while read -u 3 f; do
- if [ -z "$found" ]; then
- echo -e '\e[31m\e[01mError: found tabs instead of spaces in the following files:\e[0m'
- found=1
- errors=1
- fi
-
- echo " $f"
-done
-
-found=
-# The mt=41 sets a red background for matched MS-DOS CRLF line endings
-exec 3< <(GREP_COLORS='mt=41' grep -IUlr $'\r' include/ tests/*.{cpp,py,h} docs/*.rst --color=always)
-while read -u 3 f; do
- if [ -z "$found" ]; then
- echo -e '\e[31m\e[01mError: found CRLF characters in the following files:\e[0m'
- found=1
- errors=1
- fi
-
- echo " $f"
-done
-
-found=
-# The mt=41 sets a red background for matched trailing spaces
-exec 3< <(GREP_COLORS='mt=41' grep '\s\+$' include/ tests/*.{cpp,py,h} docs/*.rst -rn --color=always)
-while read -u 3 f; do
- if [ -z "$found" ]; then
- echo -e '\e[31m\e[01mError: found trailing spaces in the following files:\e[0m'
- found=1
- errors=1
- fi
-
- echo " $f"
-done
-
-found=
-exec 3< <(grep '\<\(if\|for\|while\|catch\)(\|){' include/ tests/*.{cpp,py,h} -rn --color=always)
-while read -u 3 line; do
- if [ -z "$found" ]; then
- echo -e '\e[31m\e[01mError: found the following coding style problems:\e[0m'
- found=1
- errors=1
- fi
-
- echo " $line"
-done
-
-found=
-exec 3< <(GREP_COLORS='mt=41' grep '^\s*{\s*$' include/ docs/*.rst -rn --color=always)
-while read -u 3 f; do
- if [ -z "$found" ]; then
- echo -e '\e[31m\e[01mError: braces should occur on the same line as the if/while/.. statement. Found issues in the following files: \e[0m'
- found=1
- errors=1
- fi
-
- echo " $f"
-done
-
-exit $errors
diff --git a/thirdparty/pybind11/pybind11/tools/libsize.py b/thirdparty/pybind11/pybind11/tools/libsize.py
deleted file mode 100644
index 5dcb8b0d020c600d03e97b148d2b56cf3bf23c07..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tools/libsize.py
+++ /dev/null
@@ -1,38 +0,0 @@
-from __future__ import print_function, division
-import os
-import sys
-
-# Internal build script for generating debugging test .so size.
-# Usage:
-# python libsize.py file.so save.txt -- displays the size of file.so and, if save.txt exists, compares it to the
-# size in it, then overwrites save.txt with the new size for future runs.
-
-if len(sys.argv) != 3:
- sys.exit("Invalid arguments: usage: python libsize.py file.so save.txt")
-
-lib = sys.argv[1]
-save = sys.argv[2]
-
-if not os.path.exists(lib):
- sys.exit("Error: requested file ({}) does not exist".format(lib))
-
-libsize = os.path.getsize(lib)
-
-print("------", os.path.basename(lib), "file size:", libsize, end='')
-
-if os.path.exists(save):
- with open(save) as sf:
- oldsize = int(sf.readline())
-
- if oldsize > 0:
- change = libsize - oldsize
- if change == 0:
- print(" (no change)")
- else:
- print(" (change of {:+} bytes = {:+.2%})".format(change, change / oldsize))
-else:
- print()
-
-with open(save, 'w') as sf:
- sf.write(str(libsize))
-
diff --git a/thirdparty/pybind11/pybind11/tools/mkdoc.py b/thirdparty/pybind11/pybind11/tools/mkdoc.py
deleted file mode 100644
index 400fb05dac6e5bdd2ef93ddba490fb408557dc1b..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tools/mkdoc.py
+++ /dev/null
@@ -1,309 +0,0 @@
-#!/usr/bin/env python3
-#
-# Syntax: mkdoc.py [-I<path> ..] [.. a list of header files ..]
-#
-# Extract documentation from C++ header files to use it in Python bindings
-#
-
-import os
-import sys
-import platform
-import re
-import textwrap
-
-from clang import cindex
-from clang.cindex import CursorKind
-from collections import OrderedDict
-from threading import Thread, Semaphore
-from multiprocessing import cpu_count
-
-RECURSE_LIST = [
- CursorKind.TRANSLATION_UNIT,
- CursorKind.NAMESPACE,
- CursorKind.CLASS_DECL,
- CursorKind.STRUCT_DECL,
- CursorKind.ENUM_DECL,
- CursorKind.CLASS_TEMPLATE
-]
-
-PRINT_LIST = [
- CursorKind.CLASS_DECL,
- CursorKind.STRUCT_DECL,
- CursorKind.ENUM_DECL,
- CursorKind.ENUM_CONSTANT_DECL,
- CursorKind.CLASS_TEMPLATE,
- CursorKind.FUNCTION_DECL,
- CursorKind.FUNCTION_TEMPLATE,
- CursorKind.CONVERSION_FUNCTION,
- CursorKind.CXX_METHOD,
- CursorKind.CONSTRUCTOR,
- CursorKind.FIELD_DECL
-]
-
-CPP_OPERATORS = {
- '<=': 'le', '>=': 'ge', '==': 'eq', '!=': 'ne', '[]': 'array',
- '+=': 'iadd', '-=': 'isub', '*=': 'imul', '/=': 'idiv', '%=':
- 'imod', '&=': 'iand', '|=': 'ior', '^=': 'ixor', '<<=': 'ilshift',
- '>>=': 'irshift', '++': 'inc', '--': 'dec', '<<': 'lshift', '>>':
- 'rshift', '&&': 'land', '||': 'lor', '!': 'lnot', '~': 'bnot',
- '&': 'band', '|': 'bor', '+': 'add', '-': 'sub', '*': 'mul', '/':
- 'div', '%': 'mod', '<': 'lt', '>': 'gt', '=': 'assign', '()': 'call'
-}
-
-CPP_OPERATORS = OrderedDict(
- sorted(CPP_OPERATORS.items(), key=lambda t: -len(t[0])))
-
-job_count = cpu_count()
-job_semaphore = Semaphore(job_count)
-
-registered_names = dict()
-
-
-def d(s):
- return s.decode('utf8')
-
-
-def sanitize_name(name):
- global registered_names
- name = re.sub(r'type-parameter-0-([0-9]+)', r'T\1', name)
- for k, v in CPP_OPERATORS.items():
- name = name.replace('operator%s' % k, 'operator_%s' % v)
- name = re.sub('<.*>', '', name)
- name = ''.join([ch if ch.isalnum() else '_' for ch in name])
- name = re.sub('_$', '', re.sub('_+', '_', name))
- if name in registered_names:
- registered_names[name] += 1
- name += '_' + str(registered_names[name])
- else:
- registered_names[name] = 1
- return '__doc_' + name
-
-
-def process_comment(comment):
- result = ''
-
- # Remove C++ comment syntax
- leading_spaces = float('inf')
- for s in comment.expandtabs(tabsize=4).splitlines():
- s = s.strip()
- if s.startswith('/*'):
- s = s[2:].lstrip('*')
- elif s.endswith('*/'):
- s = s[:-2].rstrip('*')
- elif s.startswith('///'):
- s = s[3:]
- if s.startswith('*'):
- s = s[1:]
- if len(s) > 0:
- leading_spaces = min(leading_spaces, len(s) - len(s.lstrip()))
- result += s + '\n'
-
- if leading_spaces != float('inf'):
- result2 = ""
- for s in result.splitlines():
- result2 += s[leading_spaces:] + '\n'
- result = result2
-
- # Doxygen tags
- cpp_group = '([\w:]+)'
- param_group = '([\[\w:\]]+)'
-
- s = result
- s = re.sub(r'\\c\s+%s' % cpp_group, r'``\1``', s)
- s = re.sub(r'\\a\s+%s' % cpp_group, r'*\1*', s)
- s = re.sub(r'\\e\s+%s' % cpp_group, r'*\1*', s)
- s = re.sub(r'\\em\s+%s' % cpp_group, r'*\1*', s)
- s = re.sub(r'\\b\s+%s' % cpp_group, r'**\1**', s)
- s = re.sub(r'\\ingroup\s+%s' % cpp_group, r'', s)
- s = re.sub(r'\\param%s?\s+%s' % (param_group, cpp_group),
- r'\n\n$Parameter ``\2``:\n\n', s)
- s = re.sub(r'\\tparam%s?\s+%s' % (param_group, cpp_group),
- r'\n\n$Template parameter ``\2``:\n\n', s)
-
- for in_, out_ in {
- 'return': 'Returns',
- 'author': 'Author',
- 'authors': 'Authors',
- 'copyright': 'Copyright',
- 'date': 'Date',
- 'remark': 'Remark',
- 'sa': 'See also',
- 'see': 'See also',
- 'extends': 'Extends',
- 'throw': 'Throws',
- 'throws': 'Throws'
- }.items():
- s = re.sub(r'\\%s\s*' % in_, r'\n\n$%s:\n\n' % out_, s)
-
- s = re.sub(r'\\details\s*', r'\n\n', s)
- s = re.sub(r'\\brief\s*', r'', s)
- s = re.sub(r'\\short\s*', r'', s)
- s = re.sub(r'\\ref\s*', r'', s)
-
- s = re.sub(r'\\code\s?(.*?)\s?\\endcode',
- r"```\n\1\n```\n", s, flags=re.DOTALL)
-
- # HTML/TeX tags
- s = re.sub(r'<tt>(.*?)</tt>', r'``\1``', s, flags=re.DOTALL)
- s = re.sub(r'<pre>(.*?)</pre>', r"```\n\1\n```\n", s, flags=re.DOTALL)
- s = re.sub(r'<em>(.*?)</em>', r'*\1*', s, flags=re.DOTALL)
- s = re.sub(r'<b>(.*?)</b>', r'**\1**', s, flags=re.DOTALL)
- s = re.sub(r'\\f\$(.*?)\\f\$', r'$\1$', s, flags=re.DOTALL)
- s = re.sub(r'<li>', r'\n\n* ', s)
- s = re.sub(r'</?ul>', r'', s)
- s = re.sub(r'</li>', r'\n\n', s)
-
- s = s.replace('``true``', '``True``')
- s = s.replace('``false``', '``False``')
-
- # Re-flow text
- wrapper = textwrap.TextWrapper()
- wrapper.expand_tabs = True
- wrapper.replace_whitespace = True
- wrapper.drop_whitespace = True
- wrapper.width = 70
- wrapper.initial_indent = wrapper.subsequent_indent = ''
-
- result = ''
- in_code_segment = False
- for x in re.split(r'(```)', s):
- if x == '```':
- if not in_code_segment:
- result += '```\n'
- else:
- result += '\n```\n\n'
- in_code_segment = not in_code_segment
- elif in_code_segment:
- result += x.strip()
- else:
- for y in re.split(r'(?: *\n *){2,}', x):
- wrapped = wrapper.fill(re.sub(r'\s+', ' ', y).strip())
- if len(wrapped) > 0 and wrapped[0] == '$':
- result += wrapped[1:] + '\n'
- wrapper.initial_indent = \
- wrapper.subsequent_indent = ' ' * 4
- else:
- if len(wrapped) > 0:
- result += wrapped + '\n\n'
- wrapper.initial_indent = wrapper.subsequent_indent = ''
- return result.rstrip().lstrip('\n')
-
-
-def extract(filename, node, prefix, output):
- num_extracted = 0
- if not (node.location.file is None or
- os.path.samefile(d(node.location.file.name), filename)):
- return 0
- if node.kind in RECURSE_LIST:
- sub_prefix = prefix
- if node.kind != CursorKind.TRANSLATION_UNIT:
- if len(sub_prefix) > 0:
- sub_prefix += '_'
- sub_prefix += d(node.spelling)
- for i in node.get_children():
- num_extracted += extract(filename, i, sub_prefix, output)
- if num_extracted == 0:
- return 0
- if node.kind in PRINT_LIST:
- comment = d(node.raw_comment) if node.raw_comment is not None else ''
- comment = process_comment(comment)
- sub_prefix = prefix
- if len(sub_prefix) > 0:
- sub_prefix += '_'
- if len(node.spelling) > 0:
- name = sanitize_name(sub_prefix + d(node.spelling))
- output.append('\nstatic const char *%s =%sR"doc(%s)doc";' %
- (name, '\n' if '\n' in comment else ' ', comment))
- num_extracted += 1
- return num_extracted
-
-
-class ExtractionThread(Thread):
- def __init__(self, filename, parameters, output):
- Thread.__init__(self)
- self.filename = filename
- self.parameters = parameters
- self.output = output
- job_semaphore.acquire()
-
- def run(self):
- print('Processing "%s" ..' % self.filename, file=sys.stderr)
- try:
- index = cindex.Index(
- cindex.conf.lib.clang_createIndex(False, True))
- tu = index.parse(self.filename, self.parameters)
- extract(self.filename, tu.cursor, '', self.output)
- finally:
- job_semaphore.release()
-
-if __name__ == '__main__':
- parameters = ['-x', 'c++', '-std=c++11']
- filenames = []
-
- if platform.system() == 'Darwin':
- dev_path = '/Applications/Xcode.app/Contents/Developer/'
- lib_dir = dev_path + 'Toolchains/XcodeDefault.xctoolchain/usr/lib/'
- sdk_dir = dev_path + 'Platforms/MacOSX.platform/Developer/SDKs'
- libclang = lib_dir + 'libclang.dylib'
-
- if os.path.exists(libclang):
- cindex.Config.set_library_path(os.path.dirname(libclang))
-
- if os.path.exists(sdk_dir):
- sysroot_dir = os.path.join(sdk_dir, next(os.walk(sdk_dir))[1][0])
- parameters.append('-isysroot')
- parameters.append(sysroot_dir)
-
- for item in sys.argv[1:]:
- if item.startswith('-'):
- parameters.append(item)
- else:
- filenames.append(item)
-
- if len(filenames) == 0:
- print('Syntax: %s [.. a list of header files ..]' % sys.argv[0])
- exit(-1)
-
- print('''/*
- This file contains docstrings for the Python bindings.
- Do not edit! These were automatically extracted by mkdoc.py
- */
-
-#define __EXPAND(x) x
-#define __COUNT(_1, _2, _3, _4, _5, _6, _7, COUNT, ...) COUNT
-#define __VA_SIZE(...) __EXPAND(__COUNT(__VA_ARGS__, 7, 6, 5, 4, 3, 2, 1))
-#define __CAT1(a, b) a ## b
-#define __CAT2(a, b) __CAT1(a, b)
-#define __DOC1(n1) __doc_##n1
-#define __DOC2(n1, n2) __doc_##n1##_##n2
-#define __DOC3(n1, n2, n3) __doc_##n1##_##n2##_##n3
-#define __DOC4(n1, n2, n3, n4) __doc_##n1##_##n2##_##n3##_##n4
-#define __DOC5(n1, n2, n3, n4, n5) __doc_##n1##_##n2##_##n3##_##n4##_##n5
-#define __DOC6(n1, n2, n3, n4, n5, n6) __doc_##n1##_##n2##_##n3##_##n4##_##n5##_##n6
-#define __DOC7(n1, n2, n3, n4, n5, n6, n7) __doc_##n1##_##n2##_##n3##_##n4##_##n5##_##n6##_##n7
-#define DOC(...) __EXPAND(__EXPAND(__CAT2(__DOC, __VA_SIZE(__VA_ARGS__)))(__VA_ARGS__))
-
-#if defined(__GNUG__)
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wunused-variable"
-#endif
-''')
-
- output = []
- for filename in filenames:
- thr = ExtractionThread(filename, parameters, output)
- thr.start()
-
- print('Waiting for jobs to finish ..', file=sys.stderr)
- for i in range(job_count):
- job_semaphore.acquire()
-
- output.sort()
- for l in output:
- print(l)
-
- print('''
-#if defined(__GNUG__)
-#pragma GCC diagnostic pop
-#endif
-''')
diff --git a/thirdparty/pybind11/pybind11/tools/pybind11Config.cmake.in b/thirdparty/pybind11/pybind11/tools/pybind11Config.cmake.in
deleted file mode 100644
index ae6d2daee6cd534b6f56f6c69e738ccb1e863f66..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tools/pybind11Config.cmake.in
+++ /dev/null
@@ -1,92 +0,0 @@
-# pybind11Config.cmake
-# --------------------
-#
-# PYBIND11 cmake module.
-# This module sets the following variables in your project::
-#
-# pybind11_FOUND - true if pybind11 and all required components found on the system
-# pybind11_VERSION - pybind11 version in format Major.Minor.Release
-# pybind11_INCLUDE_DIRS - Directories where pybind11 and python headers are located.
-# pybind11_INCLUDE_DIR - Directory where pybind11 headers are located.
-# pybind11_DEFINITIONS - Definitions necessary to use pybind11, namely USING_pybind11.
-# pybind11_LIBRARIES - compile flags and python libraries (as needed) to link against.
-# pybind11_LIBRARY - empty.
-# CMAKE_MODULE_PATH - appends location of accompanying FindPythonLibsNew.cmake and
-# pybind11Tools.cmake modules.
-#
-#
-# Available components: None
-#
-#
-# Exported targets::
-#
-# If pybind11 is found, this module defines the following :prop_tgt:`IMPORTED`
-# target. Python headers, libraries (as needed by platform), and C++ standard
-# are attached to the target. Set PythonLibsNew variables to influence
-# python detection and PYBIND11_CPP_STANDARD (-std=c++11 or -std=c++14) to
-# influence standard setting. ::
-#
-# pybind11::module - the main pybind11 interface library for extension modules (i.e., headers)
-#
-# find_package(pybind11 CONFIG REQUIRED)
-# message(STATUS "Found pybind11: ${pybind11_INCLUDE_DIR} (found version ${pybind11_VERSION} & Py${PYTHON_VERSION_STRING})")
-# add_library(mylib MODULE main.cpp)
-# target_link_libraries(mylib pybind11::module)
-#
-# Suggested usage::
-#
-# find_package with version info is not recommended except for release versions. ::
-#
-# find_package(pybind11 CONFIG)
-# find_package(pybind11 2.0 EXACT CONFIG REQUIRED)
-#
-#
-# The following variables can be set to guide the search for this package::
-#
-# pybind11_DIR - CMake variable, set to directory containing this Config file
-# CMAKE_PREFIX_PATH - CMake variable, set to root directory of this package
-# PATH - environment variable, set to bin directory of this package
-# CMAKE_DISABLE_FIND_PACKAGE_pybind11 - CMake variable, disables
-# find_package(pybind11) when not REQUIRED, perhaps to force internal build
-
-@PACKAGE_INIT@
-
-set(PN pybind11)
-
-# location of pybind11/pybind11.h
-set(${PN}_INCLUDE_DIR "${PACKAGE_PREFIX_DIR}/@CMAKE_INSTALL_INCLUDEDIR@")
-
-set(${PN}_LIBRARY "")
-set(${PN}_DEFINITIONS USING_${PN})
-
-check_required_components(${PN})
-
-# make detectable the FindPythonLibsNew.cmake module
-list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR})
-
-include(pybind11Tools)
-
-if(NOT (CMAKE_VERSION VERSION_LESS 3.0))
-#-----------------------------------------------------------------------------
-# Don't include targets if this file is being picked up by another
-# project which has already built this as a subproject
-#-----------------------------------------------------------------------------
-if(NOT TARGET ${PN}::module)
- include("${CMAKE_CURRENT_LIST_DIR}/${PN}Targets.cmake")
-
- find_package(PythonLibsNew ${PYBIND11_PYTHON_VERSION} MODULE REQUIRED)
- set_property(TARGET ${PN}::module APPEND PROPERTY INTERFACE_INCLUDE_DIRECTORIES ${PYTHON_INCLUDE_DIRS})
- if(WIN32 OR CYGWIN)
- set_property(TARGET ${PN}::module APPEND PROPERTY INTERFACE_LINK_LIBRARIES ${PYTHON_LIBRARIES})
- endif()
-
- select_cxx_standard()
- set_property(TARGET ${PN}::module APPEND PROPERTY INTERFACE_COMPILE_OPTIONS "${PYBIND11_CPP_STANDARD}")
-
- get_property(_iid TARGET ${PN}::module PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
- get_property(_ill TARGET ${PN}::module PROPERTY INTERFACE_LINK_LIBRARIES)
- get_property(_ico TARGET ${PN}::module PROPERTY INTERFACE_COMPILE_OPTIONS)
- set(${PN}_INCLUDE_DIRS ${_iid})
- set(${PN}_LIBRARIES ${_ico} ${_ill})
-endif()
-endif()
diff --git a/thirdparty/pybind11/pybind11/tools/pybind11Tools.cmake b/thirdparty/pybind11/pybind11/tools/pybind11Tools.cmake
deleted file mode 100644
index 3fbffeeffec6797fffce68dda51bebe6ab3908d3..0000000000000000000000000000000000000000
--- a/thirdparty/pybind11/pybind11/tools/pybind11Tools.cmake
+++ /dev/null
@@ -1,197 +0,0 @@
-# tools/pybind11Tools.cmake -- Build system for the pybind11 modules
-#
-# Copyright (c) 2015 Wenzel Jakob <wenzel@inf.ethz.ch>
-#
-# All rights reserved. Use of this source code is governed by a
-# BSD-style license that can be found in the LICENSE file.
-
-cmake_minimum_required(VERSION 2.8.12)
-
-# Add a CMake parameter for choosing a desired Python version
-if(NOT PYBIND11_PYTHON_VERSION)
- set(PYBIND11_PYTHON_VERSION "" CACHE STRING "Python version to use for compiling modules")
-endif()
-
-set(Python_ADDITIONAL_VERSIONS 3.7 3.6 3.5 3.4)
-find_package(PythonLibsNew ${PYBIND11_PYTHON_VERSION} REQUIRED)
-
-include(CheckCXXCompilerFlag)
-include(CMakeParseArguments)
-
-function(select_cxx_standard)
- if(NOT MSVC AND NOT PYBIND11_CPP_STANDARD)
- check_cxx_compiler_flag("-std=c++14" HAS_CPP14_FLAG)
- check_cxx_compiler_flag("-std=c++11" HAS_CPP11_FLAG)
-
- if (HAS_CPP14_FLAG)
- set(PYBIND11_CPP_STANDARD -std=c++14)
- elseif (HAS_CPP11_FLAG)
- set(PYBIND11_CPP_STANDARD -std=c++11)
- else()
- message(FATAL_ERROR "Unsupported compiler -- pybind11 requires C++11 support!")
- endif()
-
- set(PYBIND11_CPP_STANDARD ${PYBIND11_CPP_STANDARD} CACHE STRING
- "C++ standard flag, e.g. -std=c++11 or -std=c++14. Defaults to latest available." FORCE)
- endif()
-endfunction()
-
-# Checks whether the given CXX/linker flags can compile and link a cxx file. cxxflags and
-# linkerflags are lists of flags to use. The result variable is a unique variable name for each set
-# of flags: the compilation result will be cached base on the result variable. If the flags work,
-# sets them in cxxflags_out/linkerflags_out internal cache variables (in addition to ${result}).
-function(_pybind11_return_if_cxx_and_linker_flags_work result cxxflags linkerflags cxxflags_out linkerflags_out)
- set(CMAKE_REQUIRED_LIBRARIES ${linkerflags})
- check_cxx_compiler_flag("${cxxflags}" ${result})
- if (${result})
- set(${cxxflags_out} "${cxxflags}" CACHE INTERNAL "" FORCE)
- set(${linkerflags_out} "${linkerflags}" CACHE INTERNAL "" FORCE)
- endif()
-endfunction()
-
-# Internal: find the appropriate link time optimization flags for this compiler
-function(_pybind11_add_lto_flags target_name prefer_thin_lto)
- if (NOT DEFINED PYBIND11_LTO_CXX_FLAGS)
- set(PYBIND11_LTO_CXX_FLAGS "" CACHE INTERNAL "")
- set(PYBIND11_LTO_LINKER_FLAGS "" CACHE INTERNAL "")
-
- if(CMAKE_CXX_COMPILER_ID MATCHES "GNU|Clang")
- set(cxx_append "")
- set(linker_append "")
- if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND NOT APPLE)
- # Clang Gold plugin does not support -Os; append -O3 to MinSizeRel builds to override it
- set(linker_append ";$<$<CONFIG:MinSizeRel>:-O3>")
- elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
- set(cxx_append ";-fno-fat-lto-objects")
- endif()
-
- if (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND prefer_thin_lto)
- _pybind11_return_if_cxx_and_linker_flags_work(HAS_FLTO_THIN
- "-flto=thin${cxx_append}" "-flto=thin${linker_append}"
- PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
- endif()
-
- if (NOT HAS_FLTO_THIN)
- _pybind11_return_if_cxx_and_linker_flags_work(HAS_FLTO
- "-flto${cxx_append}" "-flto${linker_append}"
- PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
- endif()
- elseif (CMAKE_CXX_COMPILER_ID MATCHES "Intel")
- # Intel equivalent to LTO is called IPO
- _pybind11_return_if_cxx_and_linker_flags_work(HAS_INTEL_IPO
- "-ipo" "-ipo" PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
- elseif(MSVC)
- # cmake only interprets libraries as linker flags when they start with a - (otherwise it
- # converts /LTCG to \LTCG as if it was a Windows path). Luckily MSVC supports passing flags
- # with - instead of /, even if it is a bit non-standard:
- _pybind11_return_if_cxx_and_linker_flags_work(HAS_MSVC_GL_LTCG
- "/GL" "-LTCG" PYBIND11_LTO_CXX_FLAGS PYBIND11_LTO_LINKER_FLAGS)
- endif()
-
- if (PYBIND11_LTO_CXX_FLAGS)
- message(STATUS "LTO enabled")
- else()
- message(STATUS "LTO disabled (not supported by the compiler and/or linker)")
- endif()
- endif()
-
- # Enable LTO flags if found, except for Debug builds
- if (PYBIND11_LTO_CXX_FLAGS)
- target_compile_options(${target_name} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:${PYBIND11_LTO_CXX_FLAGS}>")
- endif()
- if (PYBIND11_LTO_LINKER_FLAGS)
- target_link_libraries(${target_name} PRIVATE "$<$<NOT:$<CONFIG:Debug>>:${PYBIND11_LTO_LINKER_FLAGS}>")
- endif()
-endfunction()
-
-# Build a Python extension module:
-# pybind11_add_module(<name> [MODULE | SHARED] [EXCLUDE_FROM_ALL]
-# [NO_EXTRAS] [THIN_LTO] source1 [source2 ...])
-#
-function(pybind11_add_module target_name)
- set(options MODULE SHARED EXCLUDE_FROM_ALL NO_EXTRAS THIN_LTO)
- cmake_parse_arguments(ARG "${options}" "" "" ${ARGN})
-
- if(ARG_MODULE AND ARG_SHARED)
- message(FATAL_ERROR "Can't be both MODULE and SHARED")
- elseif(ARG_SHARED)
- set(lib_type SHARED)
- else()
- set(lib_type MODULE)
- endif()
-
- if(ARG_EXCLUDE_FROM_ALL)
- set(exclude_from_all EXCLUDE_FROM_ALL)
- endif()
-
- add_library(${target_name} ${lib_type} ${exclude_from_all} ${ARG_UNPARSED_ARGUMENTS})
-
- target_include_directories(${target_name}
- PRIVATE ${PYBIND11_INCLUDE_DIR} # from project CMakeLists.txt
- PRIVATE ${pybind11_INCLUDE_DIR} # from pybind11Config
- PRIVATE ${PYTHON_INCLUDE_DIRS})
-
- # The prefix and extension are provided by FindPythonLibsNew.cmake
- set_target_properties(${target_name} PROPERTIES PREFIX "${PYTHON_MODULE_PREFIX}")
- set_target_properties(${target_name} PROPERTIES SUFFIX "${PYTHON_MODULE_EXTENSION}")
-
- if(WIN32 OR CYGWIN)
- # Link against the Python shared library on Windows
- target_link_libraries(${target_name} PRIVATE ${PYTHON_LIBRARIES})
- elseif(APPLE)
- # It's quite common to have multiple copies of the same Python version
- # installed on one's system. E.g.: one copy from the OS and another copy
- # that's statically linked into an application like Blender or Maya.
- # If we link our plugin library against the OS Python here and import it
- # into Blender or Maya later on, this will cause segfaults when multiple
- # conflicting Python instances are active at the same time (even when they
- # are of the same version).
-
- # Windows is not affected by this issue since it handles DLL imports
- # differently. The solution for Linux and Mac OS is simple: we just don't
- # link against the Python library. The resulting shared library will have
- # missing symbols, but that's perfectly fine -- they will be resolved at
- # import time.
-
- target_link_libraries(${target_name} PRIVATE "-undefined dynamic_lookup")
-
- if(ARG_SHARED)
- # Suppress CMake >= 3.0 warning for shared libraries
- set_target_properties(${target_name} PROPERTIES MACOSX_RPATH ON)
- endif()
- endif()
-
- select_cxx_standard()
- if(NOT MSVC)
- # Make sure C++11/14 are enabled
- target_compile_options(${target_name} PUBLIC ${PYBIND11_CPP_STANDARD})
- endif()
-
- if(ARG_NO_EXTRAS)
- return()
- endif()
-
- _pybind11_add_lto_flags(${target_name} ${ARG_THIN_LTO})
-
- if (NOT MSVC AND NOT ${CMAKE_BUILD_TYPE} MATCHES Debug)
- # Set the default symbol visibility to hidden (very important to obtain small binaries)
- target_compile_options(${target_name} PRIVATE "-fvisibility=hidden")
-
- # Strip unnecessary sections of the binary on Linux/Mac OS
- if(CMAKE_STRIP)
- if(APPLE)
- add_custom_command(TARGET ${target_name} POST_BUILD
- COMMAND ${CMAKE_STRIP} -x $<TARGET_FILE:${target_name}>)
- else()
- add_custom_command(TARGET ${target_name} POST_BUILD
- COMMAND ${CMAKE_STRIP} $<TARGET_FILE:${target_name}>)
- endif()
- endif()
- endif()
-
- if(MSVC)
- # /MP enables multithreaded builds (relevant when there are many files), /bigobj is
- # needed for bigger binding projects due to the limit to 64k addressable sections
- target_compile_options(${target_name} PRIVATE /MP /bigobj)
- endif()
-endfunction()