Merge branch 'main' into feat/snap-store-packaging

Publish OrcaSlicer to the Snap Store (classic confinement) on channels
matching the release tiers: stable / candidate / beta / edge. The Linux
build (both arches) repackages the AppImage AppDir into a snap; nightly
builds go to edge, and tagged releases publish to the matching channel.

Stacked on the Linux ARM64 AppImage change.

.gitattributes

@@ -1,7 +1,2 @@
 # Set the default behavior, in case people don't have core.autocrlf set.
 * text=auto
-
-# Shell scripts are run by Git Bash on Windows CI, which cannot read a script
-# with CRLF line endings: it fails on the first line. Windows checkouts default
-# to core.autocrlf=true, so keep these LF whatever the platform.
-*.sh text eol=lf

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -32,17 +32,9 @@ body:
     attributes:
       label: OrcaSlicer Version
       description: Which version of Orca Slicer are you running? You can see the full version in `Help` -> `About Orca Slicer`.
-      placeholder: e.g. 2.5.0
+      placeholder: e.g. 1.9.0
     validations:
       required: true
-  - type: input
-    id: working_version
-    attributes:
-      label: Regression compared to a previous version
-      description: Did it work in a previous version?
-      placeholder: e.g. 2.3.2
-    validations:
-      required: false
   - type: dropdown
     id: os_type
     attributes:

.github/workflows/auto-close-duplicates.yml

@@ -15,7 +15,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2

.github/workflows/backfill-duplicate-comments.yml

@@ -29,7 +29,7 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
       
       - name: Setup Bun
         uses: oven-sh/setup-bun@v2

.github/workflows/build_all.yml

@@ -5,7 +5,6 @@ on:
     branches:
      - main
      - release/*
-     - belt-printer
     paths:
      - 'deps/**'
      - 'src/**'
@@ -14,8 +13,8 @@ on:
      - 'localization/**'
      - 'resources/**'
      - ".github/workflows/build_*.yml"
-     - 'scripts/build_preset_cache.*'
      - 'scripts/flatpak/**'
+     - 'snap/**'
      - 'scripts/msix/**'
      - 'tests/**'
 
@@ -31,11 +30,10 @@ on:
      - 'version.inc'
      - ".github/workflows/build_*.yml"
      - 'build_linux.sh'
-     - 'build_release_vs.bat'
      - 'build_release_vs2022.bat'
      - 'build_release_macos.sh'
-     - 'scripts/build_preset_cache.*'
      - 'scripts/flatpak/**'
+     - 'snap/**'
      - 'scripts/msix/**'
      - 'tests/**'
 
@@ -59,13 +57,17 @@ jobs:
   build_linux:
     strategy:
       fail-fast: false
-      # SELF_HOSTED skips arm64 (no arm self-hosted server). amd64's empty arch
-      # is load-bearing: it keeps the historical 'linux-clang' deps cache key and
-      # the unsuffixed asset names.
+      # Build both arches on every event (PRs included), through the same
+      # build_check_cache -> build_deps -> build_orca chain (AppImage + snap).
+      # aarch64 always uses the GitHub-hosted arm runner (there is no arm
+      # self-hosted server). amd64's empty arch is load-bearing: it keeps the
+      # historical 'linux-clang' deps cache key and the unsuffixed asset names.
       matrix:
-        include: ${{ fromJSON(vars.SELF_HOSTED
-          && '[{"arch":"","os":"orca-lnx-server"}]'
-          || '[{"arch":"","os":"ubuntu-24.04"},{"arch":"aarch64","os":"ubuntu-24.04-arm"}]') }}
+        include:
+          - arch: ""
+            os: ${{ vars.SELF_HOSTED && 'orca-lnx-server' || 'ubuntu-24.04' }}
+          - arch: "aarch64"
+            os: ubuntu-24.04-arm
     # Don't run scheduled builds on forks:
     if: ${{ !cancelled() && (github.event_name != 'schedule' || github.repository == 'OrcaSlicer/OrcaSlicer') }}
     uses: ./.github/workflows/build_check_cache.yml
@@ -75,20 +77,11 @@ jobs:
       build-deps-only: ${{ inputs.build-deps-only || false }}
     secrets: inherit
   build_windows:
-    name: Build Windows ${{ matrix.arch }}
-    strategy:
-      fail-fast: false
-      # SELF_HOSTED skips arm64 (the self-hosted Windows server is x64-only).
-      matrix:
-        include: ${{ fromJSON(vars.SELF_HOSTED
-          && '[{"arch":"x64","os":"orca-win-server"}]'
-          || '[{"arch":"x64","os":"windows-latest"},{"arch":"arm64","os":"windows-11-arm"}]') }}
     # Don't run scheduled builds on forks:
     if: ${{ !cancelled() && (github.event_name != 'schedule' || github.repository == 'OrcaSlicer/OrcaSlicer') }}
     uses: ./.github/workflows/build_check_cache.yml
     with:
-      os: ${{ matrix.os }}
-      arch: ${{ matrix.arch }}
+      os: ${{ vars.SELF_HOSTED && 'orca-win-server' || 'windows-latest' }}
       build-deps-only: ${{ inputs.build-deps-only || false }}
       force-build: ${{ github.event_name == 'schedule' }}
     secrets: inherit
@@ -118,97 +111,54 @@ jobs:
       arch: universal
       macos-combine-only: true
     secrets: inherit
-  # One test job per built arch, on the runner that built it.
-  unit_tests_linux_x86_64:
-    name: Linux x86_64
-    needs: build_linux
-    if: ${{ !cancelled() && success() }}
-    uses: ./.github/workflows/unit_tests.yml
-    with:
-      os: ${{ vars.SELF_HOSTED && 'orca-lnx-server' || 'ubuntu-24.04' }}
-      artifact: ${{ github.sha }}-tests-linux-x86_64
-  unit_tests_linux_aarch64:
-    name: Linux aarch64
-    needs: build_linux
-    if: ${{ !cancelled() && success() && !vars.SELF_HOSTED }}
-    uses: ./.github/workflows/unit_tests.yml
-    with:
-      os: ubuntu-24.04-arm
-      artifact: ${{ github.sha }}-tests-linux-aarch64
-  unit_tests_windows_x64:
-    name: Windows x64
-    needs: build_windows
-    if: ${{ !cancelled() && success() }}
-    uses: ./.github/workflows/unit_tests.yml
-    with:
-      os: ${{ vars.SELF_HOSTED && 'orca-win-server' || 'windows-latest' }}
-      artifact: ${{ github.sha }}-tests-windows-x64
-  unit_tests_windows_arm64:
-    name: Windows arm64
-    needs: build_windows
-    if: ${{ !cancelled() && success() && !vars.SELF_HOSTED }}
-    uses: ./.github/workflows/unit_tests.yml
-    with:
-      os: windows-11-arm
-      artifact: ${{ github.sha }}-tests-windows-arm64
-      test-dir: build-arm64/tests
-  unit_tests_macos_arm64:
-    name: macOS arm64
-    needs: build_macos_arch
-    if: ${{ !cancelled() && success() }}
-    uses: ./.github/workflows/unit_tests.yml
-    with:
-      os: ${{ vars.SELF_HOSTED && 'orca-macos-arm64' || 'macos-14' }}
-      artifact: ${{ github.sha }}-tests-macos-arm64
-      test-dir: build/arm64/tests
-  # Slice a two-colour cube through every shipped printer so all custom g-code
-  # (change_filament_gcode, machine start/end, etc.) is expanded - catches
-  # slicing regressions the static profile checks and unit tests can't see.
-  # Profile-only PRs are covered by check_profiles.yml's nightly binary; this
-  # covers src/engine PRs with the PR-built binary.
-  slice_check_linux:
-    name: Slice check (Linux ${{ vars.SELF_HOSTED && 'x86_64' || 'aarch64' }})
-    needs: build_linux
-    if: ${{ !cancelled() && success() }}
-    # Follows whichever Linux leg built the validator.
+  unit_tests:
+    name: Unit Tests
+    # Tests are built on the aarch64 leg by default (faster GitHub arm runner),
+    # so run them there; self-hosted builds them on the amd64 server instead.
     runs-on: ${{ vars.SELF_HOSTED && 'orca-lnx-server' || 'ubuntu-24.04-arm' }}
+    needs: build_linux
+    if: ${{ !cancelled() && success() }}
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v7
-      - name: Download profile validator
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          sparse-checkout: |
+            .github
+            scripts
+            tests
+      - name: Apt-Install Dependencies
+        if: ${{ !vars.SELF_HOSTED }}
+        uses: ./.github/actions/apt-install-deps
+      - name: Restore Test Artifact
         uses: actions/download-artifact@v8
         with:
-          name: ${{ github.sha }}-profile-validator-linux-${{ vars.SELF_HOSTED && 'x86_64' || 'aarch64' }}
-          path: validator-bin
-      - name: Validate slice (expand custom g-code)
-        timeout-minutes: 60
+          name: ${{ github.sha }}-tests
+      - uses: lukka/get-cmake@latest
+        with:
+          cmakeVersion: "~4.3.0"  # use most recent 4.3.x version
+          useLocalCache: true         # <--= Use the local cache (default is 'false').
+          useCloudCache: true
+      - name: Unpackage and Run Unit Tests
+        timeout-minutes: 20
         run: |
-          chmod +x validator-bin/OrcaSlicer_profile_validator
-          ./validator-bin/OrcaSlicer_profile_validator -p "${{ github.workspace }}/resources/profiles" -s -l 2
-  publish_test_results:
-    name: Publish Test Results
-    needs: [unit_tests_linux_x86_64, unit_tests_linux_aarch64, unit_tests_windows_x64, unit_tests_windows_arm64, unit_tests_macos_arm64]
-    if: ${{ !cancelled() }}
-    runs-on: ubuntu-latest
-    steps:
-      - name: Download Test Results
-        uses: actions/download-artifact@v8
+          tar -xvf build_tests.tar
+          scripts/run_unit_tests.sh
+      - name: Upload Test Logs
+        uses: actions/upload-artifact@v7
+        if: ${{ failure() }}
         with:
-          pattern: test-results-*
-          path: test-results
-      # Best-effort: a read-only token (e.g. fork PRs) can't write the check, so
-      # don't let a publish failure fail the run. The test jobs gate correctness.
+          name: unit-test-logs
+          path: build/tests/**/*.log
       - name: Publish Test Results
-        continue-on-error: true
+        if: always()
         uses: EnricoMi/publish-unit-test-result-action@v2
         with:
-          files: "test-results/**/*.xml"
-      - name: Delete Test Results
+          files: "ctest_results.xml"
+      - name: Delete Test Artifact
         if: success()
         uses: geekyeggo/delete-artifact@v6
         with:
-          name: test-results-*
-          failOnError: false
+          name: ${{ github.sha }}-tests
   flatpak:
     name: "Flatpak"
     container:
@@ -236,14 +186,11 @@ jobs:
       date:
       ver:
       ver_pure:
-      # Belt-printer nightlies share the main nightly release but carry a `_belt`
-      # suffix so they never overwrite the main assets.
-      nightly_suffix: ${{ github.ref == 'refs/heads/belt-printer' && '_belt' || '' }}
     steps:
     - name: "Remove unneeded stuff to free disk space"
       run:
         rm -rf /usr/local/lib/android/* /usr/share/dotnet/* /opt/ghc1/* "/usr/local/share/boost1/*" /opt/hostedtoolcache1/*
-    - uses: actions/checkout@v7
+    - uses: actions/checkout@v6
     - name: Get the version and date
       run: |
         ver_pure=$(grep 'set(SoftFever_VERSION' version.inc | cut -d '"' -f2)
@@ -262,14 +209,14 @@ jobs:
     # Manage flatpak-builder cache externally so PRs restore but never upload
     - name: Restore flatpak-builder cache
       if: github.event_name == 'pull_request'
-      uses: actions/cache/restore@v6
+      uses: actions/cache/restore@v5
       with:
         path: .flatpak-builder
         key: flatpak-builder-${{ matrix.variant.arch }}-${{ github.event.pull_request.base.sha }}
         restore-keys: flatpak-builder-${{ matrix.variant.arch }}-
     - name: Save/restore flatpak-builder cache
       if: github.event_name != 'pull_request'
-      uses: actions/cache@v6
+      uses: actions/cache@v5
       with:
         path: .flatpak-builder
         key: flatpak-builder-${{ matrix.variant.arch }}-${{ github.sha }}
@@ -297,12 +244,12 @@ jobs:
         name: OrcaSlicer-Linux-flatpak_${{ env.ver }}_${{ matrix.variant.arch }}.flatpak
         path: '/__w/OrcaSlicer/OrcaSlicer/OrcaSlicer-Linux-flatpak_${{ env.ver }}_${{ matrix.variant.arch }}.flatpak'
     - name: Deploy Flatpak to nightly release
-      if: github.repository == 'OrcaSlicer/OrcaSlicer' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/belt-printer')
+      if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main'
       uses: WebFreak001/deploy-nightly@v3.2.0
       with:
         upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
         release_id: 137995723
         asset_path: /__w/OrcaSlicer/OrcaSlicer/OrcaSlicer-Linux-flatpak_${{ env.ver }}_${{ matrix.variant.arch }}.flatpak
-        asset_name: OrcaSlicer-Linux-flatpak_nightly${{ env.nightly_suffix }}_${{ matrix.variant.arch }}.flatpak
+        asset_name: OrcaSlicer-Linux-flatpak_nightly_${{ matrix.variant.arch }}.flatpak
         asset_content_type: application/octet-stream
         max_releases: 1 # optional, if there are more releases than this matching the asset_name, the oldest ones are going to be deleted

.github/workflows/build_check_cache.yml

@@ -26,19 +26,18 @@ jobs:
       valid-cache: ${{ steps.cache_deps.outputs.cache-hit }}
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           lfs: 'false'
         
       - name: set outputs
         id: set_outputs
         env:
-          # Keep macOS/Windows cache keys architecture-specific. amd64 Linux passes
+          # Keep macOS/Linux cache keys architecture-specific. amd64 Linux passes
           # no arch (key stays 'linux-clang', preserving the existing cache);
           # aarch64 gets its own 'linux-clang-aarch64' key.
-          cache-os: ${{ runner.os == 'macOS' && format('macos-{0}', inputs.arch) || (runner.os == 'Windows' && format('windows-{0}', inputs.arch) || format('linux-clang{0}', inputs.arch && format('-{0}', inputs.arch) || '')) }}
-          # ARM64 builds use the build-arm64 tree (see build_release_vs.bat); x64/other use build.
-          dep-folder-name: ${{ runner.os == 'macOS' && format('/{0}', inputs.arch) || (runner.os == 'Windows' && inputs.arch == 'arm64') && '-arm64/OrcaSlicer_dep' || '/OrcaSlicer_dep' }}
+          cache-os: ${{ runner.os == 'macOS' && format('macos-{0}', inputs.arch) || (runner.os == 'Windows' && 'windows' || format('linux-clang{0}', inputs.arch && format('-{0}', inputs.arch) || '')) }}
+          dep-folder-name: ${{ runner.os == 'macOS' && format('/{0}', inputs.arch) || '/OrcaSlicer_dep' }}
           output-cmd: ${{ runner.os == 'Windows' && '$env:GITHUB_OUTPUT' || '"$GITHUB_OUTPUT"'}}
         run: |
           echo cache-key=${{ env.cache-os }}-cache-orcaslicer_deps-build-${{ hashFiles('deps/**') }} >> ${{ env.output-cmd }}
@@ -46,7 +45,7 @@ jobs:
             
       - name: load cache
         id: cache_deps
-        uses: actions/cache@v6
+        uses: actions/cache@v5
         with:
           path: ${{ steps.set_outputs.outputs.cache-path }}
           key: ${{ steps.set_outputs.outputs.cache-key }}

.github/workflows/build_deps.yml

@@ -34,39 +34,22 @@ jobs:
 
       # Setup the environment
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           lfs: 'false'
 
       - name: load cached deps
-        uses: actions/cache@v6
+        uses: actions/cache@v5
         with:
           path: ${{ inputs.cache-path }}
           key: ${{ inputs.cache-key }}
 
       - uses: lukka/get-cmake@latest
-        # The windows-11-arm runner needs CMake <= 3.31 (handled in the next step).
-        if: ${{ !(runner.os == 'Windows' && inputs.arch == 'arm64') }}
         with:
           cmakeVersion: "~4.3.0"  # use most recent 4.3.x version
           useLocalCache: true         # <--= Use the local cache (default is 'false').
           useCloudCache: true
 
-      - name: Install CMake 3.31.x (Windows ARM64)
-        # windows-11-arm ships CMake 4.x, which removed pre-3.5 policy
-        # compatibility AND has incomplete ASM_ARMASM linker modules
-        # (breaks Boost.Context on ARM64). Pin to the last 3.x release.
-        if: runner.os == 'Windows' && inputs.arch == 'arm64'
-        shell: pwsh
-        run: |
-          $ver = "3.31.6"
-          $url = "https://github.com/Kitware/CMake/releases/download/v$ver/cmake-$ver-windows-arm64.zip"
-          Invoke-WebRequest -Uri $url -OutFile "$env:RUNNER_TEMP\cmake.zip"
-          Expand-Archive -Path "$env:RUNNER_TEMP\cmake.zip" -DestinationPath "$env:RUNNER_TEMP\cmake" -Force
-          $cmakeBin = "$env:RUNNER_TEMP\cmake\cmake-$ver-windows-arm64\bin"
-          if (-not (Test-Path "$cmakeBin\cmake.exe")) { throw "cmake.exe not found at $cmakeBin" }
-          Add-Content -Path $env:GITHUB_PATH -Value $cmakeBin
-
       - name: setup dev on Windows
         if: runner.os == 'Windows'
         uses: microsoft/setup-msbuild@v3
@@ -82,50 +65,6 @@ jobs:
         shell: pwsh
 
 
-      - name: Install MSYS2 (clangarm64) with GMP/MPFR and LLVM tools
-        if: runner.os == 'Windows' && inputs.arch == 'arm64'
-        uses: msys2/setup-msys2@v2
-        with:
-          msystem: CLANGARM64
-          update: true
-          install: >-
-            mingw-w64-clang-aarch64-gmp
-            mingw-w64-clang-aarch64-mpfr
-            mingw-w64-clang-aarch64-llvm
-
-      - name: Stage ARM64 GMP/MPFR (no prebuilt blobs exist for win-arm64)
-        # GMP/MPFR ship prebuilt x64/x86 blobs in-tree but none for ARM64.
-        # Pull them from MSYS2 clangarm64 and generate MSVC import libs via
-        # llvm-dlltool, then stage into deps/{GMP,MPFR}/.../win-arm64 where the
-        # MSVC branch of GMP.cmake/MPFR.cmake copies them into the dep prefix.
-        if: runner.os == 'Windows' && inputs.arch == 'arm64'
-        shell: msys2 {0}
-        run: |
-          set -euo pipefail
-          BIN=/clangarm64/bin
-          REPO=$(cygpath -u "$GITHUB_WORKSPACE")
-
-          make_import_lib() {
-            local dll="$1"; local lib="$2"; local def="/tmp/${dll%.dll}.def"
-            echo "EXPORTS" > "$def"
-            llvm-readobj --coff-exports "$BIN/$dll" | awk '/Name: /{print $2}' >> "$def"
-            llvm-dlltool -m arm64 -D "$dll" -d "$def" -l "$BIN/$lib"
-          }
-
-          make_import_lib libgmp-10.dll libgmp-10.lib
-
-          # MPFR 4.x ships as libmpfr-6.dll; rename to libmpfr-4 BEFORE generating
-          # the import lib so the baked-in runtime DLL name is correct.
-          MPFR_DLL=$(ls $BIN/libmpfr-*.dll | head -1 | xargs basename)
-          if [ "$MPFR_DLL" != "libmpfr-4.dll" ]; then cp "$BIN/$MPFR_DLL" "$BIN/libmpfr-4.dll"; fi
-          make_import_lib libmpfr-4.dll libmpfr-4.lib
-
-          mkdir -p $REPO/deps/GMP/gmp/lib/win-arm64 $REPO/deps/MPFR/mpfr/lib/win-arm64
-          cp $BIN/libgmp-10.dll $BIN/libgmp-10.lib $REPO/deps/GMP/gmp/lib/win-arm64/
-          cp $BIN/libmpfr-4.dll $BIN/libmpfr-4.lib $REPO/deps/MPFR/mpfr/lib/win-arm64/
-          cp /clangarm64/include/gmp.h  $REPO/deps/GMP/gmp/include/
-          cp /clangarm64/include/mpfr.h $REPO/deps/MPFR/mpfr/include/ || true
-
       # Build Dependencies
       - name: Build on Windows
         if: runner.os == 'Windows'
@@ -134,14 +73,8 @@ jobs:
             if (-not "${{ vars.SELF_HOSTED }}") {
               choco install strawberryperl
             }
-            $arch = "${{ inputs.arch }}"
-            if ($arch -eq "arm64") {
-              .\build_release_vs.bat deps arm64
-              .\build_release_vs.bat pack arm64
-            } else {
-              .\build_release_vs.bat deps
-              .\build_release_vs.bat pack
-            }
+            .\build_release_vs.bat deps
+            .\build_release_vs.bat pack
         shell: pwsh
 
       - name: Build on Mac ${{ inputs.arch }}
@@ -149,9 +82,9 @@ jobs:
         working-directory: ${{ github.workspace }}
         run: |
             if [ -z "${{ vars.SELF_HOSTED }}" ]; then
-              brew install automake texinfo libtool pkgconf yasm nasm
+              brew install automake texinfo libtool
             fi
-            ./build_release_macos.sh -dx ${{ !vars.SELF_HOSTED && '-j 3' || '' }} -a ${{ inputs.arch }} -t 10.15
+            ./build_release_macos.sh -dx ${{ !vars.SELF_HOSTED && '-1' || '' }} -a ${{ inputs.arch }} -t 10.15
             (cd "${{ github.workspace }}/deps/build/${{ inputs.arch }}" && \
             find . -mindepth 1 -maxdepth 1 ! -name 'OrcaSlicer_dep' -exec rm -rf {} +)
 

.github/workflows/build_orca.yml

@@ -29,49 +29,27 @@ jobs:
       ubuntu-ver: '2404'
       ubuntu-ver-str: '_Ubuntu2404'
       ORCA_UPDATER_SIG_KEY: ${{ secrets.ORCA_UPDATER_SIG_KEY }}
-      # Branches whose builds are published to the nightly release. The
-      # belt-printer branch ships alongside main but its assets carry a `_belt`
-      # suffix (nightly_suffix) so they never overwrite the main nightly assets.
-      deploy_nightly: ${{ github.ref == 'refs/heads/main' || github.ref == 'refs/heads/belt-printer' }}
-      nightly_suffix: ${{ github.ref == 'refs/heads/belt-printer' && '_belt' || '' }}
 
     steps:
       - name: Checkout
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
         with:
           lfs: 'false'
 
       - name: load cached deps
         if: ${{ !(runner.os == 'macOS' && inputs.macos-combine-only) }}
-        uses: actions/cache@v6
+        uses: actions/cache@v5
         with:
           path: ${{ inputs.cache-path }}
           key: ${{ inputs.cache-key }}
           fail-on-cache-miss: true
 
       - uses: lukka/get-cmake@latest
-        # The windows-11-arm runner needs CMake <= 3.31 (handled in the next step).
-        if: ${{ !(runner.os == 'Windows' && inputs.arch == 'arm64') }}
         with:
           cmakeVersion: "~4.3.0"  # use most recent 4.3.x version
           useLocalCache: true         # <--= Use the local cache (default is 'false').
           useCloudCache: true
 
-      - name: Install CMake 3.31.x (Windows ARM64)
-        # windows-11-arm ships CMake 4.x, which removed pre-3.5 policy
-        # compatibility AND has incomplete ASM_ARMASM linker modules
-        # (breaks Boost.Context on ARM64). Pin to the last 3.x release.
-        if: runner.os == 'Windows' && inputs.arch == 'arm64'
-        shell: pwsh
-        run: |
-          $ver = "3.31.6"
-          $url = "https://github.com/Kitware/CMake/releases/download/v$ver/cmake-$ver-windows-arm64.zip"
-          Invoke-WebRequest -Uri $url -OutFile "$env:RUNNER_TEMP\cmake.zip"
-          Expand-Archive -Path "$env:RUNNER_TEMP\cmake.zip" -DestinationPath "$env:RUNNER_TEMP\cmake" -Force
-          $cmakeBin = "$env:RUNNER_TEMP\cmake\cmake-$ver-windows-arm64\bin"
-          if (-not (Test-Path "$cmakeBin\cmake.exe")) { throw "cmake.exe not found at $cmakeBin" }
-          Add-Content -Path $env:GITHUB_PATH -Value $cmakeBin
-
       - name: Get the version and date on Ubuntu and macOS
         if: runner.os != 'Windows'
         run: |
@@ -87,10 +65,14 @@ jobs:
           echo "ver_pure=$ver_pure" >> $GITHUB_ENV
           echo "date=$(date +'%Y%m%d')" >> $GITHUB_ENV
           echo "git_commit_hash=$git_commit_hash" >> $GITHUB_ENV
-          # Per-arch Linux AppImage naming: amd64 keeps the historical unsuffixed
-          # name (arch_suffix empty). Unused on macOS/Windows.
+          # Per-arch Linux naming, computed once: amd64 keeps the historical
+          # unsuffixed names (arch_suffix empty); snap_arch is snapcraft's token.
+          # Unused on macOS/Windows.
           if [ '${{ inputs.arch }}' = 'aarch64' ]; then
             echo "arch_suffix=_aarch64" >> $GITHUB_ENV
+            echo "snap_arch=arm64" >> $GITHUB_ENV
+          else
+            echo "snap_arch=amd64" >> $GITHUB_ENV
           fi
         shell: bash
 
@@ -141,34 +123,8 @@ jobs:
       - name: Build slicer mac
         if: runner.os == 'macOS' && !inputs.macos-combine-only
         working-directory: ${{ github.workspace }}
-        # arm64 only: build the tests here; the unit_tests_macos job runs them.
-        env:
-          ORCA_TESTS_BUILD_ONLY: ${{ inputs.arch == 'arm64' && '1' || '' }}
         run: |
-          ./build_release_macos.sh -s -n -x ${{ !vars.SELF_HOSTED && '-j 3' || '' }} -a ${{ inputs.arch }} -t 10.15 ${{ inputs.arch == 'arm64' && '-T' || '' }}
-
-      - name: Pack unit tests mac
-        if: runner.os == 'macOS' && !inputs.macos-combine-only && inputs.arch == 'arm64'
-        working-directory: ${{ github.workspace }}
-        run: tar -cvf build_tests.tar build/arm64/tests
-
-      - name: Upload Test Artifact mac
-        if: runner.os == 'macOS' && !inputs.macos-combine-only && inputs.arch == 'arm64'
-        uses: actions/upload-artifact@v7
-        with:
-          name: ${{ github.sha }}-tests-macos-arm64
-          overwrite: true
-          path: build_tests.tar
-          retention-days: 5
-          if-no-files-found: error
-
-      - name: Build system preset cache (macOS)
-        if: runner.os == 'macOS' && !inputs.macos-combine-only
-        working-directory: ${{ github.workspace }}
-        shell: bash
-        # The bundle was already packed from resources/, so the caches have to be
-        # installed into it here; the source tree keeps its JSONs for later jobs.
-        run: ./scripts/build_preset_cache.sh -b build/${{ inputs.arch }} build/${{ inputs.arch }}/OrcaSlicer/OrcaSlicer.app/Contents/Resources/profiles
+          ./build_release_macos.sh -s -n -x ${{ !vars.SELF_HOSTED && '-1' || '' }} -a ${{ inputs.arch }} -t 10.15
 
       - name: Pack macOS app bundle ${{ inputs.arch }}
         if: runner.os == 'macOS' && !inputs.macos-combine-only
@@ -204,11 +160,11 @@ jobs:
         if: runner.os == 'macOS' && inputs.macos-combine-only
         working-directory: ${{ github.workspace }}
         run: |
-          ./build_release_macos.sh -u -x ${{ !vars.SELF_HOSTED && '-j 3' || '' }} -a universal -t 10.15
+          ./build_release_macos.sh -u -x ${{ !vars.SELF_HOSTED && '-1' || '' }} -a universal -t 10.15
 
  # Thanks to RaySajuuk, it's working now
       - name: Sign app and notary
-        if: github.repository == 'OrcaSlicer/OrcaSlicer' && (github.ref == 'refs/heads/main' || github.ref == 'refs/heads/belt-printer' || startsWith(github.ref, 'refs/heads/release/')) && runner.os == 'macOS' && inputs.macos-combine-only
+        if: github.repository == 'OrcaSlicer/OrcaSlicer' && (github.ref == 'refs/heads/main' || startsWith(github.ref, 'refs/heads/release/')) && runner.os == 'macOS' && inputs.macos-combine-only
         working-directory: ${{ github.workspace }}
         env:
           BUILD_CERTIFICATE_BASE64: ${{ secrets.BUILD_CERTIFICATE_BASE64 }}
@@ -229,41 +185,10 @@ jobs:
           security import $CERTIFICATE_PATH -P $P12_PASSWORD -A -t cert -f pkcs12 -k $KEYCHAIN_PATH
           security list-keychain -d user -s $KEYCHAIN_PATH
           security set-key-partition-list -S apple-tool:,apple:,codesign: -s -k $P12_PASSWORD $KEYCHAIN_PATH
-          # codesign --deep is deprecated and cannot sign the bundled Python
-          # runtime (see relocate_python_runtime in build_release_macos.sh).
-          # Sign every nested Mach-O in the bundle explicitly -- notarization
-          # requires the hardened-runtime signature on each -- then seal the
-          # bundle itself last, and verify so coverage gaps fail at CI time
-          # rather than at notarization.
-          ENTITLEMENTS=${{ github.workspace }}/scripts/disable_validation.entitlements
-          sign() {
-            codesign --force --options runtime --timestamp --entitlements "$ENTITLEMENTS" --sign "$CERTIFICATE_ID" "$@"
-          }
-          sign_app() {
-            local app="$1"
-            local machos=()
-            # file is batched via xargs (per-file it costs minutes); universal
-            # binaries also print per-architecture lines, dropped by grep -v.
-            while IFS= read -r f; do machos+=("$f"); done < <(
-              find "$app" -type f -print0 |
-                xargs -0 file --no-pad --mime-type -- |
-                grep -v ' (for architecture ' |
-                grep ': application/x-mach-binary$' |
-                sed 's|: application/x-mach-binary$||'
-            )
-            if [ "${#machos[@]}" -eq 0 ]; then
-              echo "ERROR: no Mach-O files found in $app -- detection is broken" >&2
-              exit 1
-            fi
-            echo "signing ${#machos[@]} Mach-O files in $app"
-            sign "${machos[@]}"
-            sign --verbose "$app"
-            codesign --verify --deep --strict --verbose=2 "$app"
-          }
-          sign_app "${{ github.workspace }}/build/universal/OrcaSlicer/OrcaSlicer.app"
+          codesign --deep --force --verbose --options runtime --timestamp --entitlements ${{ github.workspace }}/scripts/disable_validation.entitlements --sign "$CERTIFICATE_ID" ${{ github.workspace }}/build/universal/OrcaSlicer/OrcaSlicer.app
           # Sign OrcaSlicer_profile_validator.app if it exists
           if [ -f "${{ github.workspace }}/build/universal/OrcaSlicer/OrcaSlicer_profile_validator.app/Contents/MacOS/OrcaSlicer_profile_validator" ]; then
-            sign_app "${{ github.workspace }}/build/universal/OrcaSlicer/OrcaSlicer_profile_validator.app"
+            codesign --deep --force --verbose --options runtime --timestamp --entitlements ${{ github.workspace }}/scripts/disable_validation.entitlements --sign "$CERTIFICATE_ID" ${{ github.workspace }}/build/universal/OrcaSlicer/OrcaSlicer_profile_validator.app
           fi
           
           # Create main OrcaSlicer DMG without the profile validator helper
@@ -272,7 +197,7 @@ jobs:
           cp -R ${{ github.workspace }}/build/universal/OrcaSlicer/OrcaSlicer.app ${{ github.workspace }}/build/universal/OrcaSlicer_dmg/
           ln -sfn /Applications ${{ github.workspace }}/build/universal/OrcaSlicer_dmg/Applications
           retry hdiutil create -volname "OrcaSlicer" -srcfolder ${{ github.workspace }}/build/universal/OrcaSlicer_dmg -ov -format UDZO OrcaSlicer_Mac_universal_${{ env.ver }}.dmg
-          codesign --deep --force --verbose --options runtime --timestamp --entitlements "$ENTITLEMENTS" --sign "$CERTIFICATE_ID" OrcaSlicer_Mac_universal_${{ env.ver }}.dmg
+          codesign --deep --force --verbose --options runtime --timestamp --entitlements ${{ github.workspace }}/scripts/disable_validation.entitlements --sign "$CERTIFICATE_ID" OrcaSlicer_Mac_universal_${{ env.ver }}.dmg
           
           # Create separate OrcaSlicer_profile_validator DMG if the app exists
           if [ -f "${{ github.workspace }}/build/universal/OrcaSlicer/OrcaSlicer_profile_validator.app/Contents/MacOS/OrcaSlicer_profile_validator" ]; then
@@ -281,7 +206,7 @@ jobs:
             cp -R ${{ github.workspace }}/build/universal/OrcaSlicer/OrcaSlicer_profile_validator.app ${{ github.workspace }}/build/universal/OrcaSlicer_profile_validator_dmg/
             ln -sfn /Applications ${{ github.workspace }}/build/universal/OrcaSlicer_profile_validator_dmg/Applications
             retry hdiutil create -volname "OrcaSlicer Profile Validator" -srcfolder ${{ github.workspace }}/build/universal/OrcaSlicer_profile_validator_dmg -ov -format UDZO OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg
-            codesign --deep --force --verbose --options runtime --timestamp --entitlements "$ENTITLEMENTS" --sign "$CERTIFICATE_ID" OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg
+            codesign --deep --force --verbose --options runtime --timestamp --entitlements ${{ github.workspace }}/scripts/disable_validation.entitlements --sign "$CERTIFICATE_ID" OrcaSlicer_profile_validator_Mac_universal_${{ env.ver }}.dmg
           fi
           
           # Notarize main DMG
@@ -295,7 +220,7 @@ jobs:
           fi
 
       - name: Create DMG without notary
-        if: github.ref != 'refs/heads/main' && github.ref != 'refs/heads/belt-printer' && runner.os == 'macOS' && inputs.macos-combine-only
+        if: github.ref != 'refs/heads/main' && runner.os == 'macOS' && inputs.macos-combine-only
         working-directory: ${{ github.workspace }}
         run: |
           # Load the `retry` helper (retries flaky commands such as `hdiutil create`).
@@ -341,13 +266,13 @@ jobs:
           if-no-files-found: ignore
 
       - name: Deploy Mac release
-        if: github.repository == 'OrcaSlicer/OrcaSlicer' && env.deploy_nightly == 'true' && runner.os == 'macOS' && inputs.macos-combine-only && !vars.SELF_HOSTED
+        if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'macOS' && inputs.macos-combine-only && !vars.SELF_HOSTED
         uses: WebFreak001/deploy-nightly@v3.2.0
         with:
           upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
           release_id: 137995723
           asset_path: ${{ github.workspace }}/OrcaSlicer_Mac_universal_${{ env.ver }}.dmg
-          asset_name: OrcaSlicer_Mac_universal_nightly${{ env.nightly_suffix }}.dmg
+          asset_name: OrcaSlicer_Mac_universal_nightly.dmg
           asset_content_type: application/octet-stream
           max_releases: 1 # optional, if there are more releases than this matching the asset_name, the oldest ones are going to be deleted
 
@@ -363,18 +288,6 @@ jobs:
           max_releases: 1
 
 # Windows
-      - name: Set Windows build variables
-        if: runner.os == 'Windows'
-        shell: pwsh
-        run: |
-          if ("${{ inputs.arch }}" -eq "arm64") {
-            "BUILD_DIR=build-arm64"  | Out-File -Append -FilePath $env:GITHUB_ENV -Encoding utf8
-            "ARCH_SUFFIX=_arm64"     | Out-File -Append -FilePath $env:GITHUB_ENV -Encoding utf8
-          } else {
-            "BUILD_DIR=build"        | Out-File -Append -FilePath $env:GITHUB_ENV -Encoding utf8
-            "ARCH_SUFFIX=_x64"       | Out-File -Append -FilePath $env:GITHUB_ENV -Encoding utf8
-          }
-
       - name: setup MSVC
         if: runner.os == 'Windows'
         uses: microsoft/setup-msbuild@v3
@@ -392,52 +305,23 @@ jobs:
         # env:
         #   WindowsSdkDir: 'C:\Program Files (x86)\Windows Kits\10\'
         #   WindowsSDKVersion: '10.0.26100.0\'
-        # "tests" builds the unit tests too; the unit_tests_windows_* jobs run them.
-        run: |
-          $arch = "${{ inputs.arch }}"
-          if ($arch -eq "arm64") { .\build_release_vs.bat slicer arm64 tests } else { .\build_release_vs.bat slicer tests }
-        shell: pwsh
+        run: .\build_release_vs.bat slicer
 
-      - name: Build system preset cache (Windows)
-        if: runner.os == 'Windows'
-        shell: cmd
-        # Shipped into both the already-installed tree (portable zip, MSIX) and
-        # the checkout cpack re-installs from when it builds the NSIS installer.
-        run: scripts\build_preset_cache.bat --prune-source "%BUILD_DIR%" "resources\profiles" "%BUILD_DIR%\OrcaSlicer\resources\profiles"
-
-      - name: Pack unit tests Win
-        if: runner.os == 'Windows'
-        working-directory: ${{ github.workspace }}
-        shell: pwsh
-        run: tar -cvf build_tests.tar ${{ env.BUILD_DIR }}/tests
-
-      - name: Upload Test Artifact Win
-        if: runner.os == 'Windows'
-        uses: actions/upload-artifact@v7
-        with:
-          name: ${{ github.sha }}-tests-windows-${{ inputs.arch }}
-          overwrite: true
-          path: build_tests.tar
-          retention-days: 5
-          if-no-files-found: error
-
-      # NSIS is x86-only; it runs (and the installer it emits runs) under ARM64's
-      # x86 emulation, packaging the native arm64 payload from build-arm64.
       - name: Create installer Win
         if: runner.os == 'Windows' && !vars.SELF_HOSTED
-        working-directory: ${{ github.workspace }}/${{ env.BUILD_DIR }}
+        working-directory: ${{ github.workspace }}/build
         run: |
           cpack -G NSIS
 
       - name: Pack app
         if: runner.os == 'Windows'
-        working-directory: ${{ github.workspace }}/${{ env.BUILD_DIR }}
+        working-directory: ${{ github.workspace }}/build
         shell: cmd
-        run: '"C:/Program Files/7-Zip/7z.exe" a -tzip OrcaSlicer_Windows_${{ env.ver }}${{ env.ARCH_SUFFIX }}_portable.zip ${{ github.workspace }}/${{ env.BUILD_DIR }}/OrcaSlicer'
+        run: '"C:/Program Files/7-Zip/7z.exe" a -tzip OrcaSlicer_Windows_${{ env.ver }}_portable.zip ${{ github.workspace }}/build/OrcaSlicer'
 
       - name: Pack PDB
-        if: runner.os == 'Windows' && inputs.arch != 'arm64' && !vars.SELF_HOSTED
-        working-directory: ${{ github.workspace }}/${{ env.BUILD_DIR }}/src/Release
+        if: runner.os == 'Windows' && !vars.SELF_HOSTED
+        working-directory: ${{ github.workspace }}/build/src/Release
         shell: cmd
         run: '"C:/Program Files/7-Zip/7z.exe" a -m0=lzma2 -mx9 Debug_PDB_${{ env.ver }}_for_developers_only.7z  *.pdb'
 
@@ -445,54 +329,54 @@ jobs:
         if: runner.os == 'Windows'
         uses: actions/upload-artifact@v7
         with:
-          name: OrcaSlicer_Windows_${{ env.ver }}${{ env.ARCH_SUFFIX }}_portable
-          path: ${{ github.workspace }}/${{ env.BUILD_DIR }}/OrcaSlicer
+          name: OrcaSlicer_Windows_${{ env.ver }}_portable
+          path: ${{ github.workspace }}/build/OrcaSlicer
 
       - name: Upload artifacts Win installer
         if: runner.os == 'Windows' && !vars.SELF_HOSTED
         uses: actions/upload-artifact@v7
         with:
-          name: OrcaSlicer_Windows_${{ env.ver }}${{ env.ARCH_SUFFIX }}
-          path: ${{ github.workspace }}/${{ env.BUILD_DIR }}/OrcaSlicer*.exe
+          name: OrcaSlicer_Windows_${{ env.ver }}
+          path: ${{ github.workspace }}/build/OrcaSlicer*.exe
 
       - name: Upload artifacts Win PDB
-        if: runner.os == 'Windows' && inputs.arch != 'arm64' && !vars.SELF_HOSTED
+        if: runner.os == 'Windows' && !vars.SELF_HOSTED
         uses: actions/upload-artifact@v7
         with:
           name: PDB
           path: ${{ github.workspace }}/build/src/Release/Debug_PDB_${{ env.ver }}_for_developers_only.7z
 
       - name: Upload OrcaSlicer_profile_validator Win
-        if: runner.os == 'Windows' && inputs.arch != 'arm64' && !vars.SELF_HOSTED
+        if: runner.os == 'Windows' && !vars.SELF_HOSTED
         uses: actions/upload-artifact@v7
         with:
           name: OrcaSlicer_profile_validator_Windows_${{ env.ver }}
           path: ${{ github.workspace }}/build/src/Release/OrcaSlicer_profile_validator.exe
 
       - name: Deploy Windows release portable
-        if: github.repository == 'OrcaSlicer/OrcaSlicer' && env.deploy_nightly == 'true' && runner.os == 'Windows' && !vars.SELF_HOSTED
+        if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'Windows' && !vars.SELF_HOSTED
         uses: WebFreak001/deploy-nightly@v3.2.0
         with:
           upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
           release_id: 137995723
-          asset_path: ${{ github.workspace }}/${{ env.BUILD_DIR }}/OrcaSlicer_Windows_${{ env.ver }}${{ env.ARCH_SUFFIX }}_portable.zip
-          asset_name: OrcaSlicer_Windows${{ env.ARCH_SUFFIX }}_nightly${{ env.nightly_suffix }}_portable.zip
+          asset_path: ${{ github.workspace }}/build/OrcaSlicer_Windows_${{ env.ver }}_portable.zip
+          asset_name: OrcaSlicer_Windows_nightly_portable.zip
           asset_content_type: application/x-zip-compressed
           max_releases: 1
 
       - name: Deploy Windows release installer
-        if: github.repository == 'OrcaSlicer/OrcaSlicer' && env.deploy_nightly == 'true' && runner.os == 'Windows' && !vars.SELF_HOSTED
+        if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'Windows' && !vars.SELF_HOSTED
         uses: WebFreak001/deploy-nightly@v3.2.0
         with:
           upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
           release_id: 137995723
-          asset_path: ${{ github.workspace }}/${{ env.BUILD_DIR }}/OrcaSlicer_Windows_Installer_${{ env.ver }}${{ env.ARCH_SUFFIX }}.exe
-          asset_name: OrcaSlicer_Windows_Installer${{ env.ARCH_SUFFIX }}_nightly${{ env.nightly_suffix }}.exe
+          asset_path: ${{ github.workspace }}/build/OrcaSlicer_Windows_Installer_${{ env.ver }}.exe
+          asset_name: OrcaSlicer_Windows_Installer_nightly.exe
           asset_content_type: application/x-msdownload
           max_releases: 1
 
       - name: Deploy Windows OrcaSlicer_profile_validator release
-        if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'Windows' && inputs.arch != 'arm64' && !vars.SELF_HOSTED
+        if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'Windows' && !vars.SELF_HOSTED
         uses: WebFreak001/deploy-nightly@v3.2.0
         with:
           upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
@@ -508,9 +392,8 @@ jobs:
         shell: pwsh
         run: |
           ./scripts/msix/build_msix.ps1 `
-            -InstallDir "${{ github.workspace }}/${{ env.BUILD_DIR }}/OrcaSlicer" `
-            -OutputPath "${{ github.workspace }}/${{ env.BUILD_DIR }}/OrcaSlicer_Windows_MSIX_${{ env.ver }}${{ env.ARCH_SUFFIX }}.msix" `
-            -Architecture "${{ inputs.arch }}" `
+            -InstallDir "${{ github.workspace }}/build/OrcaSlicer" `
+            -OutputPath "${{ github.workspace }}/build/OrcaSlicer_Windows_MSIX_${{ env.ver }}.msix" `
             -IdentityName "${{ vars.ORCA_MSIX_IDENTITY_NAME || 'OrcaSlicer.OrcaSlicer' }}" `
             -Publisher "${{ vars.ORCA_MSIX_PUBLISHER || 'CN=38F7EA55-C73B-4072-B3B2-C8E0EA15BB82' }}" `
             -PublisherDisplayName "${{ vars.ORCA_MSIX_PUBLISHER_DISPLAY_NAME || 'OrcaSlicer' }}"
@@ -519,8 +402,8 @@ jobs:
         if: runner.os == 'Windows' && !vars.SELF_HOSTED
         uses: actions/upload-artifact@v7
         with:
-          name: OrcaSlicer_Windows_MSIX_${{ env.ver }}${{ env.ARCH_SUFFIX }}
-          path: ${{ github.workspace }}/${{ env.BUILD_DIR }}/OrcaSlicer_Windows_MSIX_${{ env.ver }}${{ env.ARCH_SUFFIX }}.msix
+          name: OrcaSlicer_Windows_MSIX_${{ env.ver }}
+          path: ${{ github.workspace }}/build/OrcaSlicer_Windows_MSIX_${{ env.ver }}.msix
 
 # Ubuntu
       - name: Apt-Install Dependencies
@@ -533,55 +416,62 @@ jobs:
         if: runner.os == 'Linux'
         shell: bash
         run: |
-          # Build + tar the unit tests (-t) on both Linux legs so each arch
-          # (x86_64 + aarch64) gets tested by its own unit_tests_linux_* job.
-          ./build_linux.sh -istrlL
+          # Build + tar the unit tests (-t) only on the leg that runs them: the
+          # aarch64 leg by default (faster GitHub arm runner), or amd64 when using
+          # self-hosted runners (no arm self-hosted server). unit_tests downloads
+          # this tarball. The profile validator is built with -s, so amd64 keeps it.
+          tests=${{ (!vars.SELF_HOSTED && inputs.arch == 'aarch64') || (vars.SELF_HOSTED && inputs.arch != 'aarch64') }}
+          if $tests; then flags=-istrlL; else flags=-isrlL; fi
+          ./build_linux.sh "$flags"
           ./scripts/check_appimage_libs.sh ./build/package ./build/package/bin/orca-slicer
           appimage=./build/OrcaSlicer_Linux_AppImage${{ env.ubuntu-ver-str }}${{ env.arch_suffix }}_${{ env.ver }}.AppImage
           mv -n ./build/OrcaSlicer_Linux_V${{ env.ver_pure }}.AppImage "$appimage"
           chmod +x "$appimage"
-          tar -cvf build_tests.tar build/tests
+          if $tests; then tar -cvpf build_tests.tar build/tests; fi
+
+        # Build the snap right here, reusing the AppDir we just produced
+        # (build/package): the compiled binary + bundled libs + resources are
+        # repackaged as-is, for both amd64 and aarch64. Skipped on PRs (snapcraft
+        # adds several minutes per arch). The snap is Store-only; it is never
+        # attached to a GitHub release.
+      - name: Free disk space for snap build
+        if: runner.os == 'Linux' && !vars.SELF_HOSTED && github.event_name != 'pull_request'
+        run: sudo rm -rf /usr/local/lib/android /usr/share/dotnet /opt/ghc /opt/hostedtoolcache || true
+      - name: Build snap
+        if: runner.os == 'Linux' && !vars.SELF_HOSTED && github.event_name != 'pull_request'
+        id: snapbuild
+        uses: snapcore/action-build@v1
+      - name: Upload snap artifact
+        if: ${{ ! env.ACT && runner.os == 'Linux' && !vars.SELF_HOSTED && github.event_name != 'pull_request' }}
+        uses: actions/upload-artifact@v7
+        with:
+          name: OrcaSlicer-Linux-snap_${{ env.ver }}_${{ env.snap_arch }}.snap
+          path: ${{ steps.snapbuild.outputs.snap }}
+          retention-days: 5
+          if-no-files-found: error
+        # Nightly -> Snap Store 'edge'. NOTE: classic confinement means the Store
+        # holds uploads for manual review until classic is granted (snap/README.md).
+      - name: Publish snap to edge (nightly)
+        if: github.repository == 'OrcaSlicer/OrcaSlicer' && github.ref == 'refs/heads/main' && runner.os == 'Linux' && !vars.SELF_HOSTED
+        uses: snapcore/action-publish@v1
+        env:
+          SNAPCRAFT_STORE_CREDENTIALS: ${{ secrets.SNAPCRAFT_STORE_CREDENTIALS }}
+        with:
+          snap: ${{ steps.snapbuild.outputs.snap }}
+          release: edge
 
         # Use tar because upload-artifacts won't always preserve directory structure
         # and doesn't preserve file permissions
       - name: Upload Test Artifact
-        if: runner.os == 'Linux'
+        if: runner.os == 'Linux' && ((!vars.SELF_HOSTED && inputs.arch == 'aarch64') || (vars.SELF_HOSTED && inputs.arch != 'aarch64'))
         uses: actions/upload-artifact@v7
         with:
-          name: ${{ github.sha }}-tests-linux-${{ inputs.arch == 'aarch64' && 'aarch64' || 'x86_64' }}
+          name: ${{ github.sha }}-tests
           overwrite: true
           path: build_tests.tar
           retention-days: 5
           if-no-files-found: error
 
-      - name: Build system preset cache (Linux)
-        if: runner.os == 'Linux'
-        shell: bash
-        run: |
-          # Both were packed from resources/ before the caches existed, so the
-          # AppImage is unpacked first and the caches shipped into it and into
-          # the package tree; the source tree keeps its JSONs for later steps.
-          appimage=$(find build -maxdepth 1 -name "OrcaSlicer_Linux_AppImage*.AppImage" | head -1)
-          chmod +x "$appimage"
-          "$appimage" --appimage-extract
-          ./scripts/build_preset_cache.sh -b build build/package/resources/profiles squashfs-root/resources/profiles
-          appimagetool=$(find build -name "appimagetool.AppImage" | head -1)
-          ARCH=$(uname -m) "$appimagetool" --appimage-extract-and-run squashfs-root "$appimage"
-          rm -rf squashfs-root
-        # Ship the freshly-built validator so slice_check_linux (build_all.yml)
-        # can slice-sweep the shipped profiles with this PR's engine. Taken from
-        # the aarch64 leg so the sweep also exercises the arm build; x86_64 on
-        # SELF_HOSTED, which skips arm64.
-      - name: Upload profile validator (for slice check)
-        if: ${{ runner.os == 'Linux' && (vars.SELF_HOSTED && inputs.arch != 'aarch64' || !vars.SELF_HOSTED && inputs.arch == 'aarch64') }}
-        uses: actions/upload-artifact@v7
-        with:
-          name: ${{ github.sha }}-profile-validator-linux-${{ inputs.arch == 'aarch64' && 'aarch64' || 'x86_64' }}
-          overwrite: true
-          path: ./build/src/Release/OrcaSlicer_profile_validator
-          retention-days: 5
-          if-no-files-found: error
-
       - name: Run external slicer regression tests
         if: runner.os == 'Linux' && inputs.arch != 'aarch64'
         timeout-minutes: 20
@@ -616,13 +506,13 @@ jobs:
           path: './build/src/Release/OrcaSlicer_profile_validator'
 
       - name: Deploy Ubuntu release
-        if: ${{ github.repository == 'OrcaSlicer/OrcaSlicer' && ! env.ACT && env.deploy_nightly == 'true' && runner.os == 'Linux' && !vars.SELF_HOSTED }}
+        if: ${{ github.repository == 'OrcaSlicer/OrcaSlicer' && ! env.ACT && github.ref == 'refs/heads/main' && runner.os == 'Linux' && !vars.SELF_HOSTED }}
         uses: WebFreak001/deploy-nightly@v3.2.0
         with:
           upload_url: https://uploads.github.com/repos/OrcaSlicer/OrcaSlicer/releases/137995723/assets{?name,label}
           release_id: 137995723
           asset_path: ./build/OrcaSlicer_Linux_AppImage${{ env.ubuntu-ver-str }}${{ env.arch_suffix }}_${{ env.ver }}.AppImage
-          asset_name: OrcaSlicer_Linux_AppImage${{ env.ubuntu-ver-str }}${{ env.arch_suffix }}_nightly${{ env.nightly_suffix }}.AppImage
+          asset_name: OrcaSlicer_Linux_AppImage${{ env.ubuntu-ver-str }}${{ env.arch_suffix }}_nightly.AppImage
           asset_content_type: application/octet-stream
           max_releases: 1 # optional, if there are more releases than this matching the asset_name, the oldest ones are going to be deleted
       - name: Deploy Ubuntu release

.github/workflows/check_locale.yml

@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:  
       - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       - name: Install gettext 
         run: |

.github/workflows/check_profiles.yml

@@ -1,12 +1,8 @@
 name: Check profiles
 on:
   pull_request:
-    # release/* is included because pr-merge-bot.yml lets delegates merge into
-    # it, and it gates on this workflow's result. Without it a delegated merge
-    # into a release branch would run no profile validation at all.
     branches:
     - main
-    - release/*
     paths:
     - 'resources/profiles/**'
     - ".github/workflows/check_profiles.yml"
@@ -24,13 +20,11 @@ permissions:
 
 jobs:
   check_profiles:
-    # This job name is the check-run name pr-merge-bot.yml requires before a
-    # delegated merge. Renaming it silently disables that gate.
     name: Check profiles
     runs-on: ubuntu-24.04
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       - name: Run extra JSON check
         id: extra_json_check
@@ -44,10 +38,10 @@ jobs:
       - name: Download
         working-directory: ${{ github.workspace }}
         run: |
-          curl -L -o OrcaSlicer_profile_validator https://github.com/OrcaSlicer/OrcaSlicer/releases/download/nightly-builds/OrcaSlicer_profile_validator_Linux_Ubuntu2404_nightly
+          curl -LJO https://github.com/SoftFever/Orca_tools/releases/download/1/OrcaSlicer_profile_validator
           chmod +x ./OrcaSlicer_profile_validator
 
-      # Validate all system profiles.
+      # validate profiles
       - name: validate system profiles
         id: validate_system
         continue-on-error: true
@@ -55,124 +49,17 @@ jobs:
           set +e
           ./OrcaSlicer_profile_validator -p ${{ github.workspace }}/resources/profiles -l 2 2>&1 | tee ${{ runner.temp }}/validate_system.log
           exit ${PIPESTATUS[0]}
-      # Slice a two-colour cube through every printer so all custom g-code (incl. change_filament_gcode)
-      # is expanded - catches undefined-placeholder / invalid-flow bugs the static checks above cannot see.
-      - name: validate slice (expand custom g-code)
-        id: validate_slice
-        continue-on-error: true
-        run: |
-          set +e
-          ./OrcaSlicer_profile_validator -p ${{ github.workspace }}/resources/profiles -s -l 2 2>&1 | tee ${{ runner.temp }}/validate_slice.log
-          exit ${PIPESTATUS[0]}
-      # For now run filament subtype check only for BBL profiles until we fix other vendors' profiles.
-      - name: validate filament subtype check for BBL profiles
-        id: validate_filament_subtypes
-        continue-on-error: true
-        run: |
-          set +e
-          ./OrcaSlicer_profile_validator -p ${{ github.workspace }}/resources/profiles -l 2 -v BBL -f 2>&1 | tee ${{ runner.temp }}/validate_filament_subtypes.log
-          exit ${PIPESTATUS[0]}
 
       - name: validate custom presets
         id: validate_custom
         continue-on-error: true
         working-directory: ${{ github.workspace }}
         run: |
-          fixtures_dir="${{ runner.temp }}/profile-fixtures"
-          output_dir="${{ runner.temp }}/custom-preset-validation"
-          combined_log="${{ runner.temp }}/validate_custom.log"
-          summary="${output_dir}/summary.md"
-          release_url="https://github.com/OrcaSlicer/OrcaSlicer-profile-validator/releases/download/fixture-archive"
-
-          rm -rf "${fixtures_dir}" "${output_dir}"
-          mkdir -p "${fixtures_dir}" "${output_dir}"
-
-          curl -fsSL -o "${fixtures_dir}/manifest.json" "${release_url}/manifest.json"
-
-          MANIFEST_PATH="${fixtures_dir}/manifest.json" python3 <<'PY' > "${fixtures_dir}/fixtures.tsv"
-          import json
-          import os
-
-          with open(os.environ["MANIFEST_PATH"], encoding="utf-8") as fh:
-              manifest = json.load(fh)
-
-          if isinstance(manifest, dict):
-              entries = manifest.get("fixtures", [])
-          else:
-              entries = manifest
-
-          for entry in entries:
-              version = entry.get("version", "")
-              asset = entry.get("asset", "")
-              sha256 = entry.get("asset_sha256", "")
-              if not version or not asset:
-                  continue
-              print(f"{version}\t{asset}\t{sha256}")
-          PY
-
-          if [ ! -s "${fixtures_dir}/fixtures.tsv" ]; then
-            echo "No custom preset fixtures found in ${release_url}/manifest.json" | tee "${combined_log}"
-            exit 1
-          fi
-
-          {
-            echo "## Custom Preset Fixture Validation"
-            echo ""
-            echo "| Version | Status | Log |"
-            echo "| --- | --- | --- |"
-          } > "${summary}"
-
-          status=0
-          failed_logs=()
-
-          while IFS=$'\t' read -r version asset expected_sha256; do
-            fixture_zip="${fixtures_dir}/${asset}"
-            asset_url_name="$(python3 -c 'import sys, urllib.parse; print(urllib.parse.quote(sys.argv[1], safe=""))' "${asset}")"
-            profile_tree="${output_dir}/profiles-${version}"
-            log_path="${output_dir}/${version}.log"
-
-            curl -fsSL -o "${fixture_zip}" "${release_url}/${asset_url_name}"
-
-            if [ -n "${expected_sha256}" ] && [ "${expected_sha256}" != "<sha256>" ]; then
-              echo "${expected_sha256}  ${fixture_zip}" | sha256sum -c -
-            fi
-
-            rm -rf "${profile_tree}"
-            mkdir -p "${profile_tree}"
-            cp -a "${{ github.workspace }}/resources/profiles/." "${profile_tree}/"
-            rm -rf "${profile_tree}/user"
-            unzip -q "${fixture_zip}" -d "${profile_tree}"
-
-            set +e
-            ./OrcaSlicer_profile_validator -p "${profile_tree}" -l 2 > "${log_path}" 2>&1
-            result=$?
-            set -e
-
-            if [ "${result}" -eq 0 ]; then
-              echo "| ${version} | PASS | ${version}.log |" >> "${summary}"
-            else
-              echo "| ${version} | FAIL | ${version}.log |" >> "${summary}"
-              failed_logs+=("${log_path}")
-              status=1
-            fi
-          done < "${fixtures_dir}/fixtures.tsv"
-
-          {
-            cat "${summary}"
-            if [ "${#failed_logs[@]}" -gt 0 ]; then
-              echo ""
-              echo "## Failed Fixture Logs"
-              for log_path in "${failed_logs[@]}"; do
-                echo ""
-                echo "### $(basename "${log_path}" .log)"
-                echo '```'
-                head -c 12000 "${log_path}" || echo "No output captured"
-                echo '```'
-              done
-            fi
-          } | tee "${combined_log}"
-
-          exit "${status}"
+          set +e
+          curl -LJO https://github.com/OrcaSlicer/OrcaSlicer/releases/download/nightly-builds/orca_custom_preset_tests.zip
+          unzip -q ./orca_custom_preset_tests.zip -d ${{ github.workspace }}/resources/profiles
+          ./OrcaSlicer_profile_validator -p ${{ github.workspace }}/resources/profiles -l 2 2>&1 | tee ${{ runner.temp }}/validate_custom.log
+          exit ${PIPESTATUS[0]}
 
       - name: Prepare PR number for comment workflow
         if: ${{ always() && github.event_name == 'pull_request' }}
@@ -181,7 +68,7 @@ jobs:
           echo "${{ github.event.pull_request.number }}" > ${{ runner.temp }}/profile-check-results/pr_number.txt
 
       - name: Prepare comment artifact
-        if: ${{ always() && github.event_name == 'pull_request' && (steps.extra_json_check.outcome == 'failure' || steps.validate_system.outcome == 'failure' || steps.validate_slice.outcome == 'failure' || steps.validate_filament_subtypes.outcome == 'failure' || steps.validate_custom.outcome == 'failure') }}
+        if: ${{ always() && github.event_name == 'pull_request' && (steps.extra_json_check.outcome == 'failure' || steps.validate_system.outcome == 'failure' || steps.validate_custom.outcome == 'failure') }}
         run: |
           {
             # Marker matched by check_profiles_comment.yml to delete prior comments.
@@ -207,24 +94,6 @@ jobs:
               echo ""
             fi
 
-            if [ "${{ steps.validate_slice.outcome }}" = "failure" ]; then
-              echo "### Slice Validation Failed (custom g-code expansion)"
-              echo ""
-              echo '```'
-              head -c 30000 ${{ runner.temp }}/validate_slice.log || echo "No output captured"
-              echo '```'
-              echo ""
-            fi
-
-            if [ "${{ steps.validate_filament_subtypes.outcome }}" = "failure" ]; then
-              echo "### BBL Filament Subtype Validation Failed"
-              echo ""
-              echo '```'
-              head -c 30000 ${{ runner.temp }}/validate_filament_subtypes.log || echo "No output captured"
-              echo '```'
-              echo ""
-            fi
-
             if [ "${{ steps.validate_custom.outcome }}" = "failure" ]; then
               echo "### Custom Preset Validation Failed"
               echo ""
@@ -247,7 +116,7 @@ jobs:
           retention-days: 1
 
       - name: Fail if any check failed
-        if: ${{ always() && (steps.extra_json_check.outcome == 'failure' || steps.validate_system.outcome == 'failure' || steps.validate_slice.outcome == 'failure' || steps.validate_filament_subtypes.outcome == 'failure' || steps.validate_custom.outcome == 'failure') }}
+        if: ${{ always() && (steps.extra_json_check.outcome == 'failure' || steps.validate_system.outcome == 'failure' || steps.validate_custom.outcome == 'failure') }}
         run: |
           echo "One or more profile checks failed. See above for details."
           exit 1

.github/workflows/cli_overrides.yml

@@ -1,145 +0,0 @@
-# CLI override sweep (orca-test-repo test_cli_overrides.py) against the
-# latest successful Linux AppImage build of this repo. Verifies every CLI
-# config option lands in the merged config and the sliced G-code's
-# CONFIG_BLOCK, then re-slices each landed option individually to classify
-# it effective/inert (--effect-full). Headless CLI only - no display stack.
-name: CLI Override Sweep
-
-on:
-  # temporary, for pre-merge branch testing: workflow_dispatch only works once
-  # the workflow exists on the default branch, but push events run the
-  # workflow from the pushed ref. Remove this trigger when merging to main.
-  push:
-    branches: ["hanif/parity-harness"]
-  workflow_dispatch:
-    inputs:
-      test_repo_ref:
-        description: "orca-test-repo ref to run"
-        required: false
-        default: "cli-test-suite"
-      build_branch:
-        description: "branch whose latest successful build_all artifact to test"
-        required: false
-        default: "main"
-
-permissions:
-  contents: read
-  actions: read
-
-jobs:
-  overrides:
-    runs-on: ubuntu-24.04
-    timeout-minutes: 60
-    strategy:
-      fail-fast: false
-      matrix:
-        # The effect stage re-slices every landed option one at a time and
-        # cannot batch, so it is the whole cost of this job.
-        # parity/effect_routing.json groups options by the cheapest fixture that
-        # can show their effect and splits them into balanced, disjoint shards
-        # covering every landed option exactly once. Measured at ~12.5 min a
-        # shard; un-sharded the sweep is ~24 min, so this is about feedback time
-        # rather than fitting the timeout.
-        shard: [0, 1]
-    steps:
-      - name: Find the latest successful Linux build
-        id: build
-        env:
-          GH_TOKEN: ${{ github.token }}
-          GH_REPO: ${{ github.repository }}
-        run: |
-          set -euo pipefail
-          gh run list --workflow build_all.yml \
-            --branch "${{ github.event.inputs.build_branch || 'main' }}" \
-            --status success --limit 1 --json databaseId,headSha \
-            --jq '"run_id=\(.[0].databaseId)\nhead_sha=\(.[0].headSha)"' \
-            >> "$GITHUB_OUTPUT"
-          cat "$GITHUB_OUTPUT"
-
-      - name: Check out the test suite
-        uses: actions/checkout@v5
-        with:
-          repository: OrcaSlicer/orca-test-repo
-          # temporary fallback for push-triggered branch testing (inputs are
-          # empty on push): restore to 'cli-test-suite' when merging to main
-          ref: ${{ github.event.inputs.test_repo_ref || 'hanif/parity-harness' }}
-          path: orca-test-repo
-
-      # the AppImage ships only packed .opc preset caches, no profile JSONs,
-      # so resources/ (and the option-surface source) must come from the
-      # source tree at the SAME sha the artifact was built from
-      - name: Check out OrcaSlicer sources at the build's sha
-        uses: actions/checkout@v5
-        with:
-          ref: ${{ steps.build.outputs.head_sha }}
-          path: slicer
-
-      - name: Download and extract the Linux AppImage
-        env:
-          GH_TOKEN: ${{ github.token }}
-          GH_REPO: ${{ github.repository }}
-        run: |
-          set -euo pipefail
-          gh run download "${{ steps.build.outputs.run_id }}" --dir appimage \
-            --pattern "OrcaSlicer_Linux_ubuntu_2404*"
-          appimage=$(find appimage -name "*.AppImage" ! -name "*aarch64*" | head -1)
-          [ -n "$appimage" ] || { echo "no AppImage found"; ls -R appimage; exit 1; }
-          chmod +x "$appimage"
-          "$appimage" --appimage-extract > /dev/null
-          [ -x squashfs-root/AppRun ] || { echo "no AppRun in AppImage"; exit 1; }
-          echo "ORCA_BIN=$PWD/squashfs-root/AppRun" >> "$GITHUB_ENV"
-          echo "ORCA_SOURCE=$PWD/slicer" >> "$GITHUB_ENV"
-
-      - name: Install the AppImage's host runtime dependencies
-        run: |
-          # orca-slicer-env's two preflight gates: OpenGL and WebKitGTK 4.1
-          sudo apt-get update
-          sudo apt-get install -y --no-install-recommends \
-            libopengl0 libglu1-mesa libgl1 libegl1 libwebkit2gtk-4.1-0
-
-      - name: Install suite dependencies
-        run: pip install -r orca-test-repo/requirements.txt
-
-      - name: Run the override sweep (full effect stage)
-        id: run
-        continue-on-error: true
-        working-directory: orca-test-repo
-        run: |
-          # -rA prints the per-stage summaries: pytest captures stdout on
-          # passing tests, so without it every "grep override sweep" below
-          # finds nothing and the job summary says "no stage summaries"
-          python -m pytest test_cli_overrides.py -c pytest.ini -v -rA --effect-full \
-            --effect-shard ${{ matrix.shard }}/2 \
-            --orca-bin "$ORCA_BIN" --orca-source "$ORCA_SOURCE" \
-            2>&1 | tee ../sweep.log
-
-      - name: Publish job summary
-        if: always()
-        run: |
-          {
-            echo "## CLI override sweep - shard ${{ matrix.shard }}/2"
-            grep -E "\[override sweep" sweep.log || echo "no stage summaries (see log)"
-            echo
-            grep -E "^(=+ )?[0-9]+ (passed|failed)" sweep.log | tail -1 || true
-          } >> "$GITHUB_STEP_SUMMARY"
-
-      - name: Upload the override report
-        if: always()
-        uses: actions/upload-artifact@v7
-        with:
-          name: override-report-${{ github.run_id }}-shard${{ matrix.shard }}
-          path: |
-            orca-test-repo/.pytest_cache/override_report.json
-            sweep.log
-          if-no-files-found: warn
-          retention-days: 30
-
-      # The sweep step is continue-on-error so the summary and artifact steps
-      # above still run on a failure - without this the job would then report
-      # success, and a shard that measured nothing would look identical to a
-      # healthy one.
-      - name: Fail the job if the sweep failed
-        if: steps.run.outcome == 'failure'
-        run: |
-          echo "the override sweep failed - see the job summary and the uploaded report" >&2
-          exit 1

.github/workflows/dedupe-issues.yml

@@ -20,14 +20,14 @@ jobs:
 
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       - name: Run Claude Code slash command
         uses: anthropics/claude-code-base-action@beta
         with:
           prompt: "/dedupe ${{ github.repository }}/issues/${{ github.event.issue.number || inputs.issue_number }}"
           claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
-          model: "claude-sonnet-4-5-20250929"
+          claude_args: "--model claude-sonnet-4-5-20250929"
           claude_env: |
             GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
 

.github/workflows/doxygen-docs.yml

@@ -26,7 +26,7 @@ jobs:
           remove-existing-swap-files: true
 
       - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       - name: Install Doxygen and Graphviz
         run: |

.github/workflows/parity.yml

@@ -1,144 +0,0 @@
-# GUI-vs-CLI parity check. Runs the parity harness from
-# OrcaSlicer/orca-test-repo (parity/) against the latest successful Linux
-# AppImage build of this repo. Metrics-only: the job never gates - its
-# product is scorecard.json / report.md, with the count of NEW divergences
-# (differences not in the harness's known-differences ledger) as the
-# headline number in the job summary.
-name: GUI-CLI Parity
-
-on:
-  # temporary, for pre-merge branch testing: workflow_dispatch only works once
-  # the workflow exists on the default branch, but push events run the
-  # workflow from the pushed ref. Remove this trigger when merging to main.
-  push:
-    branches: ["hanif/parity-harness"]
-  schedule:
-    - cron: "30 18 * * *"
-  workflow_dispatch:
-    inputs:
-      fixtures:
-        description: "space-separated fixture ids (empty = all)"
-        required: false
-        default: ""
-      test_repo_ref:
-        description: "orca-test-repo ref to run"
-        required: false
-        default: "cli-test-suite"
-      build_branch:
-        description: "branch whose latest successful build_all artifact to slice with"
-        required: false
-        default: "main"
-      cli_presets:
-        description: "lane C preset handling: flat = flatten inherits (clean parity), raw = leaf as-is (measures the CLI's unresolved-inherits behavior, expect large divergence on unfixed builds)"
-        required: false
-        default: "flat"
-
-permissions:
-  contents: read
-  actions: read
-
-jobs:
-  parity:
-    runs-on: ubuntu-24.04
-    timeout-minutes: 180
-    steps:
-      - name: Find the latest successful Linux build
-        id: build
-        env:
-          GH_TOKEN: ${{ github.token }}
-          GH_REPO: ${{ github.repository }}
-        run: |
-          set -euo pipefail
-          gh run list --workflow build_all.yml \
-            --branch "${{ github.event.inputs.build_branch || 'main' }}" \
-            --status success --limit 1 --json databaseId,headSha \
-            --jq '"run_id=\(.[0].databaseId)\nhead_sha=\(.[0].headSha)"' \
-            >> "$GITHUB_OUTPUT"
-          cat "$GITHUB_OUTPUT"
-
-      - name: Check out the parity test suite
-        uses: actions/checkout@v5
-        with:
-          repository: OrcaSlicer/orca-test-repo
-          # temporary fallback for push-triggered branch testing (inputs are
-          # empty on push): restore to 'cli-test-suite' when merging to main
-          ref: ${{ github.event.inputs.test_repo_ref || 'hanif/parity-harness' }}
-          path: orca-test-repo
-
-      # the AppImage ships only packed .opc preset caches, no profile JSONs,
-      # so resources/profiles must come from the source tree at the SAME sha
-      # the artifact was built from
-      - name: Check out OrcaSlicer sources at the build's sha
-        uses: actions/checkout@v5
-        with:
-          ref: ${{ steps.build.outputs.head_sha }}
-          path: slicer
-
-      - name: Download and extract the Linux AppImage
-        env:
-          GH_TOKEN: ${{ github.token }}
-          GH_REPO: ${{ github.repository }}
-        run: |
-          set -euo pipefail
-          gh run download "${{ steps.build.outputs.run_id }}" --dir appimage \
-            --pattern "OrcaSlicer_Linux_ubuntu_2404*"
-          # prefer the x86_64 artifact (amd64 is historically unsuffixed)
-          appimage=$(find appimage -name "*.AppImage" ! -name "*aarch64*" | head -1)
-          [ -n "$appimage" ] || { echo "no AppImage found"; ls -R appimage; exit 1; }
-          chmod +x "$appimage"
-          "$appimage" --appimage-extract > /dev/null
-          # the bare binary misses bundled libs (libavcodec etc.) - use AppRun,
-          # which sets up the AppImage's library paths and forwards arguments
-          [ -x squashfs-root/AppRun ] || { echo "no AppRun in AppImage"; exit 1; }
-          echo "ORCA_BIN=$PWD/squashfs-root/AppRun" >> "$GITHUB_ENV"
-          echo "ORCA_SLICER_ROOT=$PWD/slicer" >> "$GITHUB_ENV"
-
-      - name: Install display tooling for the GUI lanes
-        run: |
-          sudo apt-get update
-          # the AppImage's orca-slicer-env preflight requires host OpenGL and
-          # WebKitGTK 4.1 runtimes; everything else ships in the AppImage
-          sudo apt-get install -y --no-install-recommends \
-            xvfb xdotool imagemagick openbox mesa-utils \
-            libopengl0 libglu1-mesa libgl1 libegl1 libwebkit2gtk-4.1-0
-
-      - name: Run the parity harness
-        id: run
-        continue-on-error: true
-        run: |
-          set -euo pipefail
-          fixtures=""
-          for f in ${{ github.event.inputs.fixtures || '' }}; do
-            fixtures="$fixtures --fixture $f"
-          done
-          # 2 concurrent GUI displays: measured ~1.5 cores peak / ~1.9 GB on
-          # this 4-vCPU / 16 GB runner (3+ would contend); each fixture is
-          # fully isolated so this is correctness-neutral
-          python3 orca-test-repo/parity/run_parity.py \
-            --slicer-root "$ORCA_SLICER_ROOT" --bin "$ORCA_BIN" \
-            --cli-presets "${{ github.event.inputs.cli_presets || 'flat' }}" \
-            --gui-workers 2 \
-            --out "$PWD/parity-out" $fixtures
-
-      - name: Publish job summary
-        if: always()
-        run: |
-          if [ -f parity-out/report.md ]; then
-            cat parity-out/report.md >> "$GITHUB_STEP_SUMMARY"
-          else
-            echo "harness produced no report (see logs)" >> "$GITHUB_STEP_SUMMARY"
-          fi
-
-      - name: Prune bulky per-lane state before upload
-        if: always()
-        run: |
-          rm -rf parity-out/*/seed parity-out/*/datadir-* || true
-
-      - name: Upload scorecard and evidence
-        if: always()
-        uses: actions/upload-artifact@v7
-        with:
-          name: parity-scorecard-${{ github.run_id }}
-          path: parity-out/
-          if-no-files-found: warn
-          retention-days: 30

.github/workflows/pr-label-bot.yml

@@ -24,7 +24,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Ask PR author for label
-        uses: actions/github-script@v9
+        uses: actions/github-script@v7
         with:
           script: |
             function isPermissionDenied(error) {
@@ -79,92 +79,6 @@ jobs:
               throw error;
             }
 
-  localization-pr:
-    if: github.event_name == 'pull_request_target'
-    permissions:
-      contents: read
-      pull-requests: write
-      issues: write
-    runs-on: ubuntu-latest
-    steps:
-      - name: Auto-label and remind about the localization glossary
-        uses: actions/github-script@v9
-        with:
-          script: |
-            function isPermissionDenied(error) {
-              return error && error.status === 403 && /Resource not accessible by integration/i.test(error.message || '');
-            }
-
-            const pr = context.payload.pull_request;
-
-            // List changed files once (mirrors the `localization/**` paths filter in check_locale.yml)
-            const files = await github.paginate(github.rest.pulls.listFiles, {
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              pull_number: pr.number,
-              per_page: 100
-            });
-            const touchesLocalization = files.some((file) => file.filename.startsWith('localization/'));
-            const onlyPoFiles = files.length > 0 && files.every((file) => file.filename.endsWith('.po'));
-
-            // If the PR changes only .po files, automatically apply the Localization label
-            if (onlyPoFiles) {
-              try {
-                await github.rest.issues.addLabels({
-                  owner: context.repo.owner,
-                  repo: context.repo.repo,
-                  issue_number: pr.number,
-                  labels: ['Localization']
-                });
-                core.info('Applied Localization label (PR changes only .po files).');
-              } catch (error) {
-                if (isPermissionDenied(error)) {
-                  core.warning('Cannot add Localization label because token cannot write.');
-                } else {
-                  throw error;
-                }
-              }
-            }
-
-            if (!touchesLocalization) {
-              core.info('No localization changes detected; skipping glossary reminder.');
-              return;
-            }
-
-            // Avoid posting the reminder twice (e.g. on reopen)
-            const marker = '<!-- localization-glossary-reminder -->';
-            const comments = await github.paginate(github.rest.issues.listComments, {
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              issue_number: pr.number,
-              per_page: 100
-            });
-            if (comments.some((comment) => (comment.body || '').includes(marker))) {
-              core.info('Glossary reminder already present; skipping.');
-              return;
-            }
-
-            try {
-              await github.rest.issues.createComment({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                issue_number: pr.number,
-                body:
-                  `${marker}\n` +
-                  `Hi @${pr.user.login}, this PR changes translations (\`localization/**\`).\n\n` +
-                  `Please make sure recurring terms follow the [Localization glossary](https://www.orcaslicer.com/wiki/localization_glossary), ` +
-                  `so the same English term is always rendered the same way within a language and terms that must stay in English ` +
-                  `(brand/product names, acronyms, file formats, G-code, macros/variables) are not translated.`
-              });
-            } catch (error) {
-              if (isPermissionDenied(error)) {
-                core.warning('Skipping glossary reminder because token cannot write comments.');
-                return;
-              }
-
-              throw error;
-            }
-
   apply-label:
     if: github.event_name == 'issue_comment'
     permissions:
@@ -174,7 +88,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Apply label command from PR author
-        uses: actions/github-script@v9
+        uses: actions/github-script@v7
         with:
           script: |
             function isPermissionDenied(error) {

.github/workflows/pr-merge-bot.yml

@@ -1,510 +0,0 @@
-name: PR Merge Bot
-
-# Merges a pull request on request from a delegated vendor profile maintainer.
-# The merge is performed by this workflow's GITHUB_TOKEN, so a delegate needs no
-# repository access.
-#
-# Commands, posted as a comment on the PR:
-#   /bot merge              squash-merge the PR
-#   /bot merge --dry-run    report the verdict without merging
-#
-# Merges only when the commenter holds a grant covering every changed path, the
-# PR targets main or release/*, and CI is green on the head commit. Otherwise it
-# comments naming the files that fell outside the grant.
-#
-# Grants come from the FOLDER_MERGERS variable in the `merge-delegation`
-# environment: one per line, `account: path`, `#` comments and blank lines
-# allowed. Paths may contain spaces. A vendor takes two grants, the folder and
-# its sibling bundle JSON:
-#
-#   # Acme profiles
-#   vendor-maintainer: resources/profiles/Acme/
-#   vendor-maintainer: resources/profiles/Acme.json
-#
-# Edit the grant list (environment scope, so admin only):
-#   gh variable set FOLDER_MERGERS --env merge-delegation --body "$(cat folder-mergers.txt)"
-#   gh variable get FOLDER_MERGERS --env merge-delegation
-#
-# Stop all merging without touching this file:
-#   gh variable set MERGE_BOT_DRY_RUN --body true
-
-on:
-  issue_comment:
-    types:
-      - created
-
-# One merge attempt per PR at a time, so two quick comments cannot race.
-concurrency:
-  group: ${{ github.workflow }}-${{ github.event.issue.number }}
-  cancel-in-progress: false
-
-jobs:
-  merge:
-    # Skips the job unless a PR comment mentions the command.
-    if: >-
-      github.repository == 'OrcaSlicer/OrcaSlicer'
-      && github.event.issue.pull_request != null
-      && contains(github.event.comment.body, '/bot merge')
-    permissions:
-      contents: write        # pulls.merge
-      pull-requests: write   # pulls.merge
-      issues: write          # feedback comment + reactions
-      actions: write         # re-dispatch build_all.yml after the merge
-    runs-on: ubuntu-latest
-    timeout-minutes: 10
-    # Supplies FOLDER_MERGERS. Must carry no protection rules, or every
-    # delegated merge would wait for a human reviewer.
-    environment: merge-delegation
-    steps:
-      - name: Merge PR on behalf of a folder delegate
-        uses: actions/github-script@v9
-        env:
-          # Read as env vars, never interpolated into the script body.
-          FOLDER_MERGERS: ${{ vars.FOLDER_MERGERS }}
-          MERGE_BOT_DRY_RUN: ${{ vars.MERGE_BOT_DRY_RUN }}
-        with:
-          script: |
-            function isPermissionDenied(error) {
-              return error && error.status === 403 && /Resource not accessible by integration/i.test(error.message || '');
-            }
-
-            const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
-            const MARKER = '<!-- pr-merge-bot -->';
-            // No grant may reach outside this root.
-            const DELEGATABLE_ROOT = 'resources/profiles/';
-            const ALLOWED_BASE_BRANCH = /^(?:main|release\/.+)$/;
-            const MERGE_METHOD = 'squash';
-            const REQUIRED_CHECK = 'Check profiles';   // job name in check_profiles.yml
-            const MAX_CHANGED_FILES = 500;             // policy cap, well under listFiles' 3000
-            const LISTFILES_CAP = 3000;
-            const MAX_REPORTED_FILES = 12;
-            const MERGEABLE_ATTEMPTS = 5;
-            const MERGEABLE_DELAY_MS = 2000;
-            const OK_CONCLUSIONS = new Set(['success', 'neutral', 'skipped']);
-            const REGULAR_FILE_MODES = new Set(['100644', '100755']);
-
-            // Paths refused whatever the grants say. Checked before grants, so
-            // delegating a new root means removing it from this list too.
-            const DENIED_PATTERNS = [
-              /^\.github\//,
-              /(^|\/)\.git(attributes|modules|ignore|config)$/,
-              /^(?:src|deps|deps_src|tests|tools|cmake|sandboxes|scripts|docs?|localization|bbl)\//,
-              /(^|\/)cmakelists\.txt$/,
-              /\.cmake$/,
-              /^build_[^/]*\.(?:sh|bat)$/,
-              /^version\.inc$/,
-              // Executables, including those inside the delegatable root.
-              /\.(?:sh|bash|bat|cmd|ps1|py|js|mjs|cjs|ts|rb|pl|php)$/
-            ];
-
-            function parseGrants(raw) {
-              // GitHub login: 1-39 chars, alphanumerics with single interior hyphens.
-              const loginPattern = /^[A-Za-z0-9](?:[A-Za-z0-9]|-(?=[A-Za-z0-9])){0,38}$/;
-              const grantsByLogin = new Map();
-              const problems = [];
-
-              (raw || '').split(/\r?\n/).forEach((rawLine, index) => {
-                const line = rawLine.trim();
-                if (!line || line.startsWith('#')) {
-                  return;
-                }
-
-                // Splits on the first colon only, so paths may contain ':' and spaces.
-                const separator = line.indexOf(':');
-                if (separator === -1) {
-                  problems.push(`line ${index + 1}: expected \`account: path\``);
-                  return;
-                }
-
-                const login = line.slice(0, separator).trim().replace(/^@/, '');
-                const path = line.slice(separator + 1).trim().replace(/\/+$/, '');
-
-                if (!loginPattern.test(login)) {
-                  problems.push(`line ${index + 1}: \`${login}\` is not a valid GitHub account name`);
-                  return;
-                }
-                if (/[\\*?\u0000-\u001f\u007f]/.test(path) || path.split('/').includes('..') || path.includes('//')) {
-                  problems.push(`line ${index + 1}: invalid path (no globs, \`..\`, \`//\`, backslashes or control characters)`);
-                  return;
-                }
-                // Rejects anything outside the root, and the bare root itself.
-                if (!path.startsWith(DELEGATABLE_ROOT) || path.length <= DELEGATABLE_ROOT.length) {
-                  problems.push(`line ${index + 1}: \`${path}\` is not inside \`${DELEGATABLE_ROOT}\``);
-                  return;
-                }
-
-                const key = login.toLowerCase();
-                grantsByLogin.set(key, (grantsByLogin.get(key) || []).concat(path));
-              });
-
-              return { grantsByLogin, problems };
-            }
-
-            function isDenied(path) {
-              if (/[\\\u0000-\u001f\u007f]/.test(path) || path.startsWith('/') || path.split('/').includes('..')) {
-                return true;
-              }
-
-              const normalized = path.normalize('NFKC').toLowerCase();
-              return DENIED_PATTERNS.some((pattern) => pattern.test(normalized));
-            }
-
-            // Byte-exact match on directory boundaries, so a grant of
-            // `.../Acme` covers neither `.../Acme Labs/x.json` nor `.../Acme.json`.
-            function isGranted(path, grants) {
-              return grants.some((grant) => path === grant || path.startsWith(`${grant}/`));
-            }
-
-            // Both endpoints of a rename; both must satisfy the grant.
-            function pathsFor(file) {
-              return [file.filename, file.previous_filename].filter(Boolean);
-            }
-
-            function formatList(items) {
-              const unique = [...new Set(items)];
-              const shown = unique.slice(0, MAX_REPORTED_FILES).map((item) => `- \`${item}\``);
-              if (unique.length > MAX_REPORTED_FILES) {
-                shown.push(`- …and ${unique.length - MAX_REPORTED_FILES} more`);
-              }
-              return shown.join('\n');
-            }
-
-            const { owner, repo } = context.repo;
-            const issue = context.payload.issue;
-            const comment = context.payload.comment;
-
-            if (!issue.pull_request) {
-              core.info('Ignoring comment that is not on a pull request.');
-              return;
-            }
-            // Ignores a comment whose sender is not its author.
-            if (context.payload.action !== 'created' || context.payload.sender.login !== comment.user.login) {
-              core.warning('Ignoring comment whose sender does not match its author.');
-              return;
-            }
-            if (comment.user.type !== 'User') {
-              core.info('Ignoring bot-authored command.');
-              return;
-            }
-
-            const commandLine = (comment.body || '')
-              .split('\n')
-              .map((line) => line.trim())
-              .find((line) => /^\/bot\s+merge\b/i.test(line));
-
-            if (!commandLine) {
-              core.info('No /bot merge command found.');
-              return;
-            }
-
-            const commenter = comment.user.login;
-            const { grantsByLogin, problems } = parseGrants(process.env.FOLDER_MERGERS);
-            const grants = grantsByLogin.get(commenter.toLowerCase()) || [];
-
-            for (const problem of problems) {
-              core.warning(`FOLDER_MERGERS ${problem}`);
-            }
-
-            // Says nothing to accounts with no grant, so it cannot be used to spam.
-            if (!grants.length) {
-              core.info(`Ignoring /bot merge from @${commenter}: not listed in FOLDER_MERGERS.`);
-              return;
-            }
-
-            // Warns instead of failing when the token cannot post feedback.
-            async function bestEffort(call, warning) {
-              try {
-                await call();
-              } catch (error) {
-                if (isPermissionDenied(error)) {
-                  core.warning(warning);
-                  return;
-                }
-
-                throw error;
-              }
-            }
-
-            const react = (content) => bestEffort(
-              () => github.rest.reactions.createForIssueComment({ owner, repo, comment_id: comment.id, content }),
-              `Cannot add the "${content}" reaction because the token cannot write.`);
-
-            const say = (body) => bestEffort(
-              () => github.rest.issues.createComment({ owner, repo, issue_number: issue.number, body: `${MARKER}\n${body}` }),
-              'Cannot post a comment because the token cannot write comments.');
-
-            // Declines the command: warns in the log, reacts, explains on the PR.
-            async function refuse(reason) {
-              const configNote = problems.length
-                ? `\n\n\`FOLDER_MERGERS\` also has problems a maintainer needs to fix:\n${problems.map((problem) => `- ${problem}`).join('\n')}`
-                : '';
-              const grantsNote = `\n\n<details><summary>Your current grants</summary>\n\n${formatList(grants)}\n\n</details>`;
-
-              core.warning(`Refused /bot merge from @${commenter}: ${reason}`);
-              await react('-1');
-              await say(`@${commenter} I can't merge this PR: ${reason}${configNote}${grantsNote}`);
-            }
-
-            await react('eyes');
-
-            const args = (commandLine.match(/^\/bot\s+merge\s*(.*)$/i)[1] || '').trim().split(/\s+/).filter(Boolean);
-            const unknownArgs = args.filter((arg) => arg.toLowerCase() !== '--dry-run');
-            const dryRun = String(process.env.MERGE_BOT_DRY_RUN || '').toLowerCase() === 'true'
-              || unknownArgs.length !== args.length;
-
-            if (unknownArgs.length) {
-              return refuse(
-                `I don't understand ${unknownArgs.map((arg) => `\`${arg}\``).join(', ')}. ` +
-                'Usage: `/bot merge` or `/bot merge --dry-run`.'
-              );
-            }
-
-            // Refuses everything while the grant list is malformed.
-            if (problems.length) {
-              return refuse(
-                'the `FOLDER_MERGERS` grant list has malformed lines, so I refuse every merge until it is fixed.'
-              );
-            }
-
-            let { data: pr } = await github.rest.pulls.get({
-              owner,
-              repo,
-              pull_number: issue.number
-            });
-
-            if (pr.merged) {
-              return refuse('it is already merged.');
-            }
-            if (pr.state !== 'open') {
-              return refuse(`its state is \`${pr.state}\`, not \`open\`.`);
-            }
-            if (pr.draft) {
-              return refuse('it is still a draft. Mark it ready for review first.');
-            }
-            if (!ALLOWED_BASE_BRANCH.test(pr.base.ref)) {
-              return refuse(`it targets \`${pr.base.ref}\`. Delegated merges are only allowed into \`main\` and \`release/*\`.`);
-            }
-
-            // ---- folder scope ----
-            const files = await github.paginate(github.rest.pulls.listFiles, {
-              owner,
-              repo,
-              pull_number: pr.number,
-              per_page: 100
-            });
-
-            if (!files.length) {
-              return refuse('it changes no files, so there is nothing to verify or merge.');
-            }
-            // Refuses when the file list is truncated or disagrees with the PR.
-            if (files.length >= LISTFILES_CAP || files.length !== pr.changed_files) {
-              return refuse(
-                `it reports ${pr.changed_files} changed files but the API listed ${files.length}, ` +
-                'so the file list is truncated and I cannot verify the folder scope. A maintainer must merge this one.'
-              );
-            }
-            if (pr.changed_files > MAX_CHANGED_FILES) {
-              return refuse(`it changes ${pr.changed_files} files; delegated merges are capped at ${MAX_CHANGED_FILES}.`);
-            }
-
-            const deniedFiles = [];
-            const outsideFiles = [];
-
-            for (const file of files) {
-              for (const path of pathsFor(file)) {
-                if (isDenied(path)) {
-                  deniedFiles.push(path);
-                } else if (!isGranted(path, grants)) {
-                  outsideFiles.push(path);
-                }
-              }
-            }
-
-            if (deniedFiles.length) {
-              core.error(`@${commenter} attempted a delegated merge touching protected paths: ${deniedFiles.join(', ')}`);
-              return refuse(
-                'it touches paths that are never delegatable, whatever the grants say ' +
-                `(CI, build, scripts or executable files):\n\n${formatList(deniedFiles)}\n\nA maintainer should look at this before it goes any further.`
-              );
-            }
-            if (outsideFiles.length) {
-              return refuse(
-                `${outsideFiles.length} changed path(s) fall outside your grants:\n\n${formatList(outsideFiles)}\n\n` +
-                'A vendor needs both grants: `resources/profiles/<Vendor>/` **and** `resources/profiles/<Vendor>.json`.'
-              );
-            }
-
-            // ---- file modes: rejects symlinks and submodules ----
-            // Fetches the delegatable subtree only; listFiles does not report modes.
-            const headSha = pr.head.sha;
-            const { data: tree } = await github.rest.git.getTree({
-              owner,
-              repo,
-              tree_sha: `${headSha}:${DELEGATABLE_ROOT.replace(/\/$/, '')}`,
-              recursive: 'true'
-            });
-
-            if (tree.truncated) {
-              return refuse('the git tree is too large to verify file modes. A maintainer must merge this one.');
-            }
-
-            // Entry paths are subtree-relative.
-            const modesByPath = new Map(tree.tree.map((entry) => [`${DELEGATABLE_ROOT}${entry.path}`, entry.mode]));
-            const irregularFiles = files
-              .filter((file) => file.status !== 'removed')
-              .map((file) => [file.filename, modesByPath.get(file.filename)])
-              .filter(([, mode]) => !REGULAR_FILE_MODES.has(mode))
-              .map(([path, mode]) => `${path} (mode ${mode || 'missing'})`);
-
-            if (irregularFiles.length) {
-              core.error(`@${commenter} attempted a delegated merge with non-regular files: ${irregularFiles.join(', ')}`);
-              return refuse(
-                `it adds symlinks, submodules or files I cannot verify:\n\n${formatList(irregularFiles)}\n\nA maintainer should look at this before it goes any further.`
-              );
-            }
-
-            // ---- mergeability: waits for GitHub to compute it ----
-            for (let attempt = 0; pr.mergeable === null && attempt < MERGEABLE_ATTEMPTS; attempt += 1) {
-              core.info(`Mergeability not computed yet; retrying in ${MERGEABLE_DELAY_MS}ms.`);
-              await sleep(MERGEABLE_DELAY_MS);
-              ({ data: pr } = await github.rest.pulls.get({
-                owner,
-                repo,
-                pull_number: pr.number
-              }));
-            }
-
-            if (pr.mergeable === null) {
-              return refuse('GitHub is still working out whether it can be merged. Try `/bot merge` again in a minute.');
-            }
-            if (!pr.mergeable) {
-              return refuse(`it is not mergeable (\`${pr.mergeable_state}\`) - most likely a conflict with \`${pr.base.ref}\`.`);
-            }
-
-            // ---- CI on the head commit ----
-            const checkRuns = await github.paginate(github.rest.checks.listForRef, {
-              owner,
-              repo,
-              ref: headSha,
-              filter: 'latest',
-              per_page: 100
-            });
-            const pendingChecks = checkRuns.filter((run) => run.status !== 'completed');
-            const failedChecks = checkRuns.filter((run) => run.status === 'completed' && !OK_CONCLUSIONS.has(run.conclusion));
-
-            if (pendingChecks.length) {
-              return refuse(
-                `${pendingChecks.length} check(s) are still running on \`${headSha.slice(0, 7)}\`:\n\n` +
-                `${formatList(pendingChecks.map((run) => run.name))}\n\nRe-run \`/bot merge\` once they finish.`
-              );
-            }
-            if (failedChecks.length) {
-              return refuse(
-                `${failedChecks.length} check(s) are not green on \`${headSha.slice(0, 7)}\`:\n\n` +
-                formatList(failedChecks.map((run) => `${run.name} (${run.conclusion})`))
-              );
-            }
-
-            const { data: combined } = await github.rest.repos.getCombinedStatusForRef({
-              owner,
-              repo,
-              ref: headSha
-            });
-            // total_count 0 only means there are no legacy statuses.
-            if (combined.total_count > 0 && combined.state !== 'success') {
-              return refuse(
-                `the combined commit status on \`${headSha.slice(0, 7)}\` is \`${combined.state}\`:\n\n` +
-                formatList(combined.statuses.filter((status) => status.state !== 'success')
-                  .map((status) => `${status.context} (${status.state})`))
-              );
-            }
-
-            // Requires the check to have actually run, not merely to have not failed.
-            const requiredCheck = checkRuns.find((run) =>
-              run.name === REQUIRED_CHECK &&
-              run.app && run.app.slug === 'github-actions' &&
-              run.status === 'completed' && OK_CONCLUSIONS.has(run.conclusion));
-
-            if (!requiredCheck) {
-              return refuse(
-                `the \`${REQUIRED_CHECK}\` check has not succeeded on \`${headSha.slice(0, 7)}\`. ` +
-                'If it never ran, a maintainer needs to approve the workflow run first.'
-              );
-            }
-
-            const scopeSummary = `${files.length} file(s), all within:\n${formatList(grants)}`;
-
-            if (dryRun) {
-              core.info('Dry run: every gate passed, not merging.');
-              await react('+1');
-              await say(
-                `@${commenter} **dry run** - this PR passes every gate and I *would* squash-merge it ` +
-                `at \`${headSha.slice(0, 7)}\`.\n\nVerified scope: ${scopeSummary}`
-              );
-              return;
-            }
-
-            // ---- re-validate, then merge ----
-            // An unchanged head SHA means the verified file list still holds.
-            const { data: fresh } = await github.rest.pulls.get({
-              owner,
-              repo,
-              pull_number: pr.number
-            });
-
-            if (fresh.head.sha !== headSha || fresh.base.ref !== pr.base.ref || fresh.state !== 'open' || fresh.merged || fresh.draft) {
-              return refuse('it changed while I was checking it. Nothing was merged - re-run `/bot merge`.');
-            }
-
-            let merged;
-            try {
-              // Pinned to the verified head: a moved head fails with 409.
-              ({ data: merged } = await github.rest.pulls.merge({
-                owner,
-                repo,
-                pull_number: pr.number,
-                sha: headSha,
-                merge_method: MERGE_METHOD,
-                commit_title: `${pr.title} (#${pr.number})`,
-                commit_message:
-                  `Merged by /bot merge on behalf of @${commenter} (id ${comment.user.id}).\n` +
-                  `Grants: ${grants.join(', ')}\nHead: ${headSha}\n`
-              }));
-            } catch (error) {
-              const hint = {
-                403: 'the workflow token cannot write to the repository.',
-                405: 'GitHub refused the merge - branch protection, a required review or check, a newly added CODEOWNERS file, or squash merging being disabled.',
-                409: `the head commit moved after I verified it (was \`${headSha.slice(0, 7)}\`).`,
-                422: 'GitHub rejected the merge as invalid.'
-              }[error.status];
-
-              if (!hint) {
-                throw error;
-              }
-
-              await refuse(`${hint}\n\n> ${error.message}\n\nNothing was merged.`);
-              core.setFailed(`Delegated merge failed: ${error.status} ${error.message}`);
-              return;
-            }
-
-            core.info(`Merged #${pr.number} as ${merged.sha}.`);
-            await react('rocket');
-            await say(
-              `@${commenter} squash-merged into \`${pr.base.ref}\` as ${merged.sha}.\n\nVerified scope: ${scopeSummary}`
-            );
-
-            // ---- re-kick the build ----
-            // A GITHUB_TOKEN merge fires no push event, so build_all.yml would
-            // otherwise never see these files.
-            try {
-              await github.rest.actions.createWorkflowDispatch({
-                owner,
-                repo,
-                workflow_id: 'build_all.yml',
-                ref: pr.base.ref
-              });
-              core.info(`Dispatched build_all.yml on ${pr.base.ref}.`);
-            } catch (error) {
-              core.warning(`Merged successfully, but dispatching build_all.yml failed: ${error.message}`);
-            }

.github/workflows/publish_release.yml

@@ -79,6 +79,7 @@ jobs:
             -p 'OrcaSlicer_Mac_universal_*' \
             -p 'OrcaSlicer_Linux_ubuntu_*' \
             -p 'OrcaSlicer-Linux-flatpak_*' \
+            -p 'OrcaSlicer-Linux-snap_*' \
             -p 'PDB'
           echo "Downloaded artifact folders:"
           ls -1 artifacts
@@ -92,30 +93,30 @@ jobs:
           # binaries are already unzipped. Copy the inner binary for each platform.
           # -type f is required (some artifact *folders* are named "*.flatpak").
 
-          # Windows installers (x64 + arm64): the .exe inside each installer
-          # artifact, NOT the orca-slicer.exe in the portable app folder. CPack
-          # now bakes the arch into the filename (…_x64.exe / …_arm64.exe), so
-          # copy them straight through.
-          find artifacts -type f -name '*.exe' -path '*OrcaSlicer_Windows_V*' ! -path '*_portable*' -exec cp -v {} upload/ \;
+          # Windows installer: the .exe inside the installer artifact, NOT the
+          # orca-slicer.exe that lives in the portable app folder.
+          find artifacts -type f -name '*.exe' -path '*OrcaSlicer_Windows_*' ! -path '*_portable*' -exec cp -v {} upload/ \;
           # macOS universal DMG (profile-validator DMG isn't downloaded).
           find artifacts -type f -name '*.dmg' -path '*OrcaSlicer_Mac_universal_*' -exec cp -v {} upload/ \;
           # Linux AppImage.
           find artifacts -type f -name '*.AppImage' -exec cp -v {} upload/ \;
           # Flatpak bundles (x86_64 + aarch64).
           find artifacts -type f -name '*.flatpak' -exec cp -v {} upload/ \;
+          # Snaps are intentionally NOT copied here: they go to the Snap Store
+          # only (see the "Publish snaps to the Snap Store" step), not to the
+          # GitHub release.
           # Windows debug symbols (PDB archive, for developers).
           find artifacts -type f -name 'Debug_PDB_*.7z' -exec cp -v {} upload/ \;
 
-          # Portable Windows builds (x64 + arm64) are unzipped folder artifacts;
-          # re-zip each to its released filename (these stay .zip on the release).
-          mapfile -t portable_dirs < <(find artifacts -maxdepth 1 -type d -name 'OrcaSlicer_Windows_*_portable')
-          if [ ${#portable_dirs[@]} -eq 0 ]; then
-            echo "::warning::Windows portable artifact not found."
-          fi
-          for portable_dir in "${portable_dirs[@]}"; do
+          # Portable Windows build is an unzipped folder artifact; re-zip it to the
+          # released filename (this one stays a .zip on the release).
+          portable_dir=$(find artifacts -maxdepth 1 -type d -name 'OrcaSlicer_Windows_*_portable' | head -n1)
+          if [ -n "${portable_dir:-}" ]; then
             ( cd "$portable_dir" && zip -qr "$GITHUB_WORKSPACE/upload/$(basename "$portable_dir").zip" . )
             echo "Zipped portable -> $(basename "$portable_dir").zip"
-          done
+          else
+            echo "::warning::Windows portable artifact not found."
+          fi
 
           echo "Assets to upload:"
           ls -lh upload
@@ -129,3 +130,30 @@ jobs:
           gh release upload "$TAG" upload/* --repo "$GITHUB_REPOSITORY" --clobber
           echo "Uploaded to draft release: $TAG"
           gh release view "$TAG" --repo "$GITHUB_REPOSITORY" --json assets --jq '.assets[].name'
+
+      - name: Publish snaps to the Snap Store
+        # Snaps ship to the Store only (not as release assets). Channel comes from
+        # the tag suffix; nightly -> edge is handled in the build workflows.
+        # NOTE: classic confinement means the Store holds uploads for manual
+        # review until classic is granted (see snap/README.md).
+        env:
+          SNAPCRAFT_STORE_CREDENTIALS: ${{ secrets.SNAPCRAFT_STORE_CREDENTIALS }}
+        run: |
+          set -euo pipefail
+          mapfile -t snaps < <(find artifacts -type f -name '*.snap')
+          if [ ${#snaps[@]} -eq 0 ]; then
+            echo "::warning::No .snap artifacts in run $RUN_ID; skipping Snap Store publish."
+            exit 0
+          fi
+          case "$TAG" in
+            *-rc*)            channel=candidate ;;
+            *-beta*|*-alpha*) channel=beta ;;
+            *)                channel=stable ;;
+          esac
+          echo "Releasing $TAG to Snap Store channel: $channel"
+          sudo snap install snapcraft --classic
+          for s in "${snaps[@]}"; do
+            echo "::group::snapcraft upload $s --release=$channel"
+            snapcraft upload "$s" --release="$channel"
+            echo "::endgroup::"
+          done

.github/workflows/shellcheck.yml

@@ -21,7 +21,7 @@ jobs:
     steps:
       - name: Cache shellcheck download
         id: cache-shellcheck-v0_11
-        uses: actions/cache@v6
+        uses: actions/cache@v5
         with:
           path: ~/shellcheck
           key: ${{ runner.os }}-shellcheck-v0_11
@@ -36,7 +36,7 @@ jobs:
           tar -xvf ~/sc.tar.xz -C ~
           mv ~/shellcheck-"${INPUT_VERSION}"/shellcheck ~/shellcheck
 
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
         with:
           fetch-depth: 1
 

.github/workflows/unit_tests.yml

@@ -1,77 +0,0 @@
-name: Unit Tests
-
-# Download a platform's test artifact, run ctest, and upload the JUnit
-# results for aggregation. Called once per arch from build_all.yml.
-on:
-  workflow_call:
-    inputs:
-      os:
-        required: true
-        type: string
-      artifact:
-        description: Test artifact uploaded by the build leg
-        required: true
-        type: string
-      test-dir:
-        description: Built tests dir; defaults to build/tests, override for arch-separated builds
-        required: false
-        type: string
-        default: build/tests
-
-jobs:
-  unit_tests:
-    # Static "Unit Tests"; the per-arch label is the caller's job name, so the
-    # graph shows e.g. "Windows x64 / Unit Tests".
-    name: Unit Tests
-    runs-on: ${{ inputs.os }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v7
-        with:
-          # Tests reach outside tests/ at runtime: tests/data (TEST_DATA_DIR) and
-          # resources/profiles (PROFILES_DIR) by baked-in absolute path, plus
-          # resources/info (nozzle data) via resources_dir() during a real slice.
-          # Check out all of resources/ so no test hits a missing-file path.
-          sparse-checkout: |
-            .github
-            scripts
-            tests
-            resources
-      - name: Apt-Install Dependencies
-        if: runner.os == 'Linux' && !vars.SELF_HOSTED
-        uses: ./.github/actions/apt-install-deps
-      - name: Restore Test Artifact
-        uses: actions/download-artifact@v8
-        with:
-          name: ${{ inputs.artifact }}
-      - uses: lukka/get-cmake@latest
-        with:
-          cmakeVersion: "~4.3.0"  # use most recent 4.3.x version
-          useLocalCache: true
-          useCloudCache: true
-      - name: Unpackage and Run Unit Tests
-        timeout-minutes: 20
-        shell: bash
-        run: |
-          tar -xvf build_tests.tar
-          # Multi-config generators (Windows/macOS) need a config; Linux is single-config.
-          scripts/run_unit_tests.sh "${{ inputs.test-dir }}" "${{ runner.os != 'Linux' && 'Release' || '' }}"
-      - name: Upload Test Logs
-        if: ${{ failure() }}
-        uses: actions/upload-artifact@v7
-        with:
-          name: unit-test-logs-${{ inputs.artifact }}
-          path: ${{ inputs.test-dir }}/**/*.log
-      - name: Upload Test Results
-        if: always()
-        uses: actions/upload-artifact@v7
-        with:
-          name: test-results-${{ inputs.artifact }}
-          path: ctest_results.xml
-          retention-days: 5
-          if-no-files-found: warn
-      - name: Delete Test Artifact
-        if: success()
-        uses: geekyeggo/delete-artifact@v6
-        with:
-          name: ${{ inputs.artifact }}

.github/workflows/update-translation.yml

@@ -10,7 +10,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:  
       - name: Checkout repository
-        uses: actions/checkout@v7
+        uses: actions/checkout@v6
 
       - name: Setup Python
         uses: actions/setup-python@v6

.gitignore

@@ -2,7 +2,6 @@ Build
 Build.bat
 /build*/
 CMakeLists.txt.user
-CMakeUserPresets.json
 **/CMakeLists.txt.autosave
 deps/build*
 MYMETA.json
@@ -46,8 +45,4 @@ test.js
 .clangd
 internal_docs/
 *.flatpak
-/flatpak-repo/
-# Python bytecode
-__pycache__/
-*.pyc
-*.opc
+/flatpak-repo/

AGENTS.md

@@ -17,7 +17,7 @@ cmake --build . --config %build_type% --target ALL_BUILD -- -m
 
 ## Testing
 
-Catch2 framework. Tests in `tests/`; see [tests/AGENTS.md](tests/AGENTS.md) for where a new test belongs and the conventions to follow.
+Catch2 framework. Tests in `tests/` directory.
 
 ```bash
 cd build && ctest --output-on-failure           # all tests
@@ -30,7 +30,6 @@ ctest --test-dir ./tests/fff_print
 - C++17, selective C++20. PascalCase classes, snake_case functions/variables
 - `#pragma once` for headers. Smart pointers and RAII preferred
 - Parallelization via TBB — be mindful of shared state
-- Always use `SetSizerAndFit(sizer)` instead of `SetSizer(sizer)` on top level window. Unless `SetSizer` must be called before the full layout is built, call `sizer->SetSizeHints(window)` afterwards in this case.
 
 ## Key Entry Points
 
@@ -56,36 +55,3 @@ ctest --test-dir ./tests/fff_print
 - Add helper functions or utilities only when existing code cannot reasonably be reused. Avoid duplication.
 - Keep code concise and clear. Manually simplify AI generated bloated codes before review.
 - Include targeted tests or documented verification for behavior changes, especially in slicing logic, profiles, formats, and GUI defaults.
-- For profile changes (`resources/profiles/<Vendor>/**`), check that `version` in the sibling `resources/profiles/<Vendor>.json` was bumped.
-- For translation changes (`localization/i18n/**/*.po`), check that recurring terms match the [Localization glossary](https://github.com/OrcaSlicer/OrcaSlicer_WIKI/blob/main/guides/localization_glossary.md) for that language.
-
-## Localization & translations
-
-Catalogs live in `localization/i18n/<lang>/OrcaSlicer_<lang>.po`; the template is `OrcaSlicer.pot`.
-See the [Localization guide](https://github.com/OrcaSlicer/OrcaSlicer_WIKI/blob/main/guides/localization_guide.md) for the human-facing version of these principles.
-
-### Terminology
-
-- Use the [Localization glossary](https://github.com/OrcaSlicer/OrcaSlicer_WIKI/blob/main/guides/localization_glossary.md) as the source of truth for recurring terms, so the same English term is always rendered the same way within a language, and terms that must stay in English (brand/product names, acronyms, materials, file formats, G-code tokens, macros/variables/identifiers) are not translated.
-- If a term's established translation changes, update both the affected `.po` files and the glossary (`localization_glossary.tsv`, then regenerate) so they stay in sync.
-- Translate the *meaning*, not the words. Check what the string actually controls before translating it — English reuses one word for different things. `Flow ratio` (multiplier), `Flow Rate` (throughput) and `Flow Dynamics` (pressure compensation) are three different terms; `extruder` may mean the toolhead, the feeder motor, or the nozzle depending on the string.
-- Reuse one template per recurring message shape (`Failed to connect to …`, `Are you sure you want to …?`), even where the English wording varies.
-
-### Editing rules
-
-- Only edit `msgstr` — **never** change `msgid`, and never "fix" wrong English in the translation alone. Report the source string instead.
-- Preserve exactly: placeholders (`%s`, `%d`, `%1%`, `%zu`, `%%`), every `\n` (count *and* position, including leading/trailing), leading/trailing spaces, HTML tags, `℃`, and the file's encoding and line endings.
-- **Never reorder positional arguments** in a `c-format` string. If the msgid is `%d` then `%s`, that order must hold — swapping them breaks at runtime.
-- `msgctxt` separates homonyms — always read it. `Back`/`Camera View` is the rear view of the 3D navigator, while `Back`/`Navigation` is the go-back button; `Top` exists in the *Alignment*, *Layers* and *Camera View* senses.
-- When a string needs disambiguating, add context in the source (`_L_CONTEXT`/`_u8L_CONTEXT`), don't work around it in the translation.
-- A literal `%` inside a string xgettext flagged `possible-c-format` will fail `msgfmt`. Fix it with a `// xgettext:no-c-format, no-boost-format` comment above the string in the source — do not mangle the translation or use `%%` in text that is never passed through printf.
-- Plural entries: read `nplurals` from the catalog's `Plural-Forms` header (it is **not** always 2 — ja/ko/zh/th/vi use 1, ru/cs/pl/lt use 3, uk uses 4). Each form must be genuinely inflected for its quantity; repeating one sentence across all forms is a bug in Slavic/Baltic languages, though it is correct for Turkish and Hungarian.
-- An entry whose `msgstr` equals its `msgid` is untranslated even though it is not empty; a plural entry with any empty form is likewise incomplete.
-- Mark machine-produced translations with an `# AI Translated` translator comment. Don't add it to a human translation you didn't actually rewrite.
-- Don't reflow or re-wrap unrelated entries — keep the diff limited to the strings you changed.
-
-### Verifying
-
-- `scripts/run_gettext.bat --full` (Windows) regenerates the template, merges every catalog and compiles the `.mo` files. It must exit 0.
-- Or check a single catalog with `msgfmt --check-format -o <out>.mo localization/i18n/<lang>/OrcaSlicer_<lang>.po`.
-- Fuzzy entries are not shown to users. If you correct one, clear its `fuzzy` flag, otherwise the fix never ships.

CMakeLists.txt

@@ -59,13 +59,6 @@ if (APPLE)
     message(STATUS "CMAKE_OSX_DEPLOYMENT_TARGET: ${CMAKE_OSX_DEPLOYMENT_TARGET}")
 endif ()
 
-# Keep MSVC's default /W3 out of CMAKE_<LANG>_FLAGS so it can be applied to our own
-# targets only. Silencing a bundled target would otherwise override a warning level,
-# which cl reports as D9025 for every file it compiles.
-if (POLICY CMP0092)
-    cmake_policy(SET CMP0092 NEW)
-endif ()
-
 project(OrcaSlicer)
 
 # Backward compatibility for old CMake versions
@@ -87,12 +80,8 @@ endif()
 
 if (DEFINED BBL_RELEASE_TO_PUBLIC)
     add_compile_definitions("BBL_RELEASE_TO_PUBLIC=${BBL_RELEASE_TO_PUBLIC}")
-    if (BBL_RELEASE_TO_PUBLIC)
-        add_compile_definitions(WXINSPECTOR_DISABLE)
-    endif ()
 else ()
     add_compile_definitions("BBL_RELEASE_TO_PUBLIC=$<CONFIG:Release>")
-    add_compile_definitions("$<$<CONFIG:Release>:WXINSPECTOR_DISABLE>")
 endif ()
 
 find_package(Git)
@@ -133,136 +122,9 @@ option(SLIC3R_GUI               "Compile OrcaSlicer with GUI components (OpenGL,
 option(SLIC3R_FHS               "Assume OrcaSlicer is to be installed in a FHS directory structure" 0)
 option(SLIC3R_PROFILE           "Compile OrcaSlicer with an invasive Shiny profiler" 0)
 option(SLIC3R_PCH               "Use precompiled headers" 1)
-option(SLIC3R_WARNINGS          "Emit compiler warnings for OrcaSlicer sources" 1)
-option(SLIC3R_BUNDLED_WARNINGS  "Emit compiler warnings for bundled third-party sources" 0)
 option(SLIC3R_MSVC_COMPILE_PARALLEL "Compile on Visual Studio in parallel" 1)
 option(SLIC3R_MSVC_PDB          "Generate PDB files on MSVC in Release mode" 1)
 option(SLIC3R_ASAN              "Enable ASan on Clang and GCC" 0)
-
-# Python stubgen module
-option(ORCA_BUILD_PYTHON_STUBGEN_MODULE "Build importable Python module for pybind11-stubgen" ON)
-set(ORCA_BUNDLED_UV_EXECUTABLE "" CACHE FILEPATH "Path to a uv executable to bundle for Python package installation. Leave empty to auto-download.")
-
-# Auto-download uv if not provided by the user.
-# uv is pinned: the executable ships inside the signed app, so the build must
-# be reproducible and the download verified. To upgrade, bump ORCA_UV_VERSION
-# and refresh every hash below from the release's .sha256 assets, e.g.:
-#   curl -sL https://github.com/astral-sh/uv/releases/download/<ver>/uv-<triple>.tar.gz.sha256
-set(ORCA_UV_VERSION "0.11.21")
-set(ORCA_UV_SHA256_aarch64-apple-darwin      "1f921d491ba5ffeea774eb04d6681ecee379101341cbb1500394993b541bf3f4")
-set(ORCA_UV_SHA256_x86_64-apple-darwin       "f3c8e5708a84b920c18b691214d54d2b0da6b984789caae95d47c95120cb7765")
-set(ORCA_UV_SHA256_aarch64-unknown-linux-gnu "88e800834007cc5efd4675f166eb2a51e7e3ad19876d85fa8805a6fb5c922397")
-set(ORCA_UV_SHA256_x86_64-unknown-linux-gnu  "8c88519b0ef0af9801fcdee419bbb12116bd9e6b18e162ae093c932d8b264050")
-set(ORCA_UV_SHA256_x86_64-pc-windows-msvc    "ace861f360c6de2babedc1607d0f454b6b09a820dbc8182dc15af927e4df9589")
-
-# Version-scoped cache dir so a version bump invalidates the cached binary.
-set(ORCA_UV_DOWNLOAD_DIR "${CMAKE_BINARY_DIR}/.uv/${ORCA_UV_VERSION}")
-set(ORCA_UV_BINARY "${ORCA_UV_DOWNLOAD_DIR}/uv")
-if(WIN32)
-    set(ORCA_UV_BINARY "${ORCA_UV_DOWNLOAD_DIR}/uv.exe")
-endif()
-
-# Older configures FORCE-cached the auto-downloaded path; any cache entry
-# under .uv/ is that legacy value -- clear it so auto-download re-resolves
-# (user-provided paths never live under .uv/).
-if(ORCA_BUNDLED_UV_EXECUTABLE MATCHES "/\\.uv/")
-    set(ORCA_BUNDLED_UV_EXECUTABLE "" CACHE FILEPATH "Path to the auto-downloaded uv executable" FORCE)
-endif()
-
-if(NOT ORCA_BUNDLED_UV_EXECUTABLE)
-    if(NOT EXISTS "${ORCA_UV_BINARY}")
-        # Select uv by TARGET arch. On macOS universal builds each leg sets a single
-        # CMAKE_OSX_ARCHITECTURES (and the x86_64 leg cross-builds on an arm64 runner),
-        # so prefer it over the host CMAKE_SYSTEM_PROCESSOR -- otherwise both legs fetch
-        # the same arch and the later universal lipo merge of tools/uv/uv fails.
-        set(_orca_uv_proc "${CMAKE_SYSTEM_PROCESSOR}")
-        if(APPLE AND CMAKE_OSX_ARCHITECTURES)
-            set(_orca_uv_proc "${CMAKE_OSX_ARCHITECTURES}")
-        endif()
-        # All release archives are tar.gz except the Windows zip.
-        set(ORCA_UV_EXT "tar.gz")
-        if(_orca_uv_proc MATCHES "x86_64|AMD64|amd64")
-            if(WIN32)
-                set(ORCA_UV_ARCH "x86_64-pc-windows-msvc")
-                set(ORCA_UV_EXT "zip")
-            elseif(APPLE)
-                set(ORCA_UV_ARCH "x86_64-apple-darwin")
-            else()
-                set(ORCA_UV_ARCH "x86_64-unknown-linux-gnu")
-            endif()
-        elseif(_orca_uv_proc MATCHES "aarch64|arm64|ARM64")
-            if(APPLE)
-                set(ORCA_UV_ARCH "aarch64-apple-darwin")
-            else()
-                set(ORCA_UV_ARCH "aarch64-unknown-linux-gnu")
-            endif()
-        else()
-            message(WARNING "Unsupported architecture for auto-downloading uv: ${_orca_uv_proc}")
-        endif()
-
-        if(ORCA_UV_ARCH)
-            set(ORCA_UV_URL "https://github.com/astral-sh/uv/releases/download/${ORCA_UV_VERSION}/uv-${ORCA_UV_ARCH}.${ORCA_UV_EXT}")
-            set(ORCA_UV_ARCHIVE "${ORCA_UV_DOWNLOAD_DIR}/uv-archive.${ORCA_UV_EXT}")
-            file(MAKE_DIRECTORY "${ORCA_UV_DOWNLOAD_DIR}")
-            message(STATUS "Downloading uv ${ORCA_UV_VERSION} from ${ORCA_UV_URL} ...")
-            file(DOWNLOAD "${ORCA_UV_URL}" "${ORCA_UV_ARCHIVE}" STATUS ORCA_UV_DL_STATUS TLS_VERIFY ON)
-            list(GET ORCA_UV_DL_STATUS 0 ORCA_UV_DL_CODE)
-            list(GET ORCA_UV_DL_STATUS 1 ORCA_UV_DL_MSG)
-            if(NOT ORCA_UV_DL_CODE EQUAL 0)
-                # Network failure keeps the historical graceful degradation (uv is
-                # optional at build time) -- but a hash mismatch below is fatal.
-                message(WARNING "Failed to download uv: ${ORCA_UV_DL_MSG}")
-                file(REMOVE "${ORCA_UV_ARCHIVE}")
-            else()
-                file(SHA256 "${ORCA_UV_ARCHIVE}" _orca_uv_actual_sha256)
-                if(NOT _orca_uv_actual_sha256 STREQUAL "${ORCA_UV_SHA256_${ORCA_UV_ARCH}}")
-                    file(REMOVE "${ORCA_UV_ARCHIVE}")
-                    message(FATAL_ERROR
-                        "uv archive checksum mismatch for ${ORCA_UV_ARCH} ${ORCA_UV_VERSION}:\n"
-                        "  expected ${ORCA_UV_SHA256_${ORCA_UV_ARCH}}\n"
-                        "  actual   ${_orca_uv_actual_sha256}\n"
-                        "Possible tampering or a stale pin; refusing to bundle.")
-                endif()
-                message(STATUS "Extracting uv ...")
-                file(ARCHIVE_EXTRACT INPUT "${ORCA_UV_ARCHIVE}" DESTINATION "${ORCA_UV_DOWNLOAD_DIR}")
-                file(REMOVE "${ORCA_UV_ARCHIVE}")
-                # Pinned archives have a fixed layout: the tarballs hold
-                # uv-<triple>/uv, the Windows zip holds uv.exe at the root
-                # (already at ORCA_UV_BINARY). A layout change implies a new
-                # archive, hence a hash bump -- and RENAME fails loudly.
-                if(NOT WIN32)
-                    file(RENAME "${ORCA_UV_DOWNLOAD_DIR}/uv-${ORCA_UV_ARCH}/uv" "${ORCA_UV_BINARY}")
-                    file(REMOVE_RECURSE "${ORCA_UV_DOWNLOAD_DIR}/uv-${ORCA_UV_ARCH}")
-                endif()
-            endif()
-        endif()
-    endif()
-
-    if(EXISTS "${ORCA_UV_BINARY}")
-        # Plain set (shadows the empty cache entry for this configure run):
-        # the version-scoped path re-derives every configure, so a version
-        # bump takes effect in warm build dirs without cache surgery.
-        set(ORCA_BUNDLED_UV_EXECUTABLE "${ORCA_UV_BINARY}")
-    endif()
-endif()
-
-# Resolve ORCA_BUNDLED_UV_EXECUTABLE -> ORCA_BUNDLED_UV_EXECUTABLE_CONFIG / ORCA_BUNDLED_UV_FILENAME
-# Must run before add_subdirectory(src) so target_compile_definitions sees it.
-if(ORCA_BUNDLED_UV_EXECUTABLE)
-    if(EXISTS "${ORCA_BUNDLED_UV_EXECUTABLE}")
-        file(TO_CMAKE_PATH "${ORCA_BUNDLED_UV_EXECUTABLE}" ORCA_BUNDLED_UV_EXECUTABLE_CONFIG)
-        get_filename_component(ORCA_BUNDLED_UV_FILENAME "${ORCA_BUNDLED_UV_EXECUTABLE}" NAME)
-    else()
-        message(WARNING "ORCA_BUNDLED_UV_EXECUTABLE does not exist: ${ORCA_BUNDLED_UV_EXECUTABLE}")
-        set(ORCA_BUNDLED_UV_EXECUTABLE "")
-        set(ORCA_BUNDLED_UV_EXECUTABLE_CONFIG "")
-        set(ORCA_BUNDLED_UV_FILENAME "")
-    endif()
-else()
-    set(ORCA_BUNDLED_UV_EXECUTABLE_CONFIG "")
-    set(ORCA_BUNDLED_UV_FILENAME "")
-endif()
-
 # If SLIC3R_FHS is 1 -> SLIC3R_DESKTOP_INTEGRATION is always 0, othrewise variable.
 CMAKE_DEPENDENT_OPTION(SLIC3R_DESKTOP_INTEGRATION "Allow performing desktop integration during runtime" 1 "NOT SLIC3R_FHS" 0)
 
@@ -298,8 +160,6 @@ if (APPLE)
     SET(CMAKE_XCODE_ATTRIBUTE_PRODUCT_BUNDLE_IDENTIFIER "com.orcaslicer.OrcaSlicer")
 
     message(STATUS "Orca: IS_CROSS_COMPILE: ${IS_CROSS_COMPILE}")
-elseif (CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    set(CMAKE_INSTALL_RPATH "$ORIGIN")
 endif ()
 
 # Proposal for C++ unit tests and sandboxes
@@ -346,20 +206,15 @@ if (MSVC AND CMAKE_CXX_COMPILER_ID STREQUAL Clang)
 
     # clang-cl can interpret SYSTEM header paths if -imsvc is used
     set(CMAKE_INCLUDE_SYSTEM_FLAG_CXX "-imsvc")
+
+    set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall \
+        -Wno-old-style-cast -Wno-reserved-id-macro -Wno-c++98-compat-pedantic")
 else ()
     set(IS_CLANG_CL FALSE)
 endif ()
 
 if (MSVC)
-    # CMP0092 only applies when the cache is created; an existing tree keeps its /W3,
-    # which a silenced bundled target would then override (D9025, once per file).
-    string(REGEX REPLACE "/W[0-4]" "" CMAKE_C_FLAGS   "${CMAKE_C_FLAGS}")
-    string(REGEX REPLACE "/W[0-4]" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-
-    # /MP only matters for the VS generators, where CMake turns it into the
-    # MultiProcessorCompilation property. Ninja parallelises on its own, and
-    # clang-cl warns "argument unused" if the flag reaches it.
-    if (SLIC3R_MSVC_COMPILE_PARALLEL AND CMAKE_GENERATOR MATCHES "Visual Studio")
+    if (SLIC3R_MSVC_COMPILE_PARALLEL AND NOT IS_CLANG_CL)
            add_compile_options(/MP)
     endif ()
     # /bigobj (Increase Number of Sections in .Obj file)
@@ -539,15 +394,8 @@ if (CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fext-numeric-literals" )
 endif()
 
-if ((NOT MSVC OR IS_CLANG_CL) AND ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang"))
-    if (IS_CLANG_CL)
-        # clang-cl reads -Wall as MSVC /Wall, which clang maps to -Weverything. /W4 is
-        # its -Wall -Wextra and, unlike /clang:-Wall, is ordered with the -Wno-* below
-        # instead of after them. The -Wextra-only warnings are dropped again so the set
-        # matches what -Wall gives the GNU/Clang builds.
-        set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /W4" )
-        add_compile_options(-Wno-unused-parameter -Wno-ignored-qualifiers -Wno-missing-field-initializers)
-    elseif (NOT MINGW)
+if (NOT MSVC AND ("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU" OR "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang"))
+    if (NOT MINGW)
         set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall" )
     endif ()
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-reorder" )
@@ -862,7 +710,7 @@ endif ()
 set(L10N_DIR "${SLIC3R_RESOURCES_DIR}/i18n")
 set(BBL_L18N_DIR "${CMAKE_CURRENT_SOURCE_DIR}/localization/i18n")
 add_custom_target(gettext_make_pot
-    COMMAND xgettext --keyword=L --keyword=_L --keyword=_u8L --keyword=L_CONTEXT:1,2c --keyword=_L_CONTEXT:1,2c --keyword=_u8L_CONTEXT:1,2c --keyword=_L_PLURAL:1,2 --add-comments=TRN --from-code=UTF-8 --no-location --debug --boost
+    COMMAND xgettext --keyword=L --keyword=_L --keyword=_u8L --keyword=L_CONTEXT:1,2c --keyword=_L_PLURAL:1,2 --add-comments=TRN --from-code=UTF-8 --no-location --debug --boost
         -f "${BBL_L18N_DIR}/list.txt"
         -o "${BBL_L18N_DIR}/OrcaSlicer.pot"
     COMMAND hintsToPot ${SLIC3R_RESOURCES_DIR} ${BBL_L18N_DIR}
@@ -880,6 +728,7 @@ foreach(po_file ${BBL_L10N_PO_FILES})
     add_custom_command(
         TARGET gettext_merge_po_with_pot PRE_BUILD
         COMMAND msgmerge -N -o ${po_file} ${po_file} "${BBL_L18N_DIR}/OrcaSlicer.pot"
+        DEPENDS ${po_file}
     )
 endforeach()
 add_custom_target(gettext_po_to_mo
@@ -895,91 +744,12 @@ foreach(po_file ${BBL_L10N_PO_FILES})
         TARGET gettext_po_to_mo PRE_BUILD
         COMMAND msgfmt ARGS --check-format -o ${mo_file} ${po_file}
         #COMMAND msgfmt ARGS --check-compatibility -o ${mo_file} ${po_file}
+        DEPENDS ${po_file}
     )
 endforeach()
 
 find_package(NLopt 1.4 REQUIRED)
 
-# Use bundled Python from deps instead of system Python
-set(_bundled_python_version "3.12.13")
-set(_bundled_python_abi "312")
-string(REGEX REPLACE "^([0-9]+\\.[0-9]+)\\..*$" "\\1" _bundled_python_version_short "${_bundled_python_version}")
-set(_bundled_python_root "${CMAKE_PREFIX_PATH}/libpython")
-set(Python3_ROOT_DIR "${_bundled_python_root}" CACHE PATH "Root directory for bundled Python" FORCE)
-set(Python3_USE_STATIC_LIBS OFF)
-set(Python3_FIND_STRATEGY LOCATION)
-set(Python3_FIND_IMPLEMENTATIONS CPython)
-
-if(WIN32)
-    set(_bundled_python_executable "${_bundled_python_root}/python.exe")
-    set(_bundled_python_library "${_bundled_python_root}/libs/python${_bundled_python_abi}.lib")
-    if(EXISTS "${_bundled_python_root}/python_d.exe")
-        set(_bundled_python_executable "${_bundled_python_root}/python_d.exe")
-    endif()
-    if(EXISTS "${_bundled_python_root}/libs/python${_bundled_python_abi}_d.lib")
-        set(_bundled_python_library "${_bundled_python_root}/libs/python${_bundled_python_abi}_d.lib")
-    endif()
-
-    set(Python3_FIND_REGISTRY NEVER)
-    set(Python3_EXECUTABLE "${_bundled_python_executable}" CACHE FILEPATH "Bundled Python executable" FORCE)
-    set(Python3_INCLUDE_DIR "${_bundled_python_root}/include" CACHE PATH "Bundled Python include directory" FORCE)
-    set(Python3_LIBRARY "${_bundled_python_library}" CACHE FILEPATH "Bundled Python embed import library" FORCE)
-elseif(APPLE)
-    set(Python3_FIND_FRAMEWORK NEVER)
-
-    find_program(_bundled_python_executable
-        NAMES python${_bundled_python_version_short} python3
-        PATHS "${_bundled_python_root}/bin"
-        NO_DEFAULT_PATH
-    )
-    find_path(_bundled_python_include_dir
-        NAMES Python.h
-        PATHS
-            "${_bundled_python_root}/include/python${_bundled_python_version_short}"
-            "${_bundled_python_root}/include"
-        NO_DEFAULT_PATH
-    )
-    find_library(_bundled_python_library
-        NAMES python${_bundled_python_version_short} libpython${_bundled_python_version_short}
-        PATHS "${_bundled_python_root}/lib"
-        NO_DEFAULT_PATH
-    )
-
-    if(NOT _bundled_python_executable)
-        message(FATAL_ERROR "Bundled Python executable not found under ${_bundled_python_root}/bin")
-    endif()
-    if(NOT _bundled_python_include_dir)
-        message(FATAL_ERROR "Bundled Python headers not found under ${_bundled_python_root}/include")
-    endif()
-    if(NOT _bundled_python_library)
-        message(FATAL_ERROR "Bundled Python library not found under ${_bundled_python_root}/lib")
-    endif()
-
-    set(Python3_EXECUTABLE "${_bundled_python_executable}" CACHE FILEPATH "Bundled Python executable" FORCE)
-    set(Python3_INCLUDE_DIR "${_bundled_python_include_dir}" CACHE PATH "Bundled Python include directory" FORCE)
-    set(Python3_LIBRARY "${_bundled_python_library}" CACHE FILEPATH "Bundled Python embed library" FORCE)
-endif()
-
-find_package(Python3 ${_bundled_python_version} EXACT REQUIRED
-    COMPONENTS Interpreter Development.Embed
-)
-
-# Provide a minimal pybind11::embed target sourced from deps_src/pybind11 headers.
-set(PYBIND11_SOURCE_DIR "${CMAKE_SOURCE_DIR}/deps_src/pybind11")
-if(NOT EXISTS "${PYBIND11_SOURCE_DIR}/include/pybind11/pybind11.h")
-    message(FATAL_ERROR "pybind11 headers not found in ${PYBIND11_SOURCE_DIR}. Did you initialize submodules?")
-endif()
-
-add_library(pybind11_headers INTERFACE)
-target_include_directories(pybind11_headers INTERFACE "${PYBIND11_SOURCE_DIR}/include")
-add_library(pybind11::headers ALIAS pybind11_headers)
-add_library(pybind11::pybind11 ALIAS pybind11_headers)
-
-add_library(pybind11_embed INTERFACE)
-target_link_libraries(pybind11_embed INTERFACE pybind11_headers Python3::Python)
-target_compile_definitions(pybind11_embed INTERFACE PYBIND11_SIMPLE_GIL_MANAGEMENT)
-add_library(pybind11::embed ALIAS pybind11_embed)
-
 
 if(SLIC3R_STATIC)
     set(OPENVDB_USE_STATIC_LIBS ON)
@@ -1067,10 +837,6 @@ function(orcaslicer_copy_dlls target config postfix output_dlls)
             ${CMAKE_PREFIX_PATH}/bin/occt/TKXDESTEP.dll
             ${CMAKE_PREFIX_PATH}/bin/occt/TKXSBase.dll
             ${CMAKE_PREFIX_PATH}/bin/freetype.dll
-            ${CMAKE_PREFIX_PATH}/bin/avcodec-61.dll
-            ${CMAKE_PREFIX_PATH}/bin/swresample-5.dll
-            ${CMAKE_PREFIX_PATH}/bin/swscale-8.dll
-            ${CMAKE_PREFIX_PATH}/bin/avutil-59.dll
          DESTINATION ${_out_dir})
 
     set(${output_dlls}
@@ -1106,110 +872,15 @@ function(orcaslicer_copy_dlls target config postfix output_dlls)
         ${_out_dir}/TKXSBase.dll
 
         ${_out_dir}/freetype.dll
-        ${_out_dir}/avcodec-61.dll
-        ${_out_dir}/swresample-5.dll
-        ${_out_dir}/swscale-8.dll
-        ${_out_dir}/avutil-59.dll
+
         PARENT_SCOPE
     )
 
 endfunction()
 
-function(orcaslicer_copy_sos target config postfix output_sos)
-
-    get_property(_is_multi GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
-    get_target_property(_alt_out_dir ${target} RUNTIME_OUTPUT_DIRECTORY)
-
-    if (_alt_out_dir)
-        set(_out_dir "${_alt_out_dir}")
-    elseif (_is_multi)
-        set(_out_dir "${CMAKE_CURRENT_BINARY_DIR}/${config}")
-    else ()
-        set(_out_dir "${CMAKE_CURRENT_BINARY_DIR}")
-    endif ()
-
-    file(COPY ${CMAKE_PREFIX_PATH}/lib/libavcodec.so
-            ${CMAKE_PREFIX_PATH}/lib/libavcodec.so.61
-            ${CMAKE_PREFIX_PATH}/lib/libavcodec.so.61.3.100
-            ${CMAKE_PREFIX_PATH}/lib/libavutil.so
-            ${CMAKE_PREFIX_PATH}/lib/libavutil.so.59
-            ${CMAKE_PREFIX_PATH}/lib/libavutil.so.59.8.100
-            ${CMAKE_PREFIX_PATH}/lib/libswscale.so
-            ${CMAKE_PREFIX_PATH}/lib/libswscale.so.8
-            ${CMAKE_PREFIX_PATH}/lib/libswscale.so.8.1.100
-            ${CMAKE_PREFIX_PATH}/lib/libswresample.so
-            ${CMAKE_PREFIX_PATH}/lib/libswresample.so.5
-            ${CMAKE_PREFIX_PATH}/lib/libswresample.so.5.1.100
-         DESTINATION ${_out_dir})
-
-    set(${output_sos}
-        ${_out_dir}/libavcodec.so
-        ${_out_dir}/libavcodec.so.61
-        ${_out_dir}/libavcodec.so.61.3.100
-        ${_out_dir}/libavutil.so
-        ${_out_dir}/libavutil.so.59
-        ${_out_dir}/libavutil.so.59.8.100
-        ${_out_dir}/libswscale.so
-        ${_out_dir}/libswscale.so.8
-        ${_out_dir}/libswscale.so.8.1.100
-        ${_out_dir}/libswresample.so
-        ${_out_dir}/libswresample.so.5
-        ${_out_dir}/libswresample.so.5.1.100
-        PARENT_SCOPE
-    )
-endfunction()
-
-# Bundled sources set their own warning flags, and a plain -Wall there means /Wall
-# (= -Weverything) under clang-cl. Target options are applied after the ones a target
-# set on itself, so these win. Targets are discovered rather than listed so a newly
-# bundled library needs no maintenance here.
-function(orcaslicer_silence_third_party_warnings _dir)
-    get_property(_subdirs DIRECTORY "${_dir}" PROPERTY SUBDIRECTORIES)
-    foreach (_subdir IN LISTS _subdirs)
-        orcaslicer_silence_third_party_warnings("${_subdir}")
-    endforeach ()
-    get_property(_targets DIRECTORY "${_dir}" PROPERTY BUILDSYSTEM_TARGETS)
-    foreach (_target IN LISTS _targets)
-        get_target_property(_type ${_target} TYPE)
-        if (NOT _type STREQUAL "INTERFACE_LIBRARY" AND NOT _type STREQUAL "UTILITY")
-            if (MSVC AND NOT IS_CLANG_CL)
-                # Drop any level the target set for itself, or -w overrides it and cl
-                # reports D9025 once per file.
-                get_target_property(_opts ${_target} COMPILE_OPTIONS)
-                if (_opts)
-                    string(REGEX REPLACE "/W[0-4]|/Wall" "" _opts "${_opts}")
-                    string(REGEX REPLACE ";;+" ";" _opts "${_opts}")
-                    set_target_properties(${_target} PROPERTIES COMPILE_OPTIONS "${_opts}")
-                endif ()
-                # CMake maps a level into the VS generator's WarningLevel element, while a
-                # bare -w stays on the command line and trips D9025 there, once per file.
-                target_compile_options(${_target} PRIVATE /W0)
-            else ()
-                target_compile_options(${_target} PRIVATE -w)
-            endif ()
-        endif ()
-    endforeach ()
-endfunction()
-
 
 # libslic3r, OrcaSlicer GUI and the OrcaSlicer executable.
 add_subdirectory(deps_src)
-
-if (NOT SLIC3R_BUNDLED_WARNINGS)
-    orcaslicer_silence_third_party_warnings("${CMAKE_CURRENT_SOURCE_DIR}/deps_src")
-endif ()
-
-# Warning level for the targets added below: our sources, plus glad and libvgcode,
-# which are vendored but live under src/. The deps_src libraries were configured just
-# above. CMP0092 left MSVC without a default level, so it is set here.
-if (NOT SLIC3R_WARNINGS)
-    add_compile_options(-w)
-elseif (MSVC AND NOT IS_CLANG_CL)
-    # /we4715 is C4715, no return from a non-void function, matching the
-    # -Werror=return-type the GNU/Clang builds apply.
-    add_compile_options(/W3 /we4715)
-endif ()
-
 add_subdirectory(src)
 set_property(DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} PROPERTY VS_STARTUP_PROJECT OrcaSlicer_app_gui)
 
@@ -1221,10 +892,6 @@ endif()
 
 if(BUILD_TESTS)
     add_subdirectory(tests)
-    if (NOT SLIC3R_BUNDLED_WARNINGS)
-        # Catch2 is vendored under tests/ and sets its own warning flags too.
-        orcaslicer_silence_third_party_warnings("${CMAKE_CURRENT_SOURCE_DIR}/tests/catch2")
-    endif ()
 endif()
 
 if (NOT WIN32 AND NOT APPLE)
@@ -1232,12 +899,10 @@ if (NOT WIN32 AND NOT APPLE)
     configure_file(${LIBDIR}/dev-utils/platform/unix/build_appimage.sh.in ${CMAKE_CURRENT_BINARY_DIR}/build_appimage.sh USE_SOURCE_PERMISSIONS @ONLY)
 endif()
 
+
 # Resources install target, configure fhs.hpp on UNIX
 if (WIN32)
     install(DIRECTORY "${SLIC3R_RESOURCES_DIR}/" DESTINATION "./resources")
-    if(ORCA_BUNDLED_UV_EXECUTABLE)
-        install(PROGRAMS "${ORCA_BUNDLED_UV_EXECUTABLE}" DESTINATION "./resources/tools/uv" RENAME "${ORCA_BUNDLED_UV_FILENAME}")
-    endif()
     set(CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS_SKIP TRUE)
     include(InstallRequiredSystemLibraries)
     install (PROGRAMS ${CMAKE_INSTALL_SYSTEM_RUNTIME_LIBS} DESTINATION ".")
@@ -1247,9 +912,6 @@ elseif (SLIC3R_FHS)
     install(DIRECTORY ${SLIC3R_RESOURCES_DIR}/ DESTINATION ${SLIC3R_FHS_RESOURCES}
         PATTERN "*/udev" EXCLUDE
     )
-    if(ORCA_BUNDLED_UV_EXECUTABLE)
-        install(PROGRAMS "${ORCA_BUNDLED_UV_EXECUTABLE}" DESTINATION "${SLIC3R_FHS_RESOURCES}/tools/uv" RENAME "${ORCA_BUNDLED_UV_FILENAME}")
-    endif()
     install(FILES src/dev-utils/platform/unix/com.orcaslicer.OrcaSlicer.desktop DESTINATION ${CMAKE_INSTALL_DATAROOTDIR}/applications)
     foreach(SIZE 32 128 192)
         install(FILES ${SLIC3R_RESOURCES_DIR}/images/OrcaSlicer_${SIZE}px.png
@@ -1258,29 +920,9 @@ elseif (SLIC3R_FHS)
     endforeach()
 elseif (CMAKE_MACOSX_BUNDLE)
     # install(DIRECTORY "${SLIC3R_RESOURCES_DIR}/" DESTINATION "${CMAKE_INSTALL_PREFIX}/OrcaSlicer.app/Contents/resources")
-    if(ORCA_BUNDLED_UV_EXECUTABLE)
-        install(PROGRAMS "${ORCA_BUNDLED_UV_EXECUTABLE}" DESTINATION "${CMAKE_INSTALL_PREFIX}/OrcaSlicer.app/Contents/Resources/tools/uv" RENAME "${ORCA_BUNDLED_UV_FILENAME}")
-    endif()
 else ()
     install(FILES src/dev-utils/platform/unix/com.orcaslicer.OrcaSlicer.desktop DESTINATION ${CMAKE_INSTALL_PREFIX}/resources/applications)
     install(DIRECTORY "${SLIC3R_RESOURCES_DIR}/" DESTINATION "${CMAKE_INSTALL_PREFIX}/resources")
-    if(ORCA_BUNDLED_UV_EXECUTABLE)
-        install(PROGRAMS "${ORCA_BUNDLED_UV_EXECUTABLE}" DESTINATION "${CMAKE_INSTALL_PREFIX}/resources/tools/uv" RENAME "${ORCA_BUNDLED_UV_FILENAME}")
-    endif()
-endif ()
-
-if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    set(LIBRARY_FILES
-    ${LIBDIR_BIN}/libavcodec.so.61
-    ${LIBDIR_BIN}/libavcodec.so.61.3.100
-    ${LIBDIR_BIN}/libavutil.so.59
-    ${LIBDIR_BIN}/libavutil.so.59.8.100
-    ${LIBDIR_BIN}/libswresample.so.5
-    ${LIBDIR_BIN}/libswresample.so.5.1.100
-    ${LIBDIR_BIN}/libswscale.so.8
-    ${LIBDIR_BIN}/libswscale.so.8.1.100
-    )
-    install(FILES ${LIBRARY_FILES} DESTINATION "${CMAKE_INSTALL_PREFIX}/bin")
 endif ()
 
 install(FILES ${CMAKE_SOURCE_DIR}/LICENSE.txt DESTINATION ".")
@@ -1292,16 +934,6 @@ set (CPACK_PACKAGE_VERSION_MAJOR "${ORCA_VERSION_MAJOR}")
 set (CPACK_PACKAGE_VERSION_MINOR "${ORCA_VERSION_MINOR}")
 set (CPACK_PACKAGE_VERSION_PATCH "${ORCA_VERSION_PATCH}")
 set (CPACK_PACKAGE_FILE_NAME "OrcaSlicer_Windows_Installer_V${SoftFever_VERSION}")
-# Suffix the Windows installer with its target arch so the x64 and arm64 builds
-# produce distinct filenames (matches ARCH_SUFFIX in build_orca.yml). Same
-# CMAKE_SYSTEM_PROCESSOR mapping used by orcaslicer_copy_dlls() above.
-if (WIN32)
-    if (CMAKE_SYSTEM_PROCESSOR STREQUAL "ARM64")
-        string (APPEND CPACK_PACKAGE_FILE_NAME "_arm64")
-    else ()
-        string (APPEND CPACK_PACKAGE_FILE_NAME "_x64")
-    endif ()
-endif ()
 set (CPACK_PACKAGE_DESCRIPTION_SUMMARY "Orca Slicer is an open source slicer for FDM printers")
 set (CPACK_PACKAGE_HOMEPAGE_URL "https://github.com/OrcaSlicer/OrcaSlicer")
 set (CPACK_PACKAGE_INSTALL_DIRECTORY ${CPACK_PACKAGE_NAME})

README.md

@@ -10,6 +10,7 @@
 
 OrcaSlicer: an open source Next-Gen Slicing Software for Precision 3D Prints.  
 Optimize your prints with ultra-fast slicing, intelligent support generation, and seamless printer compatibility—engineered for perfection.
+<h3>
 
 # Official links and community
 
@@ -89,22 +90,11 @@ Visit our GitHub Releases page for the latest stable version of OrcaSlicer, reco
 🌙 **[Download the Latest Nightly Build](https://github.com/OrcaSlicer/OrcaSlicer/releases/tag/nightly-builds)**  
 Explore the latest developments in OrcaSlicer with our nightly builds. Feedback on these versions is highly appreciated.
 
-### Belt Printer Builds
-
-The [nightly release](https://github.com/OrcaSlicer/OrcaSlicer/releases/tag/nightly-builds) ships **two parallel builds**: the standard build and a belt-printer build. Both are attached to the same release — tell them apart by the filename suffix:
-
-- **Standard** — no suffix (e.g. `OrcaSlicer_Windows_Installer_x64_nightly.exe`)
-- **Belt** — `_belt` suffix (e.g. `OrcaSlicer_Windows_Installer_x64_nightly_belt.exe`)
-
-The `_belt` builds add **experimental support for belt / conveyor (infinite-Z) printers**, where the model is sliced against a tilted belt surface instead of a flat horizontal bed. They include ready-to-use belt printer profiles, the full belt slicing pipeline (mesh rotation and G-code transforms), belt-aware support generation, and a tilted-bed preview.
-
-> ⚠️ Belt printer support is under active development and is **not yet merged into `main`** — it currently ships only in these parallel `_belt` builds, produced from the [`belt-printer`](https://github.com/OrcaSlicer/OrcaSlicer/tree/belt-printer) branch. See tracking PR [#14394](https://github.com/OrcaSlicer/OrcaSlicer/pull/14394) and the original documentation in [#12998](https://github.com/OrcaSlicer/OrcaSlicer/pull/12998).
-
 # How to install
 
 ## Windows
 
-Download the **Windows Installer exe** for your preferred version from the [releases page](https://github.com/OrcaSlicer/OrcaSlicer/releases). Both `x64` and `arm64` installers are published — pick the one matching your CPU.
+Download the **Windows Installer exe**  for your preferred version from the [releases page](https://github.com/OrcaSlicer/OrcaSlicer/releases).
 
 - *For convenience there is also a portable build available.*
     <details>
@@ -119,11 +109,7 @@ Download the **Windows Installer exe** for your preferred version from the [rele
     - This file may already be available on your computer if you've installed visual studio.  Check the following location: `%VCINSTALLDIR%Redist\MSVC\v142`
     </details>
 
-### Microsoft Store
-
-Install from the [Microsoft Store](https://apps.microsoft.com/detail/9mv6gl23xm59) when you prefer a Store-signed package (helps on Windows 11 Smart App Control).
-
-### Windows Package Manager
+Windows Package Manager
 
 ```shell
 winget install --id=SoftFever.OrcaSlicer -e
@@ -131,7 +117,7 @@ winget install --id=SoftFever.OrcaSlicer -e
 
 ## Mac
 
-1. Download the universal DMG, which runs on both Apple Silicon and Intel Macs.
+1. Download the DMG for your computer: `arm64` version for Apple Silicon and `x86_64` for Intel CPU.
 2. Drag OrcaSlicer.app to Application folder.
 3. *If you want to run a build from a PR, you also need to follow the instructions below:*
 
@@ -156,14 +142,6 @@ winget install --id=SoftFever.OrcaSlicer -e
             ![mac_security_setting](./SoftFever_doc/mac_security_setting.png)
     </details>
 
-### Homebrew Cask
-
-```shell
-brew install --cask orcaslicer
-```
-
-The [Homebrew cask](https://formulae.brew.sh/cask/orcaslicer) installs the official macOS DMG from [GitHub Releases](https://github.com/OrcaSlicer/OrcaSlicer/releases).
-
 ## Linux
 
 ### Flathub (Recommended)
@@ -181,6 +159,28 @@ flatpak run com.orcaslicer.OrcaSlicer
 
 It can also be installed through graphical software managers (KDE Discover, GNOME Software, etc.) when Flathub is enabled. Search for **OrcaSlicer** in your software center.
 
+### Snap Store
+
+OrcaSlicer is available from the Snap Store:
+
+[![Get it from the Snap Store](https://snapcraft.io/static/images/badges/en/snap-store-black.svg)](https://snapcraft.io/orcaslicer)
+
+```shell
+sudo snap install orcaslicer --classic
+```
+
+Use a different channel for pre-releases or bleeding-edge builds:
+
+```shell
+sudo snap install orcaslicer --classic --candidate # release candidates (vX.Y.Z-rc)
+sudo snap install orcaslicer --classic --beta      # alpha / beta pre-releases
+sudo snap install orcaslicer --classic --edge      # nightly builds
+```
+
+The snap uses classic confinement, so it has full hardware and filesystem access just like the
+AppImage — including USB/serial printers, removable media, network shares, and 3D mice
+(3Dconnexion SpaceMouse via `spacenavd`). No extra setup is required after install.
+
 ### AppImage
 
 AppImages are published for both **x86_64** and **aarch64** (ARM64). Pick the file matching your CPU — the ARM64 build has `aarch64` in its name (e.g. `OrcaSlicer_Linux_AppImage_Ubuntu2404_aarch64_*.AppImage`).
@@ -212,8 +212,8 @@ resolution: 0.1
 
 # Supports
 
-**OrcaSlicer** is an open-source project, and we're deeply grateful to all our sponsors and backers.  
-Their generous support helps fund filaments and other essential 3D printing materials for the project.  
+**OrcaSlicer** is an open-source project and I'm deeply grateful to all my sponsors and backers.  
+Their generous support enables me to purchase filaments and other essential 3D printing materials for the project.  
 Thank you! :)
 
 ## Sponsors
@@ -237,7 +237,7 @@ Thank you! :)
 
 **Ko-fi supporters** ☕: [Backers list](https://github.com/user-attachments/files/16147016/Supporters_638561417699952499.csv)
 
-## Support the project
+## Support me
 
 <a href="https://github.com/sponsors/SoftFever"><img src="https://img.shields.io/badge/GitHub%20Sponsors-30363D?style=flat&logo=GitHub-Sponsors&logoColor=EA4AAA" height="50"></a>  
 <a href="https://ko-fi.com/G2G5IP3CP"><img src="https://img.shields.io/badge/Support_me_on_Ko--fi-FF5E5B?style=flat&logo=ko-fi&logoColor=white" height="50"></a>  

build_linux.sh

@@ -567,8 +567,6 @@ if [[ -n "${BUILD_ORCA}" ]] || [[ -n "${BUILD_TESTS}" ]] ; then
 	print_and_run cmake --build $BUILD_DIR --config "${BUILD_CONFIG}" --target OrcaSlicer
 	echo "Building OrcaSlicer_profile_validator .."
 	print_and_run cmake --build $BUILD_DIR --config "${BUILD_CONFIG}" --target OrcaSlicer_profile_validator
-	echo "Building generate_system_cache ..."
-	print_and_run cmake --build $BUILD_DIR --config "${BUILD_CONFIG}" --target generate_system_cache
 	./scripts/run_gettext.sh
     fi
     if [[ -n "${BUILD_TESTS}" ]] ; then

build_release_macos.sh

@@ -4,7 +4,7 @@ set -e
 set -o pipefail
 SECONDS=0
 
-while getopts ":dpa:snt:xbc:i:j:Tuh" opt; do
+while getopts ":dpa:snt:xbc:i:1Tuh" opt; do
   case "${opt}" in
     d )
         export BUILD_TARGET="deps"
@@ -38,8 +38,8 @@ while getopts ":dpa:snt:xbc:i:j:Tuh" opt; do
     i )
         export CMAKE_IGNORE_PREFIX_PATH="${CMAKE_IGNORE_PREFIX_PATH:+$CMAKE_IGNORE_PREFIX_PATH;}$OPTARG"
         ;;
-    j )
-        export CMAKE_BUILD_PARALLEL_LEVEL="$OPTARG"
+    1 )
+        export CMAKE_BUILD_PARALLEL_LEVEL=1
         ;;
     T )
         export BUILD_TESTS="1"
@@ -58,8 +58,8 @@ while getopts ":dpa:snt:xbc:i:j:Tuh" opt; do
         echo "   -b: Build without reconfiguring CMake"
         echo "   -c: Set CMake build configuration, default is Release"
         echo "   -i: Add a prefix to ignore during CMake dependency discovery (repeatable), defaults to /opt/local:/usr/local:/opt/homebrew"
-        echo "   -j: Set the number of parallel build jobs (CMAKE_BUILD_PARALLEL_LEVEL)"
-        echo "   -T: Build and run tests (set ORCA_TESTS_BUILD_ONLY=1 to build without running)"
+        echo "   -1: Use single job for building"
+        echo "   -T: Build and run tests"
         exit 0
         ;;
     * )
@@ -179,66 +179,6 @@ function pack_deps() {
     )
 }
 
-# codesign cannot seal the runtime's dotted directories (include/python3.12,
-# lib/python3.12) anywhere under Contents/MacOS -- it mistakes any dotted
-# directory there for a nested bundle and fails with "bundle format
-# unrecognized" -- so packaged apps ship the runtime under Contents/Resources
-# with a compatibility symlink that keeps every Contents/MacOS/python path and
-# the @executable_path/python/lib rpath resolving unchanged.
-function relocate_python_runtime() {
-    local app="$1"
-    local pydir="$app/Contents/MacOS/python"
-    if [ -d "$pydir" ] && [ ! -L "$pydir" ]; then
-        rm -rf "$app/Contents/Resources/python"
-        mv "$pydir" "$app/Contents/Resources/python"
-        ln -s ../Resources/python "$pydir"
-    fi
-}
-
-# --- Bundled Python runtime verification --------------------------------------
-# Relocation is handled at the source: deps/python3/python3.cmake stamps
-# libpython with an @rpath id and src/CMakeLists.txt gives the app a matching
-# rpath. This gate catches regressions that would otherwise only surface as
-# launch failures on end users' machines (the absolute deps path still exists
-# on the build host, so a plain run can pass while relocation is broken --
-# hence the otool checks). The x86_64 leg runs under Rosetta on arm64 hosts.
-function verify_python_runtime() {
-    local app="$1"
-    local pydir="$app/Contents/MacOS/python"
-    [ -d "$pydir" ] || return 0  # app doesn't bundle Python (e.g. profile validator)
-    if [ ! -L "$pydir" ]; then
-        echo "ERROR: Contents/MacOS/python must be a symlink into Contents/Resources" >&2
-        echo "       (see relocate_python_runtime in this script)" >&2
-        exit 1
-    fi
-    # Version-agnostic interpreter name so a CPython version bump cannot
-    # silently skip the gate; if the dir exists the interpreter must too.
-    local pybin="$pydir/bin/python3"
-    if [ ! -x "$pybin" ]; then
-        echo "ERROR: bundled python/ present but no interpreter at $pybin" >&2
-        exit 1
-    fi
-    echo "  Verifying bundled Python runtime in $(basename "$app")..."
-    local bad
-    bad=$(otool -arch all -L "$pybin" "$app/Contents/MacOS/OrcaSlicer" | grep "libpython" | grep -v "@rpath/" || true)
-    if [ -n "$bad" ]; then
-        echo "ERROR: a bundled binary references libpython by absolute path (relocation regression):" >&2
-        echo "$bad" >&2
-        exit 1
-    fi
-    # otool -L shows load commands only; assert the consumer rpath separately.
-    # Its loss is masked on the build host by CMake's absolute build-tree rpath.
-    if ! otool -arch all -l "$app/Contents/MacOS/OrcaSlicer" | grep -q "path @executable_path/python/lib "; then
-        echo "ERROR: OrcaSlicer lacks the @executable_path/python/lib rpath (relocation regression)" >&2
-        exit 1
-    fi
-    if ! "$pybin" -c "import ssl"; then
-        echo "ERROR: bundled Python failed to start (libpython relocation broken," >&2
-        echo "       or missing Rosetta 2 for the x86_64 leg?)" >&2
-        exit 1
-    fi
-}
-
 function build_slicer() {
     # iterate over two architectures: x86_64 and arm64
     for _ARCH in x86_64 arm64; do
@@ -269,10 +209,13 @@ function build_slicer() {
             cmake --build . --config "$BUILD_CONFIG" --target "$SLICER_BUILD_TARGET"
         )
 
-        # -T also runs the tests; ORCA_TESTS_BUILD_ONLY=1 builds them without
-        # running, so CI can build here and run them in a dedicated job.
-        if [ "1." == "$BUILD_TESTS". ] && [ "1." != "$ORCA_TESTS_BUILD_ONLY". ]; then
-            "$PROJECT_DIR/scripts/run_unit_tests.sh" "build/$_ARCH/tests" "$BUILD_CONFIG"
+        if [ "1." == "$BUILD_TESTS". ]; then
+            echo "Running tests for $_ARCH..."
+            (
+                set -x
+                cd "$PROJECT_BUILD_DIR"
+                ctest --build-config "$BUILD_CONFIG" --output-on-failure
+            )
         fi
 
         echo "Verify localization with gettext..."
@@ -294,11 +237,8 @@ function build_slicer() {
             resources_path=$(readlink ./OrcaSlicer.app/Contents/Resources)
             rm ./OrcaSlicer.app/Contents/Resources
             cp -R "$resources_path" ./OrcaSlicer.app/Contents/Resources
-            relocate_python_runtime ./OrcaSlicer.app
             # delete .DS_Store file
             find ./OrcaSlicer.app/ -name '.DS_Store' -delete
-
-            verify_python_runtime ./OrcaSlicer.app
             
             # Copy OrcaSlicer_profile_validator.app if it exists
             if [ -f "../src$BUILD_DIR_CONFIG_SUBDIR/OrcaSlicer_profile_validator.app/Contents/MacOS/OrcaSlicer_profile_validator" ]; then
@@ -307,7 +247,6 @@ function build_slicer() {
                 cp -pR "../src$BUILD_DIR_CONFIG_SUBDIR/OrcaSlicer_profile_validator.app" ./OrcaSlicer_profile_validator.app
                 # delete .DS_Store file
                 find ./OrcaSlicer_profile_validator.app/ -name '.DS_Store' -delete
-                verify_python_runtime ./OrcaSlicer_profile_validator.app
             fi
         )
 
@@ -363,7 +302,6 @@ function build_universal() {
     echo "Creating universal binaries for OrcaSlicer.app..."
     lipo_dir "$UNIVERSAL_APP" "$X86_64_APP"
     echo "Universal OrcaSlicer.app created at $UNIVERSAL_APP"
-    verify_python_runtime "$UNIVERSAL_APP"
 
     # Create universal binary for profile validator if it exists
     ARM64_VALIDATOR="$PROJECT_DIR/build/arm64/OrcaSlicer/OrcaSlicer_profile_validator.app"

build_release_vs.bat

@@ -3,41 +3,12 @@
 set WP=%CD%
 set _START_TIME=%TIME%
 
-@REM Default target architecture to the host CPU arch; override by passing
-@REM "x64" or "arm64" as an argument. PROCESSOR_ARCHITEW6432 covers a 32-bit
-@REM shell running on a 64-bit OS, where PROCESSOR_ARCHITECTURE reads "x86".
-set arch=x64
-if /I "%PROCESSOR_ARCHITECTURE%"=="ARM64" set arch=ARM64
-if /I "%PROCESSOR_ARCHITEW6432%"=="ARM64" set arch=ARM64
-if /I "%1"=="arm64" set arch=ARM64
-if /I "%2"=="arm64" set arch=ARM64
-if /I "%1"=="x64" set arch=x64
-if /I "%2"=="x64" set arch=x64
-
 @REM Check for Ninja Multi-Config option (-x)
 set USE_NINJA=0
 for %%a in (%*) do (
     if "%%a"=="-x" set USE_NINJA=1
 )
 
-@REM Check for clang-cl option (-l). Combined with -x it also builds the deps with
-@REM clang-cl; on the Visual Studio generator it applies to the slicer only, because
-@REM the dependency sub-builds have no toolset to inherit and stay on MSVC.
-set CLANG_ARG=
-set TOOLSET_ARG=
-for %%a in (%*) do (
-    if "%%a"=="-l" (
-        set CLANG_ARG=-DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl
-        set TOOLSET_ARG=-T ClangCL
-    )
-)
-
-@REM Check for unit-tests option ("tests")
-set BUILD_TESTS=OFF
-for %%a in (%*) do (
-    if /I "%%a"=="tests" set BUILD_TESTS=ON
-)
-
 if "%USE_NINJA%"=="1" (
     echo Using Ninja Multi-Config generator
     set CMAKE_GENERATOR="Ninja Multi-Config"
@@ -97,13 +68,12 @@ echo Using CMake generator: %CMAKE_GENERATOR%
 
 @REM Pack deps
 if "%1"=="pack" (
-    setlocal ENABLEDELAYEDEXPANSION
+    setlocal ENABLEDELAYEDEXPANSION 
     cd %WP%/deps/build
-    if "%arch%"=="ARM64" cd %WP%/deps/build-arm64
     for /f "tokens=2-4 delims=/ " %%a in ('date /t') do set build_date=%%c%%b%%a
-    echo packing deps: OrcaSlicer_dep_win-!arch!_!build_date!_vs!VS_VERSION!.zip
+    echo packing deps: OrcaSlicer_dep_win64_!build_date!_vs!VS_VERSION!.zip
 
-    %WP%/tools/7z.exe a OrcaSlicer_dep_win-!arch!_!build_date!_vs!VS_VERSION!.zip OrcaSlicer_dep
+    %WP%/tools/7z.exe a OrcaSlicer_dep_win64_!build_date!_vs!VS_VERSION!.zip OrcaSlicer_dep
     goto :done
 )
 
@@ -125,10 +95,9 @@ if "%debug%"=="ON" (
         set build_dir=build
     )
 )
-if "%arch%"=="ARM64" set build_dir=%build_dir%-arm64
-echo build type set to %build_type%, arch=%arch%
+echo build type set to %build_type%
 
-setlocal DISABLEDELAYEDEXPANSION
+setlocal DISABLEDELAYEDEXPANSION 
 cd deps
 mkdir %build_dir%
 cd %build_dir%
@@ -139,16 +108,15 @@ if "%1"=="slicer" (
     GOTO :slicer
 )
 echo "building deps.."
-if defined CLANG_ARG if "%USE_NINJA%"=="0" echo Note: -l needs -x for the dependencies; building them with MSVC.
 
 echo on
 REM Set minimum CMake policy to avoid <3.5 errors
 set CMAKE_POLICY_VERSION_MINIMUM=3.5
 if "%USE_NINJA%"=="1" (
-    cmake ../ -G %CMAKE_GENERATOR% %CLANG_ARG% -DCMAKE_BUILD_TYPE=%build_type%
+    cmake ../ -G %CMAKE_GENERATOR% -DCMAKE_BUILD_TYPE=%build_type%
     cmake --build . --config %build_type% --target deps
 ) else (
-    cmake ../ -G %CMAKE_GENERATOR% -A %arch% -DCMAKE_BUILD_TYPE=%build_type%
+    cmake ../ -G %CMAKE_GENERATOR% -A x64 -DCMAKE_BUILD_TYPE=%build_type%
     cmake --build . --config %build_type% --target deps -- -m
 )
 @echo off
@@ -164,10 +132,10 @@ cd %build_dir%
 echo on
 set CMAKE_POLICY_VERSION_MINIMUM=3.5
 if "%USE_NINJA%"=="1" (
-    cmake .. -G %CMAKE_GENERATOR% %CLANG_ARG% -DORCA_TOOLS=ON %SIG_FLAG% -DBUILD_TESTS=%BUILD_TESTS% -DCMAKE_BUILD_TYPE=%build_type%
-    cmake --build . --config %build_type% --target all
+    cmake .. -G %CMAKE_GENERATOR% -DORCA_TOOLS=ON %SIG_FLAG% -DCMAKE_BUILD_TYPE=%build_type%
+    cmake --build . --config %build_type% --target ALL_BUILD
 ) else (
-    cmake .. -G %CMAKE_GENERATOR% -A %arch% %TOOLSET_ARG% -DORCA_TOOLS=ON %SIG_FLAG% -DBUILD_TESTS=%BUILD_TESTS% -DCMAKE_BUILD_TYPE=%build_type%
+    cmake .. -G %CMAKE_GENERATOR% -A x64 -DORCA_TOOLS=ON %SIG_FLAG% -DCMAKE_BUILD_TYPE=%build_type%
     cmake --build . --config %build_type% --target ALL_BUILD -- -m
 )
 @echo off

build_release_vs2022.bat

@@ -15,18 +15,10 @@ if "%1"=="pack" (
 
 set debug=OFF
 set debuginfo=OFF
-@REM Default target architecture to the host CPU arch; override with x64/arm64 arg.
-set arch=x64
-if /I "%PROCESSOR_ARCHITECTURE%"=="ARM64" set arch=ARM64
-if /I "%PROCESSOR_ARCHITEW6432%"=="ARM64" set arch=ARM64
 if "%1"=="debug" set debug=ON
 if "%2"=="debug" set debug=ON
 if "%1"=="debuginfo" set debuginfo=ON
 if "%2"=="debuginfo" set debuginfo=ON
-if /I "%1"=="arm64" set arch=ARM64
-if /I "%2"=="arm64" set arch=ARM64
-if /I "%1"=="x64" set arch=x64
-if /I "%2"=="x64" set arch=x64
 if "%debug%"=="ON" (
     set build_type=Debug
     set build_dir=build-dbg
@@ -39,8 +31,7 @@ if "%debug%"=="ON" (
         set build_dir=build
     )
 )
-if "%arch%"=="ARM64" set build_dir=%build_dir%-arm64
-echo build type set to %build_type%, arch=%arch%
+echo build type set to %build_type%
 
 setlocal DISABLEDELAYEDEXPANSION 
 cd deps
@@ -57,7 +48,7 @@ echo "building deps.."
 echo on
 REM Set minimum CMake policy to avoid <3.5 errors
 set CMAKE_POLICY_VERSION_MINIMUM=3.5
-cmake ../ -G "Visual Studio 17 2022" -A %arch% -DCMAKE_BUILD_TYPE=%build_type%
+cmake ../ -G "Visual Studio 17 2022" -A x64 -DCMAKE_BUILD_TYPE=%build_type%
 cmake --build . --config %build_type% --target deps -- -m
 @echo off
 
@@ -71,7 +62,7 @@ cd %build_dir%
 
 echo on
 set CMAKE_POLICY_VERSION_MINIMUM=3.5
-cmake .. -G "Visual Studio 17 2022" -A %arch% -DORCA_TOOLS=ON %SIG_FLAG% -DCMAKE_BUILD_TYPE=%build_type%
+cmake .. -G "Visual Studio 17 2022" -A x64 -DORCA_TOOLS=ON %SIG_FLAG% -DCMAKE_BUILD_TYPE=%build_type%
 cmake --build . --config %build_type% --target ALL_BUILD -- -m
 @echo off
 cd ..

cmake/modules/FindGLEW.cmake

@@ -124,8 +124,6 @@ endif()
 
 if("${CMAKE_GENERATOR_PLATFORM}" MATCHES "x64" OR "${CMAKE_GENERATOR}" MATCHES "Win64")
   set(_arch "x64")
-elseif("${CMAKE_GENERATOR_PLATFORM}" MATCHES "ARM64")
-  set(_arch "x64")  # GLEW ships one header set; ARM64 uses the x64 import path
 else()
   set(_arch "Win32")
 endif()

cmake/modules/FindOpenVDB.cmake

@@ -128,10 +128,6 @@ cmake_minimum_required(VERSION 3.13)
 if(POLICY CMP0074)
   cmake_policy(SET CMP0074 NEW)
 endif()
-# Re-set after cmake_minimum_required above cleared it; use BoostConfig, not the removed FindBoost.
-if(POLICY CMP0167)
-  cmake_policy(SET CMP0167 NEW)
-endif()
 
 if(OpenVDB_FIND_QUIETLY)
   set (_quiet "QUIET")

deps/Assimp/Assimp.cmake

@@ -1,43 +0,0 @@
-if(CMAKE_VERSION VERSION_LESS 3.22)
-    set(_assimp_url "https://github.com/assimp/assimp/archive/refs/tags/v5.3.1.tar.gz")
-    set(_assimp_hash "SHA256=a07666be71afe1ad4bc008c2336b7c688aca391271188eb9108d0c6db1be53f1")
-else()
-    set(_assimp_url "https://github.com/assimp/assimp/archive/refs/tags/v5.4.3.tar.gz")
-    set(_assimp_hash "SHA256=66dfbaee288f2bc43172440a55d0235dfc7bf885dda6435c038e8000e79582cb")
-endif()
-
-# Assimp's bundled zlib (contrib/zlib) is too old to compile against the modern
-# macOS SDK: its zutil.h takes the classic-Mac branch under TARGET_OS_MAC and
-# does `#define fdopen(fd,mode) NULL`, which then clobbers the SDK's real
-# `fdopen` prototype in <stdio.h> and breaks the build. On macOS use the system
-# zlib (already found by find_package(ZLIB) in deps-unix-common) instead.
-if(APPLE)
-    set(_assimp_build_zlib "-DASSIMP_BUILD_ZLIB=OFF")
-else()
-    set(_assimp_build_zlib "-DASSIMP_BUILD_ZLIB=ON")
-endif()
-
-orcaslicer_add_cmake_project(Assimp
-    URL ${_assimp_url}
-    URL_HASH ${_assimp_hash}
-    CMAKE_ARGS
-        # Assimp's ccache support sets the global RULE_LAUNCH_COMPILE, which breaks
-        # the Ninja RC rule. The superbuild forwards CMAKE_<LANG>_COMPILER_LAUNCHER.
-        -DASSIMP_BUILD_USE_CCACHE=OFF
-        -DASSIMP_BUILD_TESTS=OFF
-        -DASSIMP_BUILD_SAMPLES=OFF
-        -DASSIMP_BUILD_ASSIMP_TOOLS=OFF
-        -DASSIMP_INSTALL_PDB=OFF
-        -DASSIMP_NO_EXPORT=ON
-        -DASSIMP_BUILD_ALL_IMPORTERS_BY_DEFAULT=OFF
-        -DASSIMP_BUILD_GLTF_IMPORTER=ON
-        -DASSIMP_BUILD_OBJ_IMPORTER=ON
-        -DASSIMP_BUILD_FBX_IMPORTER=ON
-        ${_assimp_build_zlib}
-        -DASSIMP_WARNINGS_AS_ERRORS=OFF
-        -DBUILD_WITH_STATIC_CRT=OFF
-)
-
-if (MSVC)
-    add_debug_dep(dep_Assimp)
-endif ()

deps/Boost/Boost.cmake

@@ -10,27 +10,11 @@ if (APPLE AND CMAKE_OSX_ARCHITECTURES)
     set(_context_arch_line "-DBOOST_CONTEXT_ARCHITECTURE:STRING=${CMAKE_OSX_ARCHITECTURES}")
 endif ()
 
-# Windows ARM64: Boost.Context's default fcontext implementation assembles .asm
-# via armasm64, which trips a CMake ASM_ARMASM linker-module bug under the VS
-# generator. The winfib implementation (Windows Fiber API) avoids assembly while
-# keeping the Boost::context target that Boost.Asio's stackful coroutines need.
-set(_context_impl_line "")
-if (MSVC AND "${DEPS_ARCH}" STREQUAL "arm64")
-    set(_context_impl_line "-DBOOST_CONTEXT_IMPLEMENTATION:STRING=winfib")
-endif ()
-
 set(_options "")
 if (MSVC AND DEP_DEBUG)
     set(_options "FORWARD_CONFIG")
 endif ()
 
-# Boost.Container's bundled dlmalloc passes int* where the Win32 Interlocked API
-# takes volatile long*; cl compiles that with a warning, clang errors out.
-set(_boost_c_flags_line "")
-if (MSVC AND CMAKE_C_COMPILER_ID STREQUAL "Clang")
-    set(_boost_c_flags_line "-DCMAKE_C_FLAGS:STRING=-Wno-incompatible-pointer-types")
-endif ()
-
 orcaslicer_add_cmake_project(Boost
     ${_options}
     URL "https://github.com/boostorg/boost/releases/download/boost-1.84.0/boost-1.84.0.tar.gz"
@@ -44,8 +28,6 @@ orcaslicer_add_cmake_project(Boost
         -DBOOST_IOSTREAMS_ENABLE_ZSTD:BOOL=OFF
         "${_context_abi_line}"
         "${_context_arch_line}"
-        "${_context_impl_line}"
-        "${_boost_c_flags_line}"
 )
 
-set(DEP_Boost_DEPENDS ZLIB)
+set(DEP_Boost_DEPENDS ZLIB)

deps/CMakeLists.txt

@@ -157,16 +157,8 @@ endif ()
 function(orcaslicer_add_cmake_project projectname)
     cmake_parse_arguments(P_ARGS "FORWARD_CONFIG" "INSTALL_DIR;BUILD_COMMAND;INSTALL_COMMAND" "CMAKE_ARGS" ${ARGN})
 
-    # MSVC is true for clang-cl as well, so the sub-build toolchain has to key on the
-    # generator. A non-Visual-Studio superbuild passes its own generator down, and with
-    # it the CMAKE_C_COMPILER / CMAKE_CXX_COMPILER forwarded below.
-    set(_dep_msvc_gen FALSE)
-    if (MSVC AND CMAKE_GENERATOR MATCHES "Visual Studio")
-        set(_dep_msvc_gen TRUE)
-    endif ()
-
     set(_configs_line -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE})
-    if (_is_multi OR _dep_msvc_gen)
+    if (_is_multi OR MSVC)
         if (P_ARGS_FORWARD_CONFIG)
             set(_configs_line -DCMAKE_BUILD_TYPE:STRING=${CMAKE_BUILD_TYPE})
         elseif (ORCA_INCLUDE_DEBUG_INFO AND NOT DEP_DEBUG)
@@ -182,7 +174,7 @@ function(orcaslicer_add_cmake_project projectname)
         set(_target_config "Release")
     endif()
 
-    if (_dep_msvc_gen)
+    if (MSVC)
       set(_gen CMAKE_GENERATOR "${DEP_MSVC_GEN}" CMAKE_GENERATOR_PLATFORM "${DEP_PLATFORM}")
     else()
       set(_gen "")
@@ -190,7 +182,7 @@ function(orcaslicer_add_cmake_project projectname)
 
     if ($ENV{CMAKE_BUILD_PARALLEL_LEVEL})
       set(_build_j "")  # assume environment will control --build parallel setting
-    elseif(_dep_msvc_gen)
+    elseif(MSVC)
       set(_build_j "/m")
     else()
       set(_build_j "-j${NPROC}")
@@ -375,9 +367,6 @@ include(libnoise/libnoise.cmake)
 
 include(Draco/Draco.cmake)
 
-include(FFMPEG/FFMPEG.cmake)
-include(Assimp/Assimp.cmake)
-
 
 # I *think* 1.1 is used for *just* md5 hashing?
 # 3.1 has everything in the right place, but the md5 funcs used are deprecated
@@ -433,8 +422,6 @@ endif ()
 
 include(OCCT/OCCT.cmake)
 include(OpenCV/OpenCV.cmake)
-include(python3/python3.cmake)
-include(wxInspector/wxInspector.cmake)
 
 set(_dep_list
     dep_Boost
@@ -457,10 +444,6 @@ set(_dep_list
     ${ZLIB_PKG}
     ${EXPAT_PKG}
     dep_libnoise
-    dep_python3
-    dep_wxInspector
-    dep_FFMPEG
-    dep_Assimp
     )
 
 if (MSVC)

deps/CURL/CURL.cmake

@@ -56,18 +56,6 @@ else()
   set(_curl_static ON)
 endif()
 
-# curl 7.75's configure probes and code rely on C laxness cl allows but clang
-# errors on (implicit function declarations, int* vs u_long* in ioctlsocket),
-# which flips probe results and misconfigures nonblock.c into the AmigaOS
-# IoctlSocket branch. Relax both diagnostics so the probes behave like cl, and
-# pin the camel-case probes off since they only "pass" by implicit declaration.
-set(_curl_c_flags_line "")
-set(_curl_probe_overrides "")
-if (MSVC AND CMAKE_C_COMPILER_ID STREQUAL "Clang")
-  set(_curl_c_flags_line "-DCMAKE_C_FLAGS:STRING=-Wno-implicit-function-declaration -Wno-incompatible-pointer-types")
-  set(_curl_probe_overrides -DHAVE_IOCTLSOCKET_CAMEL=0 -DHAVE_IOCTLSOCKET_CAMEL_FIONBIO=0)
-endif ()
-
 orcaslicer_add_cmake_project(CURL
   # GIT_REPOSITORY      https://github.com/curl/curl.git
   # GIT_TAG             curl-7_75_0
@@ -81,8 +69,6 @@ orcaslicer_add_cmake_project(CURL
     -DBUILD_CURL_EXE:BOOL=OFF
     -DCMAKE_POSITION_INDEPENDENT_CODE=ON
     -DCURL_STATICLIB=${_curl_static}
-    "${_curl_c_flags_line}"
-    ${_curl_probe_overrides}
     ${_curl_platform_flags}
 )
 

deps/Eigen/Eigen.cmake

@@ -7,20 +7,5 @@ orcaslicer_add_cmake_project(Eigen
     URL https://gitlab.com/libeigen/eigen/-/archive/5.0.1/eigen-5.0.1.zip
     URL_HASH SHA256=0dbb1f9e3aaad66f352c03227d8c983f6f0b49e0b07e71a7300f4abcc01aee12
     CMAKE_ARGS "${_eigen_extra_flags}"
-        # Only the headers are consumed here. Everything below builds nothing we
-        # use, and all three enable_language(Fortran): test/CMakeLists.txt:9,
-        # lapack/CMakeLists.txt:6 and blas/testing/CMakeLists.txt:2. They default
-        # to ON because the dependency configures as its own top-level project.
-        #
-        # Whether that probe is harmless depends on what CMake finds. The Visual
-        # Studio generator supports no Fortran, so it finds nothing; clang-cl sits
-        # next to the LLVM toolset's flang, which works. MSVC with Ninja finds
-        # Strawberry Perl's MinGW gfortran instead, which the deps build already
-        # requires for OpenSSL, and hands it the MSVC-style /machine:x64 that
-        # MinGW's ld reads as a missing input file. The configure dies there and
-        # takes the rest of the superbuild with it.
-        -DEIGEN_BUILD_TESTING=OFF
-        -DEIGEN_BUILD_BLAS=OFF
-        -DEIGEN_BUILD_LAPACK=OFF
     DEPENDS dep_Boost dep_GMP dep_MPFR
 )

deps/FFMPEG/FFMPEG.cmake

@@ -1,87 +0,0 @@
-set(_conf_cmd ./configure)
-
-if (MSVC)
-    set(_source_dir "${CMAKE_BINARY_DIR}/dep_FFMPEG-prefix/src/dep_FFMPEG")
-
-    set(PREBUILD_URL_arm64 "https://github.com/Noisyfox/FFmpeg-Builds-Orca/releases/download/autobuild-2026-07-17-14-28/ffmpeg-n7.0.3-31-g9b6ffd74b5-winarm64-orca-shared-7.0.zip")
-    set(PREBUILD_HASH_arm64 "12f4140279f2f8469885e1b5b2e8be9d788882914c21523cacd56989f3548054")
-    set(PREBUILD_URL_x64 "https://github.com/Noisyfox/FFmpeg-Builds-Orca/releases/download/autobuild-2026-07-17-14-28/ffmpeg-n7.0.3-31-g9b6ffd74b5-win64-orca-shared-7.0.zip")
-    set(PREBUILD_HASH_x64 "e65916020ddb9ef84b2666dfbcbfc9b1d67f69d15b4a66db53754637bf2d498c")
-
-    ExternalProject_Add(dep_FFMPEG
-        URL ${PREBUILD_URL_${DEPS_ARCH}}
-        URL_HASH SHA256=${PREBUILD_HASH_${DEPS_ARCH}}
-        DOWNLOAD_DIR ${DEP_DOWNLOAD_DIR}/FFMPEG
-        CONFIGURE_COMMAND ""
-        BUILD_COMMAND ""
-        INSTALL_COMMAND
-            COMMAND ${CMAKE_COMMAND} -E copy_directory  "${_source_dir}/bin" "${DESTDIR}/bin"
-            COMMAND ${CMAKE_COMMAND} -E copy_directory  "${_source_dir}/lib" "${DESTDIR}/lib"
-            COMMAND ${CMAKE_COMMAND} -E copy_directory  "${_source_dir}/include" "${DESTDIR}/include"
-    )
-
-else ()
-    if (APPLE)
-        set(_minos_cmd
-            "--extra-cflags=-mmacosx-version-min=${DEP_OSX_TARGET}"
-            "--extra-ldflags=-mmacosx-version-min=${DEP_OSX_TARGET}"
-            )
-        # Static FFmpeg: nothing to bundle into the .app, no rpath handling.
-        # Disable the VideoToolbox/AudioToolbox HW-accel paths: the player decodes
-        # in software (swscale), and the auto-detected HW objects would drag in
-        # system frameworks that the static libs would then depend on.
-        set(_link_cmd --enable-static --disable-shared --disable-videotoolbox --disable-audiotoolbox)
-        if (IS_CROSS_COMPILE)
-            set(_cross_cmd --enable-cross-compile)
-            set(_pic_cmd --enable-pic)
-            if (${CMAKE_SYSTEM_PROCESSOR} MATCHES "x86_64")
-                set(_arch_cmd --arch=arm64)
-                set(_cc_cmd "--cc=clang -arch arm64")
-            else()
-                set(_arch_cmd --arch=x86_64)
-                set(_cc_cmd "--cc=clang -arch x86_64")
-            endif()
-        endif()
-    else ()
-        set(_link_cmd --enable-shared)
-    endif ()
-
-    set(_build_j -j)
-    if(DEFINED ENV{CMAKE_BUILD_PARALLEL_LEVEL})
-        set(_build_j "-j$ENV{CMAKE_BUILD_PARALLEL_LEVEL}")
-    endif()
-
-    ExternalProject_Add(dep_FFMPEG
-        URL https://github.com/FFmpeg/FFmpeg/archive/refs/tags/n7.0.3.tar.gz
-        URL_HASH SHA256=DEEDCABE339165214A3637DF4C86A507AEF0D793CF8774FF68735F4737E8DDBC
-        DOWNLOAD_DIR ${DEP_DOWNLOAD_DIR}/FFMPEG
-        CONFIGURE_COMMAND ${_conf_cmd}
-            ${_cross_cmd}
-            ${_pic_cmd}
-            ${_arch_cmd}
-            ${_cc_cmd}
-            "--prefix=${DESTDIR}"
-            ${_link_cmd}
-            ${_minos_cmd}
-            --disable-doc
-            --enable-small
-            --disable-outdevs
-            --disable-filters
-            --enable-filter=*null*,afade,*fifo,*format,*resample,aeval,allrgb,allyuv,atempo,pan,*bars,color,*key,crop,draw*,eq*,framerate,*_qsv,*_vaapi,*v4l2*,hw*,scale,volume,test*
-            --disable-protocols
-            --enable-protocol=file,fd,pipe,rtp,udp
-            --disable-muxers
-            --enable-muxer=rtp
-            --disable-encoders
-            --disable-decoders
-            --enable-decoder=*aac*,h264*,mp3*,mjpeg,rv*
-            --disable-demuxers
-            --enable-demuxer=h264,mp3,mov
-            --disable-zlib
-            --disable-avdevice
-        BUILD_IN_SOURCE ON
-        BUILD_COMMAND make ${_build_j}
-        INSTALL_COMMAND make install
-    )
-
-endif()

deps/OCCT/0001-OCCT-fix.patch

@@ -1,20 +1,3 @@
-diff --git a/adm/cmake/occt_defs_flags.cmake b/adm/cmake/occt_defs_flags.cmake
-index 00000000..00000001 100644
---- a/adm/cmake/occt_defs_flags.cmake
-+++ b/adm/cmake/occt_defs_flags.cmake
-@@ -134,7 +134,11 @@
-     set (CMAKE_CXX_FLAGS "-std=c++0x ${CMAKE_CXX_FLAGS}")
-   endif()
-   # Optimize size of binaries
--  set (CMAKE_SHARED_LINKER_FLAGS "-Wl,-s ${CMAKE_SHARED_LINKER_FLAGS}")
-+  # clang-cl reports the Clang compiler ID, and OCCT builds shared on Windows,
-+  # where the MSVC-style linker gets this flag as an argument it does not know.
-+  if (NOT WIN32)
-+    set (CMAKE_SHARED_LINKER_FLAGS "-Wl,-s ${CMAKE_SHARED_LINKER_FLAGS}")
-+  endif()
- elseif(MINGW)
-   add_definitions(-D_WIN32_WINNT=0x0601)
-   # _WIN32_WINNT=0x0601 (use Windows 7 SDK)
 diff --git a/CMakeLists.txt b/CMakeLists.txt
 index d98acc0f..28eb8eb4 100644
 --- a/CMakeLists.txt
@@ -185,32 +168,6 @@ index d98acc0f..28eb8eb4 100644
  endforeach()
  
  if (BUILD_SAMPLES_QT)
-diff --git a/adm/cmake/occt_macros.cmake b/adm/cmake/occt_macros.cmake
-index 224c96b1..8c94a1c5 100644
---- a/adm/cmake/occt_macros.cmake
-+++ b/adm/cmake/occt_macros.cmake
-@@ -608,7 +608,7 @@ macro (OCCT_INSERT_CODE_FOR_TARGET)
-   install(CODE "if (\"\${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^([Rr][Ee][Ll][Ee][Aa][Ss][Ee])$\")
-     set (OCCT_INSTALL_BIN_LETTER \"\")
-   elseif (\"\${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^([Rr][Ee][Ll][Ww][Ii][Tt][Hh][Dd][Ee][Bb][Ii][Nn][Ff][Oo])$\")
--    set (OCCT_INSTALL_BIN_LETTER \"i\")
-+    set (OCCT_INSTALL_BIN_LETTER \"\")
-   elseif (\"\${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^([Dd][Ee][Bb][Uu][Gg])$\")
-     set (OCCT_INSTALL_BIN_LETTER \"d\")
-   endif()")
-diff --git a/adm/cmake/occt_toolkit.cmake b/adm/cmake/occt_toolkit.cmake
-index 550e0e2f..7ac1a3b8 100644
---- a/adm/cmake/occt_toolkit.cmake
-+++ b/adm/cmake/occt_toolkit.cmake
-@@ -241,7 +241,7 @@
-     else()
-       set (aReleasePdbConf)
-     endif()
--    install (FILES  ${CMAKE_BINARY_DIR}/${OS_WITH_BIT}/${COMPILER}/bin\${OCCT_INSTALL_BIN_LETTER}/${PROJECT_NAME}.pdb
-+    install (FILES  $<TARGET_PDB_FILE:${PROJECT_NAME}>
-              CONFIGURATIONS Debug ${aReleasePdbConf} RelWithDebInfo
-              DESTINATION "${INSTALL_DIR_BIN}\${OCCT_INSTALL_BIN_LETTER}")
-   endif()
 diff --git a/src/Font/Font_FTFont.cxx b/src/Font/Font_FTFont.cxx
 index 5ae9899f..0a17372b 100644
 --- a/src/Font/Font_FTFont.cxx

deps/OpenCV/OpenCV.cmake

@@ -1,6 +1,4 @@
-# Intel IPP / IPP-ICV is x86/x64 only — there is no ARM64 build, so enabling it
-# leaves ~200 unresolved ippicv* externals at link time on Windows ARM64.
-if (MSVC AND NOT "${DEPS_ARCH}" STREQUAL "arm64")
+if (MSVC)
     set(_use_IPP "-DWITH_IPP=ON")
     if (DEP_DEBUG)
         set(_options "FORWARD_CONFIG")

deps/OpenEXR/OpenEXR.cmake

@@ -32,17 +32,6 @@ else()
 
 if (CMAKE_SYSTEM_NAME STREQUAL "Linux")
     set(_patch_cmd ${PATCH_CMD} ${CMAKE_CURRENT_LIST_DIR}/0001-OpenEXR-GCC13.patch)
-elseif (MSVC AND "${DEPS_ARCH}" STREQUAL "arm64")
-    # Windows ARM64: OpenEXR 2.5.5 hard-codes IMF_HAVE_SSE2 for any MSVC
-    # (ImfSimd.h: `_MSC_VER >= 1300`), pulling in <emmintrin.h> (x86-only) -> C1189.
-    # Patch the header to require an x86 target, and force the SSE cache vars off.
-    set(_patch_cmd ${CMAKE_COMMAND} -P ${CMAKE_CURRENT_LIST_DIR}/patch_openexr_arm64.cmake)
-    set(_openexr_arm64_args
-        -DOPENEXR_IMF_HAVE_SSE2:BOOL=OFF
-        -DOPENEXR_IMF_HAVE_SSSE3:BOOL=OFF
-        -DILMBASE_HAVE_SSE:BOOL=OFF
-        -DILMBASE_FORCE_DISABLE_INTEL_SSE:BOOL=ON
-    )
 else ()
     set(_patch_cmd "")
 endif ()
@@ -60,7 +49,6 @@ orcaslicer_add_cmake_project(OpenEXR
         -DPYILMBASE_ENABLE:BOOL=OFF
         -DOPENEXR_VIEWERS_ENABLE:BOOL=OFF
         -DOPENEXR_BUILD_UTILS:BOOL=OFF
-        ${_openexr_arm64_args}
 )
 endif()
 

deps/OpenEXR/patch_openexr_arm64.cmake

@@ -1,29 +0,0 @@
-# Applied as PATCH_COMMAND for OpenEXR 2.5.5 on Windows ARM64.
-#
-# Root cause of the ARM64 build failure: OpenEXR/IlmImf/ImfSimd.h hard-codes
-#     #if defined __SSE2__ || (_MSC_VER >= 1300 && !_M_CEE_PURE)
-#         #define IMF_HAVE_SSE2 1
-#     #endif
-# The `_MSC_VER >= 1300` arm is true for *every* MSVC, including ARM64, so
-# IMF_HAVE_SSE2 gets defined and <emmintrin.h> (an x86-only header) is pulled
-# in -> error C1189. This is a pure-preprocessor decision, so no CMake cache
-# variable can suppress it. Patch the header to also require an x86 target.
-
-set(_simd "OpenEXR/IlmImf/ImfSimd.h")
-if(EXISTS "${_simd}")
-    file(READ "${_simd}" _content)
-    set(_old "#if defined __SSE2__ || (_MSC_VER >= 1300 && !_M_CEE_PURE)")
-    set(_new "#if (defined __SSE2__ || (_MSC_VER >= 1300 && !_M_CEE_PURE)) && (defined(_M_IX86) || defined(_M_X64) || defined(__i386__) || defined(__x86_64__))")
-    if(_content MATCHES "_M_IX86")
-        message(STATUS "[ARM64 patch] ImfSimd.h already guarded")
-    else()
-        string(REPLACE "${_old}" "${_new}" _patched "${_content}")
-        if(_patched STREQUAL _content)
-            message(FATAL_ERROR "[ARM64 patch] Failed to match SSE2 guard in ${_simd}")
-        endif()
-        file(WRITE "${_simd}" "${_patched}")
-        message(STATUS "[ARM64 patch] Guarded IMF_HAVE_SSE2 with x86 arch check in ${_simd}")
-    endif()
-else()
-    message(FATAL_ERROR "[ARM64 patch] Not found: ${_simd}")
-endif()

deps/OpenSSL/OpenSSL.cmake

@@ -6,31 +6,17 @@ if(DEFINED OPENSSL_ARCH)
     set(_cross_arch ${OPENSSL_ARCH})
 else()
     if(WIN32)
-        if("${CMAKE_GENERATOR_PLATFORM}" STREQUAL "ARM64")
-            set(_cross_arch "VC-WIN64-ARM")
-        else()
-            set(_cross_arch "VC-WIN64A")
-        endif()
+        set(_cross_arch "VC-WIN64A")
     elseif(APPLE)
         set(_cross_arch "darwin64-${CMAKE_OSX_ARCHITECTURES}-cc")
 	endif()
 endif()
 
 if(WIN32)
-    set(_openssl_msvc_env CC=cl CXX=cl RC=rc CL=/FS)
-    # OpenSSL's perl Configure honors the CC environment variable, but the
-    # VC-WIN64A makefile only works with cl (an unquoted clang-cl path with
-    # spaces, e.g. exported by CLion, silently produces no .obj files and the
-    # lib step fails with LNK1181). Pin the upstream toolchain.
-    # Keep rc.exe resolved from the MSVC developer environment as well. The
-    # absolute Windows SDK path contains spaces and OpenSSL 1.1.1 writes it to
-    # the generated nmake file without quoting, which skips .res generation.
-    # /FS serializes access to OpenSSL's shared generated PDB when cl is
-    # driven through nmake from a Ninja configure step.
-    set(_conf_cmd ${CMAKE_COMMAND} -E env ${_openssl_msvc_env} perl Configure )
+    set(_conf_cmd perl Configure )
     set(_cross_comp_prefix_line "")
-    set(_make_cmd ${CMAKE_COMMAND} -E env ${_openssl_msvc_env} nmake)
-    set(_install_cmd ${CMAKE_COMMAND} -E env ${_openssl_msvc_env} nmake install_sw )
+    set(_make_cmd nmake)
+    set(_install_cmd nmake install_sw )
 else()
     if(APPLE)
         set(_conf_cmd export MACOSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET} && ./Configure -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET})
@@ -62,14 +48,6 @@ ExternalProject_Add(dep_OpenSSL
 	CONFIGURE_COMMAND ${_conf_cmd} ${_cross_arch}
         "--openssldir=${DESTDIR}"
         "--prefix=${DESTDIR}"
-        # OpenSSL's linux-x86_64 target sets multilib=64, so it installs to
-        # <prefix>/lib64 while every other dep uses <prefix>/lib. CPython's
-        # --with-openssl only ever emits -L<dir>/lib, so it misses the bundled
-        # static libs and silently links the system OpenSSL instead -- which,
-        # against 1.1.1w headers, leaves _ssl.so with an undefined
-        # SSL_get_peer_certificate (removed in OpenSSL 3.x). Pin libdir so the
-        # prefix stays single-layout.
-        "--libdir=lib"
         ${_cross_comp_prefix_line}
         no-shared
         no-asm

deps/TBB/MSVC.cmake

@@ -1,98 +0,0 @@
-# Copyright (c) 2020-2021 Intel Corporation
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-set(TBB_LINK_DEF_FILE_FLAG ${CMAKE_LINK_DEF_FILE_FLAG})
-set(TBB_DEF_FILE_PREFIX win${TBB_ARCH})
-
-# Workaround for CMake issue https://gitlab.kitware.com/cmake/cmake/issues/18317.
-# TODO: consider use of CMP0092 CMake policy.
-string(REGEX REPLACE "/W[0-4]" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}")
-
-set(TBB_WARNING_LEVEL $<$<BOOL:${TBB_STRICT}>:/W4> $<$<BOOL:${TBB_STRICT}>:/WX>)
-
-# Warning suppression C4324: structure was padded due to alignment specifier
-set(TBB_WARNING_SUPPRESS /wd4324)
-set(TBB_TEST_COMPILE_FLAGS /bigobj)
-
-if (MSVC_VERSION LESS_EQUAL 1900)
-    # Warning suppression C4503 for VS2015 and earlier:
-    # decorated name length exceeded, name was truncated.
-    # More info can be found at
-    # https://docs.microsoft.com/en-us/cpp/error-messages/compiler-warnings/compiler-warning-level-1-c4503
-    set(TBB_TEST_COMPILE_FLAGS ${TBB_TEST_COMPILE_FLAGS} /wd4503)
-endif()
-
-set(TBB_LIB_COMPILE_FLAGS -D_CRT_SECURE_NO_WARNINGS /GS)
-set(TBB_COMMON_COMPILE_FLAGS /volatile:iso /FS /EHsc)
-
-# Ignore /WX set through add_compile_options() or added to CMAKE_CXX_FLAGS if TBB_STRICT is disabled.
-if (NOT TBB_STRICT AND COMMAND tbb_remove_compile_flag)
-    tbb_remove_compile_flag(/WX)
-endif()
-
-if (WINDOWS_STORE OR TBB_WINDOWS_DRIVER)
-    set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} /D_WIN32_WINNT=0x0A00)
-    set(TBB_COMMON_LINK_FLAGS -NODEFAULTLIB:kernel32.lib -INCREMENTAL:NO)
-    set(TBB_COMMON_LINK_LIBS OneCore.lib)
-endif()
-
-if (WINDOWS_STORE)
-    if (NOT CMAKE_SYSTEM_VERSION EQUAL 10.0)
-        message(FATAL_ERROR "CMAKE_SYSTEM_VERSION must be equal to 10.0")
-    endif()
-    set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} /ZW /ZW:nostdlib)
-    # CMake define this extra lib, remove it for this build type
-    string(REGEX REPLACE "WindowsApp.lib" "" CMAKE_CXX_STANDARD_LIBRARIES "${CMAKE_CXX_STANDARD_LIBRARIES}")
-
-    if (TBB_NO_APPCONTAINER)
-        set(TBB_LIB_LINK_FLAGS ${TBB_LIB_LINK_FLAGS} -APPCONTAINER:NO)
-    endif()
-endif()
-
-if (TBB_WINDOWS_DRIVER)
-    # Since this is universal driver disable this variable
-    set(CMAKE_SYSTEM_PROCESSOR "")
-    # CMake define list additional libs, remove it for this build type
-    set(CMAKE_CXX_STANDARD_LIBRARIES "")
-    set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} /D _UNICODE /DUNICODE /DWINAPI_FAMILY=WINAPI_FAMILY_APP /D__WRL_NO_DEFAULT_LIB__)
-endif()
-
-if (NOT DEFINED TBB_ENABLE_IPO)
-    if (DEFINED CMAKE_INTERPROCEDURAL_OPTIMIZATION)
-        set(TBB_ENABLE_IPO ${CMAKE_INTERPROCEDURAL_OPTIMIZATION})
-    else()
-        set(TBB_ENABLE_IPO ON)
-    endif()
-endif()
-
-if (TBB_ENABLE_IPO)
-    if (CMAKE_CXX_COMPILER_ID MATCHES "(Clang|IntelLLVM)")
-        if (CMAKE_SYSTEM_PROCESSOR MATCHES "(x86|AMD64)")
-            set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} -mrtm -mwaitpkg)
-        endif()
-        set(TBB_OPENMP_NO_LINK_FLAG TRUE)
-        set(TBB_IPO_COMPILE_FLAGS $<$<NOT:$<CONFIG:Debug>>:-flto>)
-    else()
-        set(TBB_IPO_COMPILE_FLAGS $<$<NOT:$<CONFIG:Debug>>:/GL>)
-        set(TBB_IPO_LINK_FLAGS $<$<NOT:$<CONFIG:Debug>>:-LTCG> $<$<NOT:$<CONFIG:Debug>>:-INCREMENTAL:NO>)
-    endif()
-else()
-    if (CMAKE_CXX_COMPILER_ID MATCHES "(Clang|IntelLLVM)" AND CMAKE_SYSTEM_PROCESSOR MATCHES "(x86|AMD64)")
-        set(TBB_COMMON_COMPILE_FLAGS ${TBB_COMMON_COMPILE_FLAGS} -mrtm -mwaitpkg)
-    endif()
-    set(TBB_IPO_COMPILE_FLAGS "")
-    set(TBB_IPO_LINK_FLAGS "")
-endif()
-
-set(TBB_OPENMP_FLAG /openmp)

deps/TBB/TBB.cmake

@@ -1,6 +1,4 @@
-if (MSVC)
-    set(_patch_command ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_LIST_DIR}/MSVC.cmake ./cmake/compilers/MSVC.cmake)
-elseif (FLATPAK AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
+if (FLATPAK AND "${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
     set(_patch_command ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_LIST_DIR}/GNU.cmake ./cmake/compilers/GNU.cmake)
 else()
     set(_patch_command "")
@@ -15,8 +13,6 @@ orcaslicer_add_cmake_project(
         -DTBB_BUILD_SHARED=OFF
         -DTBB_BUILD_TESTS=OFF
         -DTBB_TEST=OFF
-        -DTBB_ENABLE_IPO=OFF
-        -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=OFF
         -DCMAKE_POSITION_INDEPENDENT_CODE=ON
         -DCMAKE_DEBUG_POSTFIX=_debug
 )

deps/python3/01-windows-nuget.patch

@@ -1,71 +0,0 @@
-From b32e63f75046d186d93ee7d627c978f2f7c892f3 Mon Sep 17 00:00:00 2001
-From: Steve Dower <steve.dower@python.org>
-Date: Fri, 10 Jul 2026 14:04:00 +0100
-Subject: [PATCH] [3.13] gh-153438: Update NuGet download URL (GH-153482)
- (GH-153515)
-
-gh-153438: Update NuGet download URL (GH-153482)
-(cherry picked from commit 106eb532ea3b243423e62a702719e9d3c0e40c16)
-(cherry picked from commit 62eb50d65d538dda5164f9c4a097a896454a0d1c)
-
-Co-authored-by: Steve Dower <steve.dower@python.org>
-Co-authored-by: Harjoth Khara <harjoth.khara@gmail.com>
----
- Doc/using/windows.rst                                       | 6 +++---
- .../Build/2026-07-09-22-45-00.gh-issue-153438.Qr7N2p.rst    | 2 ++
- PCbuild/find_python.bat                                     | 2 +-
- Tools/msi/get_externals.bat                                 | 2 +-
- 4 files changed, 7 insertions(+), 5 deletions(-)
- create mode 100644 Misc/NEWS.d/next/Build/2026-07-09-22-45-00.gh-issue-153438.Qr7N2p.rst
-
-diff --git a/Doc/using/windows.rst b/Doc/using/windows.rst
-index 2a507675044666..4800789ca2d6cc 100644
---- a/Doc/using/windows.rst
-+++ b/Doc/using/windows.rst
-@@ -414,9 +414,9 @@ on using nuget. What follows is a summary that is sufficient for Python
- developers.
- 
- The ``nuget.exe`` command line tool may be downloaded directly from
--``https://aka.ms/nugetclidl``, for example, using curl or PowerShell. With the
--tool, the latest version of Python for 64-bit or 32-bit machines is installed
--using::
-+``https://dist.nuget.org/win-x86-commandline/latest/nuget.exe``, for example,
-+using curl or PowerShell. With the tool, the latest version of Python for
-+64-bit or 32-bit machines is installed using::
- 
-    nuget.exe install python -ExcludeVersion -OutputDirectory .
-    nuget.exe install pythonx86 -ExcludeVersion -OutputDirectory .
-diff --git a/Misc/NEWS.d/next/Build/2026-07-09-22-45-00.gh-issue-153438.Qr7N2p.rst b/Misc/NEWS.d/next/Build/2026-07-09-22-45-00.gh-issue-153438.Qr7N2p.rst
-new file mode 100644
-index 00000000000000..edab8e6ba7b259
---- /dev/null
-+++ b/Misc/NEWS.d/next/Build/2026-07-09-22-45-00.gh-issue-153438.Qr7N2p.rst
-@@ -0,0 +1,2 @@
-+Update Windows build and installer tooling and documentation to use the
-+current download URL for ``nuget.exe``.
-diff --git a/PCbuild/find_python.bat b/PCbuild/find_python.bat
-index 0af367a3efafad..9612a2860ef9c3 100644
---- a/PCbuild/find_python.bat
-+++ b/PCbuild/find_python.bat
-@@ -52,7 +52,7 @@
- @set _Py_HOST_PYTHON=%HOST_PYTHON%
- @if "%_Py_HOST_PYTHON%"=="" set _Py_HOST_PYTHON=py
- @if "%_Py_NUGET%"=="" (set _Py_NUGET=%_Py_EXTERNALS_DIR%\nuget.exe)
--@if "%_Py_NUGET_URL%"=="" (set _Py_NUGET_URL=https://aka.ms/nugetclidl)
-+@if "%_Py_NUGET_URL%"=="" (set _Py_NUGET_URL=https://dist.nuget.org/win-x86-commandline/latest/nuget.exe)
- @if NOT exist "%_Py_NUGET%" (
-     @if not "%_Py_Quiet%"=="1" @echo Downloading nuget...
-     @rem NB: Must use single quotes around NUGET here, NOT double!
-diff --git a/Tools/msi/get_externals.bat b/Tools/msi/get_externals.bat
-index f6602ce9588ff4..c7c7e9f470bc25 100644
---- a/Tools/msi/get_externals.bat
-+++ b/Tools/msi/get_externals.bat
-@@ -6,7 +6,7 @@ set HERE=%~dp0
- if "%PCBUILD%"=="" (set PCBUILD=%HERE%..\..\PCbuild\)
- if "%EXTERNALS_DIR%"=="" (set EXTERNALS_DIR=%HERE%..\..\externals\windows-installer)
- if "%NUGET%"=="" (set NUGET=%EXTERNALS_DIR%\..\nuget.exe)
--if "%NUGET_URL%"=="" (set NUGET_URL=https://aka.ms/nugetclidl)
-+if "%NUGET_URL%"=="" (set NUGET_URL=https://dist.nuget.org/win-x86-commandline/latest/nuget.exe)
- 
- set DO_FETCH=true
- set DO_CLEAN=false

deps/python3/python3.cmake

@@ -1,279 +0,0 @@
-
-include(ProcessorCount)
-ProcessorCount(NPROC)
-
-set(_python_version "3.12.13")
-string(REGEX REPLACE "^([0-9]+\\.[0-9]+)\\..*" "\\1" _python_version_short "${_python_version}")
-set(_python_url "https://www.python.org/ftp/python/${_python_version}/Python-${_python_version}.tar.xz")
-set(_python_sha256 "c08bc65a81971c1dd5783182826503369466c7e67374d1646519adf05207b684")
-
-
-set(_patch_cmd "")
-if(WIN32)
-
-    # Fix python build failure on Windows if python is not available, due to wrong nuget download URL
-    # See https://github.com/python/cpython/issues/153438
-    # Patch from https://github.com/python/cpython/pull/153608
-    # This patch has not been merged to 3.12 yet so we need to apply it manually
-    set(_patch_cmd git init && ${PATCH_CMD} ${CMAKE_CURRENT_LIST_DIR}/01-windows-nuget.patch)
-
-    if(MSVC_VERSION EQUAL 1800)
-        set(_python_platform_toolset v120)
-    elseif(MSVC_VERSION EQUAL 1900)
-        set(_python_platform_toolset v140)
-    elseif(MSVC_VERSION LESS 1920)
-        set(_python_platform_toolset v141)
-    elseif(MSVC_VERSION LESS 1930)
-        set(_python_platform_toolset v142)
-    elseif(MSVC_VERSION LESS 1950)
-        set(_python_platform_toolset v143)
-    elseif(MSVC_VERSION LESS 1960)
-        set(_python_platform_toolset v145)
-    else()
-        message(FATAL_ERROR "Unsupported MSVC version for CPython build: ${MSVC_VERSION}")
-    endif()
-
-    # 64-bit-hosted MSBuild selection (see the build-step comment below). Default
-    # to the amd64 host + x64 tools; only the native ARM64 build differs.
-    set(_python_msbuild_host amd64)
-    set(_python_tool_arch x64)
-    if(CMAKE_SYSTEM_PROCESSOR MATCHES "ARM64|aarch64")
-        set(_python_pcbuild_platform ARM64)
-        set(_python_layout_arch arm64)
-        set(_python_pcbuild_output_dir arm64)
-        set(_python_msbuild_host arm64)   # native ARM64 MSBuild already hosts arm64 tools
-        set(_python_tool_arch "")
-    elseif(CMAKE_SIZEOF_VOID_P EQUAL 8)
-        set(_python_pcbuild_platform x64)
-        set(_python_layout_arch amd64)
-        set(_python_pcbuild_output_dir amd64)
-    else()
-        set(_python_pcbuild_platform Win32)
-        set(_python_layout_arch win32)
-        set(_python_pcbuild_output_dir win32)
-    endif()
-
-    set(_python_pcbuild_config Release)
-    set(_python_layout_debug OFF)
-    if(DEFINED DEP_DEBUG AND DEP_DEBUG)
-        set(_python_pcbuild_config Debug)
-        set(_python_layout_debug ON)
-    endif()
-
-    # CPython's PCbuild needs a 64-bit-hosted toolchain: find_msbuild.bat picks the
-    # 32-bit Bin\MSBuild.exe, whose x86 cl.exe/link.exe run out of address space
-    # (fatal C1002 "out of heap space") building the LTCG-optimized pythoncore.
-    # That 32-bit MSBuild ignores PreferredToolArchitecture, so build.bat must be
-    # pointed at a 64-bit MSBuild via the MSBUILD env var. The native arm64 MSBuild
-    # then hosts arm64 tools on its own; the amd64 MSBuild still defaults to x86, so
-    # PreferredToolArchitecture pins it to x64. Scoped to this build step, so
-    # CPython's own sources stay untouched.
-    set(_python_env_args "GIT_CEILING_DIRECTORIES=<SOURCE_DIR>/..")
-    if(CMAKE_GENERATOR_INSTANCE)   # empty for non-VS generators (e.g. Ninja)
-        set(_python_msbuild "${CMAKE_GENERATOR_INSTANCE}/MSBuild/Current/Bin/${_python_msbuild_host}/MSBuild.exe")
-        if(EXISTS "${_python_msbuild}")
-            file(TO_NATIVE_PATH "${_python_msbuild}" _python_msbuild_native)
-            list(APPEND _python_env_args "MSBUILD=${_python_msbuild_native}")
-        else()
-            # Loud signal: a silent fall-through to the 32-bit MSBuild reintroduces C1002.
-            message(WARNING "Bundled Python: 64-bit MSBuild not found at '${_python_msbuild}'. "
-                "CPython will fall back to find_msbuild.bat's default (32-bit) MSBuild, which may "
-                "fail with C1002 (out of heap space) building the optimized pythoncore.")
-        endif()
-    endif()
-    if(_python_tool_arch)
-        list(APPEND _python_env_args "PreferredToolArchitecture=${_python_tool_arch}")
-    endif()
-
-    set(_conf_cmd
-        cmd /c "echo /p:PlatformToolset=${_python_platform_toolset}>PCbuild\\msbuild.rsp"
-    )
-    set(_build_cmd
-        ${CMAKE_COMMAND} -E env ${_python_env_args}
-        cmd /c PCbuild\\build.bat
-            -p ${_python_pcbuild_platform}
-            -c ${_python_pcbuild_config}
-            --no-tkinter
-    )
-    set(_install_cmd
-        ${CMAKE_COMMAND}
-            -DPYTHON_SOURCE_DIR=<SOURCE_DIR>
-            -DPYTHON_BUILD_DIR=<SOURCE_DIR>/PCbuild/${_python_pcbuild_output_dir}
-            -DPYTHON_DEST_DIR=${DESTDIR}/libpython
-            -DPYTHON_LAYOUT_ARCH=${_python_layout_arch}
-            -DPYTHON_DEBUG=${_python_layout_debug}
-            -P ${CMAKE_CURRENT_LIST_DIR}/stage_windows.cmake
-    )
-elseif(APPLE)
-    # macOS configuration
-    if(CMAKE_OSX_ARCHITECTURES)
-        set(_python_target_arch "${CMAKE_OSX_ARCHITECTURES}")
-    else()
-        set(_python_target_arch "${CMAKE_SYSTEM_PROCESSOR}")
-    endif()
-
-    if(CMAKE_SYSTEM_PROCESSOR MATCHES "ARM64|arm64|aarch64")
-        set(_python_build_arch aarch64)
-        set(_python_build_arch_flag "arm64")
-    elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "x86_64|AMD64|amd64")
-        set(_python_build_arch x86_64)
-        set(_python_build_arch_flag "x86_64")
-    else()
-        set(_python_build_arch "${CMAKE_SYSTEM_PROCESSOR}")
-        set(_python_build_arch_flag "${CMAKE_SYSTEM_PROCESSOR}")
-    endif()
-
-    if(_python_target_arch MATCHES "ARM64|arm64|aarch64")
-        set(_python_host_arch aarch64)
-        set(_python_arch_flag "arm64")
-    elseif(_python_target_arch MATCHES "x86_64|AMD64|amd64")
-        set(_python_host_arch x86_64)
-        set(_python_arch_flag "x86_64")
-    else()
-        message(FATAL_ERROR "Unsupported macOS Python target architecture: ${_python_target_arch}")
-    endif()
-
-    set(_python_arch_flags "-arch ${_python_arch_flag} -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
-    # No -rpath: all other deps are static, so libpython has no shared
-    # dependencies to find there. headerpad reserves load-command space for
-    # the post-install -add_rpath below.
-    set(_python_ldflags "${_python_arch_flags} -Wl,-headerpad_max_install_names")
-
-    if(IS_CROSS_COMPILE)
-        set(_python_build_tgt --build=${_python_build_arch}-apple-darwin --host=${_python_host_arch}-apple-darwin)
-        set(_python_build_arch_flags "-arch ${_python_build_arch_flag} -mmacosx-version-min=${CMAKE_OSX_DEPLOYMENT_TARGET}")
-        set(_python_build_ldflags "${_python_build_arch_flags} -Wl,-rpath,${DESTDIR}/lib")
-        set(_python_build_python_dir "<SOURCE_DIR>/build-python-host")
-        set(_python_build_python "${_python_build_python_dir}/python")
-        set(_conf_cmd
-            /bin/sh -c
-            "rm -rf '${_python_build_python_dir}' && \
-             mkdir -p '${_python_build_python_dir}' && \
-             cd '${_python_build_python_dir}' && \
-             env \
-               CC='${CMAKE_C_COMPILER}' \
-               CXX='${CMAKE_CXX_COMPILER}' \
-               CFLAGS='${_python_build_arch_flags}' \
-               CXXFLAGS='${_python_build_arch_flags}' \
-               LDFLAGS='${_python_build_ldflags}' \
-               MACOSX_DEPLOYMENT_TARGET='${CMAKE_OSX_DEPLOYMENT_TARGET}' \
-               ../configure \
-                 --prefix='${_python_build_python_dir}/install' \
-                 --enable-shared \
-                 --without-static-libpython \
-                 --disable-test-modules \
-                 --build=${_python_build_arch}-apple-darwin && \
-             make -j${NPROC} python && \
-             cd '<SOURCE_DIR>' && \
-             env \
-               CC='${CMAKE_C_COMPILER}' \
-               CXX='${CMAKE_CXX_COMPILER}' \
-               CFLAGS='${_python_arch_flags}' \
-               CXXFLAGS='${_python_arch_flags}' \
-               LDFLAGS='${_python_ldflags}' \
-               MACOSX_DEPLOYMENT_TARGET='${CMAKE_OSX_DEPLOYMENT_TARGET}' \
-               ./configure \
-                 --prefix='${DESTDIR}/libpython' \
-                 --enable-shared \
-                 --enable-optimizations \
-                 --without-static-libpython \
-                 --with-openssl='${DESTDIR}' \
-                 --disable-test-modules \
-                 ${_python_build_tgt} \
-                 --with-build-python='${_python_build_python}' \
-                 py_cv_module__tkinter=n/a"
-        )
-    else()
-        set(_python_build_tgt --build=${_python_host_arch}-apple-darwin)
-        set(_conf_cmd
-            env
-            "CC=${CMAKE_C_COMPILER}"
-            "CXX=${CMAKE_CXX_COMPILER}"
-            "CFLAGS=${_python_arch_flags}"
-            "CXXFLAGS=${_python_arch_flags}"
-            "LDFLAGS=${_python_ldflags}"
-            "MACOSX_DEPLOYMENT_TARGET=${CMAKE_OSX_DEPLOYMENT_TARGET}"
-            ./configure
-            --prefix=${DESTDIR}/libpython
-            --enable-shared
-            --enable-optimizations
-            --without-static-libpython
-            --with-openssl=${DESTDIR}
-            --disable-test-modules
-            ${_python_build_tgt}
-            # Tcl/Tk 9.0 (e.g. from Homebrew) is incompatible with CPython 3.12's
-            # _tkinter; OrcaSlicer's embedded Python does not need tkinter anyway.
-            py_cv_module__tkinter=n/a
-        )
-    endif()
-    set(_build_cmd make -j${NPROC})
-
-    # CPython stamps libpython with an absolute install name ($prefix/lib/...),
-    # which every consumer inherits at link time and which only exists on the
-    # build host. Normalize once here, before anything links against the dep:
-    # give the dylib an @rpath id and teach the interpreter to find it relative
-    # to itself. Consumers then just need an rpath entry (src/CMakeLists.txt).
-    # install_name_tool invalidates code signatures, so re-sign ad-hoc; CI
-    # re-signs the whole bundle with the real identity later.
-    # ld collapses '//' in -install_name (but not in -rpath) strings, while
-    # ${DESTDIR} ends with a slash -- collapse slashes so -change matches the
-    # recorded install name.
-    string(REGEX REPLACE "/+" "/" _python_prefix "${DESTDIR}/libpython")
-    set(_python_dylib "${_python_prefix}/lib/libpython${_python_version_short}.dylib")
-    set(_python_bin "${_python_prefix}/bin/python${_python_version_short}")
-    set(_install_cmd make install
-        COMMAND install_name_tool -id "@rpath/libpython${_python_version_short}.dylib" "${_python_dylib}"
-        COMMAND install_name_tool -change "${_python_dylib}" "@rpath/libpython${_python_version_short}.dylib" "${_python_bin}"
-        COMMAND install_name_tool -add_rpath "@loader_path/../lib" "${_python_bin}"
-        COMMAND codesign --force --sign - "${_python_dylib}"
-        COMMAND codesign --force --sign - "${_python_bin}"
-    )
-else()
-    # Linux/Unix
-    # Kept verbatim, no slash normalization (unlike the macOS branch's
-    # collapsed copy): the LDFLAGS rpath below is recorded byte-for-byte in
-    # the ELF, and the OLD_RPATH handed to relocate_linux.cmake must match it
-    # exactly -- both derive from this one variable to make that structural.
-    set(_python_prefix "${DESTDIR}/libpython")
-    # The rpath points at libpython's real install dir, so the interpreter runs
-    # in-tree pre-relocation -- and, critically, it reserves enough RUNPATH
-    # bytes for the in-place $ORIGIN rewrite at install time (Flatpak's
-    # DESTDIR is the short /app) -- see relocate_linux.cmake.
-    set(_conf_cmd ./configure
-        --prefix=${_python_prefix}
-        --enable-shared
-        --enable-optimizations
-        --with-openssl=${DESTDIR}
-        --without-static-libpython
-        --disable-test-modules
-        # Tcl/Tk 9.0 is incompatible with CPython 3.12's _tkinter; not needed here.
-        py_cv_module__tkinter=n/a
-        LDFLAGS=-Wl,-rpath,${_python_prefix}/lib
-    )
-    set(_build_cmd make -j${NPROC})
-    set(_install_cmd make install
-        COMMAND ${CMAKE_COMMAND}
-            "-DPYTHON_BIN=${_python_prefix}/bin/python${_python_version_short}"
-            "-DOLD_RPATH=${_python_prefix}/lib"
-            -P "${CMAKE_CURRENT_LIST_DIR}/relocate_linux.cmake"
-    )
-endif()
-
-ExternalProject_Add(dep_python3
-    URL "${_python_url}"
-    URL_HASH SHA256=${_python_sha256}
-    PATCH_COMMAND ${_patch_cmd}
-    DOWNLOAD_DIR ${DEP_DOWNLOAD_DIR}/python3
-    BUILD_IN_SOURCE ON
-    CONFIGURE_COMMAND ${_conf_cmd}
-    BUILD_COMMAND ${_build_cmd}
-    INSTALL_COMMAND ${_install_cmd}
-)
-
-# Python depends on OpenSSL and ZLIB
-if(TARGET dep_OpenSSL)
-    add_dependencies(dep_python3 dep_OpenSSL)
-endif()
-if(TARGET dep_ZLIB)
-    add_dependencies(dep_python3 dep_ZLIB)
-endif()

deps/python3/relocate_linux.cmake

@@ -1,10 +0,0 @@
-# Repoint the installed interpreter's RUNPATH from the absolute deps dir to a
-# self-relative entry so the bundled runtime is relocatable (the deps tree,
-# Flatpak /app/libpython, and AppImage $APPDIR/lib/python all keep bin/ and
-# lib/ as siblings). $ORIGIN is expanded by the dynamic loader; CMake leaves
-# it alone (only ${...} is expanded here). RPATH_CHANGE edits the ELF in
-# place, so the new entry must not be longer than the old one: the reserved
-# ${DESTDIR}/libpython/lib is at least 18 bytes even for the shortest
-# supported DESTDIR (Flatpak's /app), longer than the 14-byte $ORIGIN/../lib.
-# Invoked from python3.cmake with -DPYTHON_BIN=... -DOLD_RPATH=...
-file(RPATH_CHANGE FILE "${PYTHON_BIN}" OLD_RPATH "${OLD_RPATH}" NEW_RPATH "$ORIGIN/../lib")

deps/python3/stage_windows.cmake

@@ -1,72 +0,0 @@
-cmake_minimum_required(VERSION 3.13)
-
-set(_python_abi "312")
-
-foreach(_var PYTHON_SOURCE_DIR PYTHON_BUILD_DIR PYTHON_DEST_DIR PYTHON_LAYOUT_ARCH)
-    if(NOT DEFINED ${_var} OR "${${_var}}" STREQUAL "")
-        message(FATAL_ERROR "${_var} is required")
-    endif()
-endforeach()
-
-set(_python_exe "${PYTHON_BUILD_DIR}/python.exe")
-if(PYTHON_DEBUG)
-    set(_python_exe "${PYTHON_BUILD_DIR}/python_d.exe")
-endif()
-
-if(NOT EXISTS "${_python_exe}")
-    message(FATAL_ERROR "Built Python executable not found: ${_python_exe}")
-endif()
-
-file(REMOVE_RECURSE "${PYTHON_DEST_DIR}")
-file(MAKE_DIRECTORY "${PYTHON_DEST_DIR}")
-
-# CPython's Windows layout helper reads LICENSE.txt from the build output.
-# Source archives ship this file as LICENSE, so provide the expected name.
-if(EXISTS "${PYTHON_SOURCE_DIR}/LICENSE" AND NOT EXISTS "${PYTHON_BUILD_DIR}/LICENSE.txt")
-    configure_file("${PYTHON_SOURCE_DIR}/LICENSE" "${PYTHON_BUILD_DIR}/LICENSE.txt" COPYONLY)
-endif()
-
-execute_process(
-    COMMAND
-        "${CMAKE_COMMAND}" -E env
-            "PYTHONHOME="
-            "PYTHONPATH=${PYTHON_SOURCE_DIR}/Lib"
-            "${_python_exe}"
-            "${PYTHON_SOURCE_DIR}/PC/layout"
-            --source "${PYTHON_SOURCE_DIR}"
-            --build "${PYTHON_BUILD_DIR}"
-            --arch "${PYTHON_LAYOUT_ARCH}"
-            --copy "${PYTHON_DEST_DIR}"
-            --include-dev
-    WORKING_DIRECTORY "${PYTHON_SOURCE_DIR}"
-    RESULT_VARIABLE _layout_result
-)
-
-if(NOT _layout_result EQUAL 0)
-    message(FATAL_ERROR "CPython Windows layout staging failed with exit code ${_layout_result}")
-endif()
-
-set(_required_files
-    "${PYTHON_DEST_DIR}/Lib/encodings/__init__.py"
-    "${PYTHON_DEST_DIR}/include/Python.h"
-)
-
-if(PYTHON_DEBUG)
-    list(APPEND _required_files
-        "${PYTHON_DEST_DIR}/python_d.exe"
-        "${PYTHON_DEST_DIR}/python${_python_abi}_d.dll"
-        "${PYTHON_DEST_DIR}/libs/python${_python_abi}_d.lib"
-    )
-else()
-    list(APPEND _required_files
-        "${PYTHON_DEST_DIR}/python.exe"
-        "${PYTHON_DEST_DIR}/python${_python_abi}.dll"
-        "${PYTHON_DEST_DIR}/libs/python${_python_abi}.lib"
-    )
-endif()
-
-foreach(_required_file IN LISTS _required_files)
-    if(NOT EXISTS "${_required_file}")
-        message(FATAL_ERROR "Staged Python file missing: ${_required_file}")
-    endif()
-endforeach()

deps/wxInspector/wxInspector.cmake

@@ -1,37 +0,0 @@
-# wxInspector finds wxWidgets through CMake's FindwxWidgets module, which only
-# searches lib/vc*_lib because _WX_TOOL is hardcoded to "vc". A superbuild driven
-# by clang-cl installs wxWidgets into lib/clang_x64_lib, so hand the module the
-# directory wxWidgets actually used, derived the same way wxWidgetsConfig.cmake
-# derives it.
-set(_wxinspector_wx_hints "")
-if (MSVC)
-    if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-        set(_wx_compiler_prefix "clang")
-    else ()
-        set(_wx_compiler_prefix "vc")
-    endif ()
-    set(_wx_arch_suffix "")
-    if (CMAKE_GENERATOR_PLATFORM AND NOT CMAKE_GENERATOR_PLATFORM STREQUAL "Win32")
-        string(TOLOWER "_${CMAKE_GENERATOR_PLATFORM}" _wx_arch_suffix)
-    elseif (CMAKE_SIZEOF_VOID_P EQUAL 8)
-        set(_wx_arch_suffix "_x64")
-    endif ()
-    set(_wxinspector_wx_hints
-        "-DwxWidgets_ROOT_DIR=${DESTDIR}"
-        "-DwxWidgets_LIB_DIR=${DESTDIR}/lib/${_wx_compiler_prefix}${_wx_arch_suffix}_lib")
-endif ()
-
-orcaslicer_add_cmake_project(
-    wxInspector
-    URL https://github.com/Noisyfox/wxInspector/archive/refs/tags/v1.0.0.zip
-    URL_HASH SHA256=0ba163956f2d468b19a91b96c5aba66ee9610843ea41dda628ea44cdafde7db7
-    DEPENDS ${WXWIDGETS_PKG}
-    CMAKE_ARGS
-        -DCMAKE_CXX_FLAGS="-DwxDEBUG_LEVEL=0"
-        -DCMAKE_POSITION_INDEPENDENT_CODE=ON
-        ${_wxinspector_wx_hints}
-)
-
-if (MSVC)
-    add_debug_dep(dep_wxInspector)
-endif ()

deps/wxWidgets/wxWidgets.cmake

@@ -26,7 +26,6 @@ orcaslicer_add_cmake_project(
     GIT_REPOSITORY "https://github.com/SoftFever/Orca-deps-wxWidgets"
     GIT_TAG v3.3.2
     GIT_SHALLOW ON
-    GIT_SUBMODULES 3rdparty/catch 3rdparty/pcre 3rdparty/libwebp
     DEPENDS ${PNG_PKG} ${ZLIB_PKG} ${EXPAT_PKG} ${JPEG_PKG}
     CMAKE_ARGS
         -DwxBUILD_PRECOMP=ON

deps_src/clipper2/CMakeLists.txt

@@ -37,11 +37,7 @@ target_include_directories(Clipper2
 )
 
 if (WIN32)
-  if (MSVC AND NOT CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
-    target_compile_options(Clipper2 PRIVATE /W4 /WX)
-  elseif (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
-    target_compile_options(Clipper2 PRIVATE /W4)
-  endif()
+  target_compile_options(Clipper2 PRIVATE /W4 /WX)
 else()
   target_compile_options(Clipper2 PRIVATE -Wall -Wextra -Wpedantic -Werror)
   target_link_libraries(Clipper2 PUBLIC -lm)

deps_src/imgui/imgui_draw.cpp

@@ -2856,7 +2856,6 @@ const ImWchar*   ImFontAtlas::GetGlyphRangesDefault()
     {
         0x0020, 0x00FF, // Basic Latin + Latin Supplement
         0x2000, 0x206F, // General Punctuation
-        0x2103, 0x2103, // ℃ Celsius symbol
         0x3000, 0x30FF, // CJK Symbols and Punctuations, Hiragana, Katakana
         0x31F0, 0x31FF, // Katakana Phonetic Extensions
         0xFF00, 0xFFEF, // Half-width characters

deps_src/imgui/imgui_widgets.cpp

@@ -267,7 +267,7 @@ void ImGui::Text(const char* fmt, ...)
 void ImGui::TextCentered(const char* text, ...)
 {
     va_list vaList;
-    va_start(vaList, text);
+    va_start(vaList,&text);
 
     float font_size = ImGui::GetFontSize() * strlen(text) / 2;
     ImGui::SameLine(ImGui::GetCursorPos().x / 2 - font_size + (font_size / 2));

deps_src/imgui/imstb_textedit.h

@@ -465,57 +465,6 @@ static void stb_textedit_click(STB_TEXTEDIT_STRING *str, STB_TexteditState *stat
       STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
       y = r.ymin;
    }
-   else
-   {
-      // In multi-line mode, clamp y to stay within the text vertical bounds.
-      // This lets the click still land at a valid location if the mouse is slightly
-      // above or below the text.
-      StbTexteditRow r;
-      int n = STB_TEXTEDIT_STRINGLEN(str);
-      int i = 0;
-      float base_y = 0, y_min, y_max;
-
-      // Get the first row to establish y_min and start the iteration
-      STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
-      if (r.num_chars <= 0)
-      {
-         state->cursor = 0;
-         state->select_start = state->cursor;
-         state->select_end = state->cursor;
-         state->has_preferred_x = 0;
-         return;
-      }
-      y_min = r.ymin;
-      y_max = base_y + r.ymax;
-      i = r.num_chars;
-      base_y += r.baseline_y_delta;
-
-      // Walk the remaining rows to find the bottom of the last row
-      while (i < n)
-      {
-         STB_TEXTEDIT_LAYOUTROW(&r, str, i);
-         if (r.num_chars <= 0)
-            break;
-         y_max = base_y + r.ymax;
-         i += r.num_chars;
-         base_y += r.baseline_y_delta;
-      }
-
-      // If the text ends with a newline, account for the empty trailing line
-      // so the cursor can be placed on it
-      if (n > 0 && STB_TEXTEDIT_GETCHAR(str, n - 1) == STB_TEXTEDIT_NEWLINE)
-      {
-         STB_TEXTEDIT_LAYOUTROW(&r, str, n);
-         y_max = base_y + r.ymax;
-      }
-
-      // Subtract half the last line height to avoid rounding issues when the mouse
-      // is just barely below the last line (keep cursor on the last line, not after the text)
-      y_max -= (r.ymax - r.ymin) * 0.5f;
-
-      if (y < y_min) y = y_min;
-      if (y > y_max) y = y_max;
-   }
 
    state->cursor = stb_text_locate_coord(str, x, y);
    state->select_start = state->cursor;
@@ -536,50 +485,6 @@ static void stb_textedit_drag(STB_TEXTEDIT_STRING *str, STB_TexteditState *state
       STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
       y = r.ymin;
    }
-   else
-   {
-      // In multi-line mode, clamp y to stay within the text vertical bounds.
-      // This lets the drag keep working if the mouse goes off the top or bottom of the text.
-      StbTexteditRow r;
-      int n = STB_TEXTEDIT_STRINGLEN(str);
-      int i = 0;
-      float base_y = 0, y_min, y_max;
-
-      // Get the first row to establish y_min and start the iteration
-      STB_TEXTEDIT_LAYOUTROW(&r, str, 0);
-      if (r.num_chars <= 0)
-         return;
-      y_min = r.ymin;
-      y_max = base_y + r.ymax;
-      i = r.num_chars;
-      base_y += r.baseline_y_delta;
-
-      // Walk the remaining rows to find the bottom of the last row
-      while (i < n)
-      {
-         STB_TEXTEDIT_LAYOUTROW(&r, str, i);
-         if (r.num_chars <= 0)
-            break;
-         y_max = base_y + r.ymax;
-         i += r.num_chars;
-         base_y += r.baseline_y_delta;
-      }
-
-      // If the text ends with a newline, account for the empty trailing line
-      // so the cursor can be placed on it
-      if (n > 0 && STB_TEXTEDIT_GETCHAR(str, n - 1) == STB_TEXTEDIT_NEWLINE)
-      {
-         STB_TEXTEDIT_LAYOUTROW(&r, str, n);
-         y_max = base_y + r.ymax;
-      }
-
-      // Subtract half the last line height to avoid rounding issues when the mouse
-      // is just barely below the last line (keep cursor on the last line, not after the text)
-      y_max -= (r.ymax - r.ymin) * 0.5f;
-
-      if (y < y_min) y = y_min;
-      if (y > y_max) y = y_max;
-   }
 
    if (state->select_start == state->select_end)
       state->select_start = state->cursor;

deps_src/miniz/CMakeLists.txt

@@ -11,8 +11,6 @@ add_library(miniz_static STATIC
 
 if(${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
     target_compile_definitions(miniz_static PRIVATE _GNU_SOURCE)
-elseif (CMAKE_C_COMPILER_ID STREQUAL "Clang" AND CMAKE_C_COMPILER_FRONTEND_VARIANT STREQUAL "MSVC")
-    target_compile_options(miniz_static PRIVATE /clang:-Wno-error=incompatible-pointer-types)
 endif()
 
 target_link_libraries(miniz INTERFACE miniz_static)

deps_src/pybind11/LICENSE

@@ -1,29 +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.
-
-Please also refer to the file .github/CONTRIBUTING.md, which clarifies licensing of
-external contributions to this project including patches, pull requests, etc.

deps_src/pybind11/README.rst

@@ -1,216 +0,0 @@
-.. figure:: https://github.com/pybind/pybind11/raw/master/docs/pybind11-logo.png
-   :alt: pybind11 logo
-
-**pybind11 (v3)  — Seamless interoperability between C++ and Python**
-
-|Latest Documentation Status| |Stable Documentation Status| |Gitter chat| |GitHub Discussions|
-
-|CI| |Build status| |SPEC 4 — Using and Creating Nightly Wheels|
-
-|Repology| |PyPI package| |Conda-forge| |Python Versions|
-
-`Setuptools example <https://github.com/pybind/python_example>`_
-• `Scikit-build example <https://github.com/pybind/scikit_build_example>`_
-• `CMake example <https://github.com/pybind/cmake_example>`_
-
-.. start
-
-
-**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 (CPython 3.8+, PyPy, or GraalPy) and the C++
-standard library. This compact implementation was possible thanks to some 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
-`pybind11.readthedocs.io <https://pybind11.readthedocs.io/en/latest>`_.
-A PDF version of the manual is available
-`here <https://pybind11.readthedocs.io/_/downloads/en/latest/pdf/>`_.
-And the source code is always available at
-`github.com/pybind/pybind11 <https://github.com/pybind/pybind11>`_.
-
-
-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
-- 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
-- Integrated NumPy support (NumPy 2 requires pybind11 2.12+)
-
-Goodies
--------
-
-In addition to the core functionality, pybind11 provides some extra
-goodies:
-
-- CPython 3.8+, PyPy3 7.3.17+, and GraalPy 24.1+ are supported with an
-  implementation-agnostic interface (see older versions for older CPython
-  and PyPy versions).
-
-- 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 <https://graylab.jhu.edu/Sergey/2016.RosettaCon/PyRosetta-4.pdf>`_
-  a binary size reduction of **5.4x** and compile time reduction by
-  **5.8x**.
-
-- Function signatures are precomputed at compile time (using
-  ``constexpr``), 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 2022 or newer (2019 probably works, but was dropped in CI)
-4. Intel classic C++ compiler 18 or newer (ICC 20.2 tested in CI)
-5. Cygwin/GCC (previously tested on 2.5.1)
-6. NVCC (CUDA 11.0 tested in CI)
-7. NVIDIA PGI (20.9 tested in CI)
-
-Supported Platforms
--------------------
-
-* Windows, Linux, macOS, and iOS
-* CPython 3.8+, Pyodide, PyPy, and GraalPy
-* C++11, C++14, C++17, C++20, and C++23
-
-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,
-Lori A. Burns,
-Sylvain Corlay,
-Eric Cousineau,
-Aaron Gokaslan,
-Ralf Grosse-Kunstleve,
-Trent Houliston,
-Axel Huebl,
-@hulucc,
-Yannick Jadoul,
-Sergey Lyskov,
-Johan Mabille,
-Tomasz Miąsko,
-Dean Moldovan,
-Ben Pritchard,
-Jason Rhinelander,
-Boris Schäling,
-Pim Schellart,
-Henry Schreiner,
-Ivan Smirnov,
-Dustin Spicuzza,
-Boris Staletic,
-Ethan Steinberg,
-Patrick Stewart,
-Ivor Wanders,
-and
-Xiaofei Wang.
-
-We thank Google for a generous financial contribution to the continuous
-integration infrastructure used by this project.
-
-
-Contributing
-~~~~~~~~~~~~
-
-See the `contributing
-guide <https://github.com/pybind/pybind11/blob/master/.github/CONTRIBUTING.md>`_
-for information on building and contributing to pybind11.
-
-License
-~~~~~~~
-
-pybind11 is provided under a BSD-style license that can be found in the
-`LICENSE <https://github.com/pybind/pybind11/blob/master/LICENSE>`_
-file. By using, distributing, or contributing to this project, you agree
-to the terms and conditions of this license.
-
-.. |Latest Documentation Status| image:: https://readthedocs.org/projects/pybind11/badge?version=latest
-   :target: http://pybind11.readthedocs.org/en/latest
-.. |Stable Documentation Status| image:: https://img.shields.io/badge/docs-stable-blue.svg
-   :target: http://pybind11.readthedocs.org/en/stable
-.. |Gitter chat| image:: https://img.shields.io/gitter/room/gitterHQ/gitter.svg
-   :target: https://gitter.im/pybind/Lobby
-.. |CI| image:: https://github.com/pybind/pybind11/workflows/CI/badge.svg
-   :target: https://github.com/pybind/pybind11/actions
-.. |Build status| image:: https://ci.appveyor.com/api/projects/status/riaj54pn4h08xy40?svg=true
-   :target: https://ci.appveyor.com/project/wjakob/pybind11
-.. |PyPI package| image:: https://img.shields.io/pypi/v/pybind11.svg
-   :target: https://pypi.org/project/pybind11/
-.. |Conda-forge| image:: https://img.shields.io/conda/vn/conda-forge/pybind11.svg
-   :target: https://github.com/conda-forge/pybind11-feedstock
-.. |Repology| image:: https://repology.org/badge/latest-versions/python:pybind11.svg
-   :target: https://repology.org/project/python:pybind11/versions
-.. |Python Versions| image:: https://img.shields.io/pypi/pyversions/pybind11.svg
-   :target: https://pypi.org/project/pybind11/
-.. |GitHub Discussions| image:: https://img.shields.io/static/v1?label=Discussions&message=Ask&color=blue&logo=github
-   :target: https://github.com/pybind/pybind11/discussions
-.. |SPEC 4 — Using and Creating Nightly Wheels| image:: https://img.shields.io/badge/SPEC-4-green?labelColor=%23004811&color=%235CA038
-   :target: https://scientific-python.org/specs/spec-0004/

deps_src/pybind11/include/pybind11/attr.h

@@ -1,722 +0,0 @@
-/*
-    pybind11/attr.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 "detail/common.h"
-#include "cast.h"
-#include "trampoline_self_life_support.h"
-
-#include <functional>
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-/// \addtogroup annotations
-/// @{
-
-/// Annotation for methods
-struct is_method {
-    handle class_;
-    explicit is_method(const handle &c) : class_(c) {}
-};
-
-/// Annotation for setters
-struct is_setter {};
-
-/// Annotation for operators
-struct is_operator {};
-
-/// Annotation for classes that cannot be subclassed
-struct is_final {};
-
-/// Annotation for parent scope
-struct scope {
-    handle value;
-    explicit scope(const handle &s) : value(s) {}
-};
-
-/// Annotation for documentation
-struct doc {
-    const char *value;
-    explicit doc(const char *value) : value(value) {}
-};
-
-/// Annotation for function names
-struct name {
-    const char *value;
-    explicit name(const char *value) : value(value) {}
-};
-
-/// Annotation indicating that a function is an overload associated with a given "sibling"
-struct sibling {
-    handle value;
-    explicit 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() = default;
-};
-
-/// 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 enables releasing the GIL before calling the C++ destructor of wrapped
-/// instances (pybind/pybind11#1446).
-struct release_gil_before_calling_cpp_dtor {};
-
-/// 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) {}
-};
-
-/// Specifies a custom callback with signature `void (PyHeapTypeObject*)` that
-/// may be used to customize the Python type.
-///
-/// The callback is invoked immediately before `PyType_Ready`.
-///
-/// Note: This is an advanced interface, and uses of it may require changes to
-/// work with later versions of pybind11.  You may wish to consult the
-/// implementation of `make_new_python_type` in `detail/classes.h` to understand
-/// the context in which the callback will be run.
-struct custom_type_setup {
-    using callback = std::function<void(PyHeapTypeObject *heap_type)>;
-
-    explicit custom_type_setup(callback value) : value(std::move(value)) {}
-
-    callback value;
-};
-
-/// Annotation that marks a class as local to the module:
-struct module_local {
-    const bool value;
-    constexpr explicit module_local(bool v = true) : value(v) {}
-};
-
-/// Annotation to mark enums as an arithmetic type
-struct arithmetic {};
-
-/// Mark a function for addition at the beginning of the existing overload chain instead of the end
-struct prepend {};
-
-/** \rst
-    A call policy which places one or more guard variables (``Ts...``) around the function call.
-
-    For example, this definition:
-
-    .. code-block:: cpp
-
-        m.def("foo", foo, py::call_guard<T>());
-
-    is equivalent to the following pseudocode:
-
-    .. code-block:: cpp
-
-        m.def("foo", [](args...) {
-            T scope_guard;
-            return foo(args...); // forwarded arguments
-        });
- \endrst */
-template <typename... Ts>
-struct call_guard;
-
-template <>
-struct call_guard<> {
-    using type = detail::void_type;
-};
-
-template <typename T>
-struct call_guard<T> {
-    static_assert(std::is_default_constructible<T>::value,
-                  "The guard type must be default constructible");
-
-    using type = T;
-};
-
-template <typename T, typename... Ts>
-struct call_guard<T, Ts...> {
-    struct type {
-        T guard{}; // Compose multiple guard types with left-to-right default-constructor order
-        typename call_guard<Ts...>::type next{};
-    };
-};
-
-/// @} annotations
-
-PYBIND11_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_;
-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
-    bool none : 1;     ///< True if None is allowed when loading
-
-    argument_record(const char *name, const char *descr, handle value, bool convert, bool none)
-        : name(name), descr(descr), value(value), convert(convert), none(none) {}
-};
-
-/// Internal data structure which holds metadata about a bound function (signature, overloads,
-/// etc.)
-#define PYBIND11_DETAIL_FUNCTION_RECORD_ABI_ID "v1" // PLEASE UPDATE if the struct is changed.
-struct function_record {
-    function_record()
-        : is_constructor(false), is_new_style_constructor(false), is_stateless(false),
-          is_operator(false), is_method(false), is_setter(false), has_args(false),
-          has_kwargs(false), prepend(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 new-style `__init__` defined in `detail/init.h`
-    bool is_new_style_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 this is a method
-    bool is_method : 1;
-
-    /// True if this is a setter
-    bool is_setter : 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 function is to be inserted at the beginning of the overload resolution chain
-    bool prepend : 1;
-
-    /// Number of arguments (including py::args and/or py::kwargs, if present)
-    std::uint16_t nargs;
-
-    /// Number of leading positional arguments, which are terminated by a py::args or py::kwargs
-    /// argument or by a py::kw_only annotation.
-    std::uint16_t nargs_pos = 0;
-
-    /// Number of leading arguments (counted in `nargs`) that are positional-only
-    std::uint16_t nargs_pos_only = 0;
-
-    /// 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;
-};
-// The main purpose of this macro is to make it easy to pin-point the critically related code
-// sections.
-#define PYBIND11_ENSURE_PRECONDITION_FOR_FUNCTIONAL_H_PERFORMANCE_OPTIMIZATIONS(...)              \
-    static_assert(                                                                                \
-        __VA_ARGS__,                                                                              \
-        "Violation of precondition for pybind11/functional.h performance optimizations!")
-
-/// 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),
-          module_local(false), is_final(false), release_gil_before_calling_cpp_dtor(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;
-
-    /// What is the alignment of the underlying C++ type?
-    size_t type_align = 0;
-
-    /// How large is the type's holder?
-    size_t holder_size = 0;
-
-    /// The global operator new can be overridden with a class-specific variant
-    void *(*operator_new)(size_t) = nullptr;
-
-    /// Function pointer to class_<..>::init_instance
-    void (*init_instance)(instance *, const void *) = nullptr;
-
-    /// Function pointer to class_<..>::dealloc
-    void (*dealloc)(detail::value_and_holder &) = nullptr;
-
-    /// Function pointer for casting alias class (aka trampoline) pointer to
-    /// trampoline_self_life_support pointer. Sidesteps cross-DSO RTTI issues
-    /// on platforms like macOS (see PR #5728 for details).
-    get_trampoline_self_life_support_fn get_trampoline_self_life_support
-        = [](void *) -> trampoline_self_life_support * { return nullptr; };
-
-    /// List of base classes of the newly created type
-    list bases;
-
-    /// Optional docstring
-    const char *doc = nullptr;
-
-    /// Custom metaclass (optional)
-    handle metaclass;
-
-    /// Custom type setup.
-    custom_type_setup::callback custom_type_setup_callback;
-
-    /// 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 class definition local to the module shared object?
-    bool module_local : 1;
-
-    /// Is the class inheritable from python classes?
-    bool is_final : 1;
-
-    /// Solves pybind/pybind11#1446
-    bool release_gil_before_calling_cpp_dtor : 1;
-
-    holder_enum_t holder_enum_v = holder_enum_t::undefined;
-
-    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 + "\"");
-        }
-
-        // SMART_HOLDER_BAKEIN_FOLLOW_ON: Refine holder compatibility checks.
-        bool this_has_unique_ptr_holder = (holder_enum_v == holder_enum_t::std_unique_ptr);
-        bool base_has_unique_ptr_holder
-            = (base_info->holder_enum_v == holder_enum_t::std_unique_ptr);
-        if (this_has_unique_ptr_holder != base_has_unique_ptr_holder) {
-            std::string tname(base.name());
-            detail::clean_type_id(tname);
-            pybind11_fail("generic_type: type \"" + std::string(name) + "\" "
-                          + (this_has_unique_ptr_holder ? "does not have" : "has")
-                          + " a non-default holder type while its base \"" + tname + "\" "
-                          + (base_has_unique_ptr_holder ? "does not" : "does"));
-        }
-
-        bases.append((PyObject *) base_info->type);
-
-#ifdef PYBIND11_BACKWARD_COMPATIBILITY_TP_DICTOFFSET
-        dynamic_attr |= base_info->type->tp_dictoffset != 0;
-#else
-        dynamic_attr |= (base_info->type->tp_flags & Py_TPFLAGS_MANAGED_DICT) != 0;
-#endif
-
-        if (caster) {
-            base_info->implicit_casts.emplace_back(type, caster);
-        }
-    }
-};
-
-inline function_call::function_call(const function_record &f, handle p) : func(f), parent(p) {
-    args.reserve(f.nargs);
-    args_convert.reserve(f.nargs);
-}
-
-/// Tag for a new-style `__init__` defined in `detail/init.h`
-struct is_new_style_constructor {};
-
-/**
- * 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 = 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 that this function is a setter
-template <>
-struct process_attribute<is_setter> : process_attribute_default<is_setter> {
-    static void init(const is_setter &, function_record *r) { r->is_setter = true; }
-};
-
-/// 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; }
-};
-
-template <>
-struct process_attribute<is_new_style_constructor>
-    : process_attribute_default<is_new_style_constructor> {
-    static void init(const is_new_style_constructor &, function_record *r) {
-        r->is_new_style_constructor = true;
-    }
-};
-
-inline void check_kw_only_arg(const arg &a, function_record *r) {
-    if (r->args.size() > r->nargs_pos && (!a.name || a.name[0] == '\0')) {
-        pybind11_fail("arg(): cannot specify an unnamed argument after a kw_only() annotation or "
-                      "args() argument");
-    }
-}
-
-inline void append_self_arg_if_needed(function_record *r) {
-    if (r->is_method && r->args.empty()) {
-        r->args.emplace_back("self", nullptr, handle(), /*convert=*/true, /*none=*/false);
-    }
-}
-
-/// 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) {
-        append_self_arg_if_needed(r);
-        r->args.emplace_back(a.name, nullptr, handle(), !a.flag_noconvert, a.flag_none);
-
-        check_kw_only_arg(a, r);
-    }
-};
-
-/// 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", /*descr=*/nullptr, /*parent=*/handle(), /*convert=*/true, /*none=*/false);
-        }
-
-        if (!a.value) {
-#if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
-            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?). "
-                          "#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for "
-                          "more information.");
-#endif
-        }
-        r->args.emplace_back(a.name, a.descr, a.value.inc_ref(), !a.flag_noconvert, a.flag_none);
-
-        check_kw_only_arg(a, r);
-    }
-};
-
-/// Process a keyword-only-arguments-follow pseudo argument
-template <>
-struct process_attribute<kw_only> : process_attribute_default<kw_only> {
-    static void init(const kw_only &, function_record *r) {
-        append_self_arg_if_needed(r);
-        if (r->has_args && r->nargs_pos != static_cast<std::uint16_t>(r->args.size())) {
-            pybind11_fail("Mismatched args() and kw_only(): they must occur at the same relative "
-                          "argument location (or omit kw_only() entirely)");
-        }
-        r->nargs_pos = static_cast<std::uint16_t>(r->args.size());
-    }
-};
-
-/// Process a positional-only-argument maker
-template <>
-struct process_attribute<pos_only> : process_attribute_default<pos_only> {
-    static void init(const pos_only &, function_record *r) {
-        append_self_arg_if_needed(r);
-        r->nargs_pos_only = static_cast<std::uint16_t>(r->args.size());
-        if (r->nargs_pos_only > r->nargs_pos) {
-            pybind11_fail("pos_only(): cannot follow a py::args() argument");
-        }
-        // It also can't follow a kw_only, but a static_assert in pybind11.h checks that
-    }
-};
-
-/// 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<custom_type_setup> {
-    static void init(const custom_type_setup &value, type_record *r) {
-        r->custom_type_setup_callback = value.value;
-    }
-};
-
-template <>
-struct process_attribute<is_final> : process_attribute_default<is_final> {
-    static void init(const is_final &, type_record *r) { r->is_final = 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; }
-};
-
-template <>
-struct process_attribute<module_local> : process_attribute_default<module_local> {
-    static void init(const module_local &l, type_record *r) { r->module_local = l.value; }
-};
-
-template <>
-struct process_attribute<release_gil_before_calling_cpp_dtor>
-    : process_attribute_default<release_gil_before_calling_cpp_dtor> {
-    static void init(const release_gil_before_calling_cpp_dtor &, type_record *r) {
-        r->release_gil_before_calling_cpp_dtor = true;
-    }
-};
-
-/// Process a 'prepend' attribute, putting this at the beginning of the overload chain
-template <>
-struct process_attribute<prepend> : process_attribute_default<prepend> {
-    static void init(const prepend &, function_record *r) { r->prepend = true; }
-};
-
-/// Process an 'arithmetic' attribute for enums (does nothing here)
-template <>
-struct process_attribute<arithmetic> : process_attribute_default<arithmetic> {};
-
-template <typename... Ts>
-struct process_attribute<call_guard<Ts...>> : process_attribute_default<call_guard<Ts...>> {};
-
-/**
- * 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) {
-        PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(r);
-        PYBIND11_WORKAROUND_INCORRECT_GCC_UNUSED_BUT_SET_PARAMETER(r);
-        using expander = int[];
-        (void) expander{
-            0, ((void) process_attribute<typename std::decay<Args>::type>::init(args, r), 0)...};
-    }
-    static void init(const Args &...args, type_record *r) {
-        PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(r);
-        PYBIND11_WORKAROUND_INCORRECT_GCC_UNUSED_BUT_SET_PARAMETER(r);
-        using expander = int[];
-        (void) expander{0,
-                        (process_attribute<typename std::decay<Args>::type>::init(args, r), 0)...};
-    }
-    static void precall(function_call &call) {
-        PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(call);
-        using expander = int[];
-        (void) expander{0,
-                        (process_attribute<typename std::decay<Args>::type>::precall(call), 0)...};
-    }
-    static void postcall(function_call &call, handle fn_ret) {
-        PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(call, fn_ret);
-        PYBIND11_WORKAROUND_INCORRECT_GCC_UNUSED_BUT_SET_PARAMETER(fn_ret);
-        using expander = int[];
-        (void) expander{
-            0, (process_attribute<typename std::decay<Args>::type>::postcall(call, fn_ret), 0)...};
-    }
-};
-
-template <typename T>
-using is_call_guard = is_instantiation<call_guard, T>;
-
-/// Extract the ``type`` from the first `call_guard` in `Extras...` (or `void_type` if none found)
-template <typename... Extra>
-using extract_guard_t = typename exactly_one_t<is_call_guard, call_guard<>, Extra...>::type;
-
-/// 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) {
-    PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(nargs, has_args, has_kwargs);
-    return named == 0 || (self + named + size_t(has_args) + size_t(has_kwargs)) == nargs;
-}
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/buffer_info.h

@@ -1,208 +0,0 @@
-/*
-    pybind11/buffer_info.h: Python buffer object interface
-
-    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 "detail/common.h"
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-// Default, C-style strides
-inline std::vector<ssize_t> c_strides(const std::vector<ssize_t> &shape, ssize_t itemsize) {
-    auto ndim = shape.size();
-    std::vector<ssize_t> strides(ndim, itemsize);
-    if (ndim > 0) {
-        for (size_t i = ndim - 1; i > 0; --i) {
-            strides[i - 1] = strides[i] * shape[i];
-        }
-    }
-    return strides;
-}
-
-// F-style strides; default when constructing an array_t with `ExtraFlags & f_style`
-inline std::vector<ssize_t> f_strides(const std::vector<ssize_t> &shape, ssize_t itemsize) {
-    auto ndim = shape.size();
-    std::vector<ssize_t> strides(ndim, itemsize);
-    for (size_t i = 1; i < ndim; ++i) {
-        strides[i] = strides[i - 1] * shape[i - 1];
-    }
-    return strides;
-}
-
-template <typename T, typename SFINAE = void>
-struct compare_buffer_info;
-
-PYBIND11_NAMESPACE_END(detail)
-
-/// Information record describing a Python buffer object
-struct buffer_info {
-    void *ptr = nullptr;          // Pointer to the underlying storage
-    ssize_t itemsize = 0;         // Size of individual items in bytes
-    ssize_t size = 0;             // Total number of entries
-    std::string format;           // For homogeneous buffers, this should be set to
-                                  // format_descriptor<T>::format()
-    ssize_t ndim = 0;             // Number of dimensions
-    std::vector<ssize_t> shape;   // Shape of the tensor (1 entry per dimension)
-    std::vector<ssize_t> strides; // Number of bytes between adjacent entries
-                                  // (for each per dimension)
-    bool readonly = false;        // flag to indicate if the underlying storage may be written to
-
-    buffer_info() = default;
-
-    buffer_info(void *ptr,
-                ssize_t itemsize,
-                const std::string &format,
-                ssize_t ndim,
-                detail::any_container<ssize_t> shape_in,
-                detail::any_container<ssize_t> strides_in,
-                bool readonly = false)
-        : ptr(ptr), itemsize(itemsize), size(1), format(format), ndim(ndim),
-          shape(std::move(shape_in)), strides(std::move(strides_in)), readonly(readonly) {
-        if (ndim != (ssize_t) shape.size() || ndim != (ssize_t) strides.size()) {
-            pybind11_fail("buffer_info: ndim doesn't match shape and/or strides length");
-        }
-        for (size_t i = 0; i < (size_t) ndim; ++i) {
-            size *= shape[i];
-        }
-    }
-
-    template <typename T>
-    buffer_info(T *ptr,
-                detail::any_container<ssize_t> shape_in,
-                detail::any_container<ssize_t> strides_in,
-                bool readonly = false)
-        : buffer_info(private_ctr_tag(),
-                      ptr,
-                      sizeof(T),
-                      format_descriptor<T>::format(),
-                      static_cast<ssize_t>(shape_in->size()),
-                      std::move(shape_in),
-                      std::move(strides_in),
-                      readonly) {}
-
-    buffer_info(void *ptr,
-                ssize_t itemsize,
-                const std::string &format,
-                ssize_t size,
-                bool readonly = false)
-        : buffer_info(ptr, itemsize, format, 1, {size}, {itemsize}, readonly) {}
-
-    template <typename T>
-    buffer_info(T *ptr, ssize_t size, bool readonly = false)
-        : buffer_info(ptr, sizeof(T), format_descriptor<T>::format(), size, readonly) {}
-
-    template <typename T>
-    buffer_info(const T *ptr, ssize_t size, bool readonly = true)
-        : buffer_info(
-              const_cast<T *>(ptr), sizeof(T), format_descriptor<T>::format(), size, readonly) {}
-
-    explicit buffer_info(Py_buffer *view, bool ownview = true)
-        : buffer_info(
-              view->buf,
-              view->itemsize,
-              view->format,
-              view->ndim,
-              {view->shape, view->shape + view->ndim},
-              /* Though buffer::request() requests PyBUF_STRIDES, ctypes objects
-               * ignore this flag and return a view with NULL strides.
-               * When strides are NULL, build them manually.  */
-              view->strides
-                  ? std::vector<ssize_t>(view->strides, view->strides + view->ndim)
-                  : detail::c_strides({view->shape, view->shape + view->ndim}, view->itemsize),
-              (view->readonly != 0)) {
-        // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
-        this->m_view = view;
-        // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
-        this->ownview = ownview;
-    }
-
-    buffer_info(const buffer_info &) = delete;
-    buffer_info &operator=(const buffer_info &) = delete;
-
-    buffer_info(buffer_info &&other) noexcept { (*this) = std::move(other); }
-
-    buffer_info &operator=(buffer_info &&rhs) noexcept {
-        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(m_view, rhs.m_view);
-        std::swap(ownview, rhs.ownview);
-        readonly = rhs.readonly;
-        return *this;
-    }
-
-    ~buffer_info() {
-        if (m_view && ownview) {
-            PyBuffer_Release(m_view);
-            delete m_view;
-        }
-    }
-
-    Py_buffer *view() const { return m_view; }
-    Py_buffer *&view() { return m_view; }
-
-    /* True if the buffer item type is equivalent to `T`. */
-    // To define "equivalent" by example:
-    // `buffer_info::item_type_is_equivalent_to<int>(b)` and
-    // `buffer_info::item_type_is_equivalent_to<long>(b)` may both be true
-    // on some platforms, but `int` and `unsigned` will never be equivalent.
-    // For the ground truth, please inspect `detail::compare_buffer_info<>`.
-    template <typename T>
-    bool item_type_is_equivalent_to() const {
-        return detail::compare_buffer_info<T>::compare(*this);
-    }
-
-private:
-    struct private_ctr_tag {};
-
-    buffer_info(private_ctr_tag,
-                void *ptr,
-                ssize_t itemsize,
-                const std::string &format,
-                ssize_t ndim,
-                detail::any_container<ssize_t> &&shape_in,
-                detail::any_container<ssize_t> &&strides_in,
-                bool readonly)
-        : buffer_info(
-              ptr, itemsize, format, ndim, std::move(shape_in), std::move(strides_in), readonly) {}
-
-    Py_buffer *m_view = nullptr;
-    bool ownview = false;
-};
-
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-template <typename T, typename SFINAE>
-struct compare_buffer_info {
-    static bool compare(const buffer_info &b) {
-        // NOLINTNEXTLINE(bugprone-sizeof-expression) Needed for `PyObject *`
-        return b.format == format_descriptor<T>::format() && b.itemsize == (ssize_t) 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 (size_t) 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")));
-    }
-};
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/chrono.h

@@ -1,228 +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 <chrono>
-#include <cmath>
-#include <ctime>
-#include <datetime.h>
-#include <mutex>
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-template <typename type>
-class duration_caster {
-public:
-    using rep = typename type::rep;
-    using period = typename type::period;
-
-    // signed 25 bits required by the standard.
-    using days = std::chrono::duration<int_least32_t, std::ratio<86400>>;
-
-    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
-        if (PyFloat_Check(src.ptr())) {
-            value = type(duration_cast<duration<rep, period>>(
-                duration<double>(PyFloat_AsDouble(src.ptr()))));
-            return true;
-        }
-        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;
-    }
-    static const std::chrono::duration<rep, period> &
-    get_duration(const std::chrono::duration<rep, period> &&)
-        = delete;
-
-    // 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, const_name("datetime.timedelta"));
-};
-
-inline std::tm *localtime_thread_safe(const std::time_t *time, std::tm *buf) {
-#if (defined(__STDC_LIB_EXT1__) && defined(__STDC_WANT_LIB_EXT1__)) || defined(_MSC_VER)
-    if (localtime_s(buf, time))
-        return nullptr;
-    return buf;
-#else
-    static std::mutex mtx;
-    std::lock_guard<std::mutex> lock(mtx);
-    std::tm *tm_ptr = std::localtime(time);
-    if (tm_ptr != nullptr) {
-        *buf = *tm_ptr;
-    }
-    return tm_ptr;
-#endif
-}
-
-// 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:
-    using type = std::chrono::time_point<std::chrono::system_clock, Duration>;
-    bool load(handle src, bool) {
-        using namespace std::chrono;
-
-        // Lazy initialise the PyDateTime import
-        if (!PyDateTimeAPI) {
-            PyDateTime_IMPORT;
-        }
-
-        if (!src) {
-            return false;
-        }
-
-        std::tm cal;
-        microseconds msecs;
-
-        if (PyDateTime_Check(src.ptr())) {
-            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;
-            msecs = microseconds(PyDateTime_DATE_GET_MICROSECOND(src.ptr()));
-        } else if (PyDate_Check(src.ptr())) {
-            cal.tm_sec = 0;
-            cal.tm_min = 0;
-            cal.tm_hour = 0;
-            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;
-            msecs = microseconds(0);
-        } else if (PyTime_Check(src.ptr())) {
-            cal.tm_sec = PyDateTime_TIME_GET_SECOND(src.ptr());
-            cal.tm_min = PyDateTime_TIME_GET_MINUTE(src.ptr());
-            cal.tm_hour = PyDateTime_TIME_GET_HOUR(src.ptr());
-            cal.tm_mday = 1;  // This date (day, month, year) = (1, 0, 70)
-            cal.tm_mon = 0;   // represents 1-Jan-1970, which is the first
-            cal.tm_year = 70; // earliest available date for Python's datetime
-            cal.tm_isdst = -1;
-            msecs = microseconds(PyDateTime_TIME_GET_MICROSECOND(src.ptr()));
-        } else {
-            return false;
-        }
-
-        value = time_point_cast<Duration>(system_clock::from_time_t(std::mktime(&cal)) + msecs);
-        return true;
-    }
-
-    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;
-        }
-
-        // Get out microseconds, and make sure they are positive, to avoid bug in eastern
-        // hemisphere time zones (cfr. https://github.com/pybind/pybind11/issues/2417)
-        using us_t = duration<int, std::micro>;
-        auto us = duration_cast<us_t>(src.time_since_epoch() % seconds(1));
-        if (us.count() < 0) {
-            us += duration_cast<us_t>(seconds(1));
-        }
-
-        // Subtract microseconds BEFORE `system_clock::to_time_t`, because:
-        // > If std::time_t has lower precision, it is implementation-defined whether the value is
-        // rounded or truncated. (https://en.cppreference.com/w/cpp/chrono/system_clock/to_time_t)
-        std::time_t tt
-            = system_clock::to_time_t(time_point_cast<system_clock::duration>(src - us));
-
-        std::tm localtime;
-        std::tm *localtime_ptr = localtime_thread_safe(&tt, &localtime);
-        if (!localtime_ptr) {
-            throw cast_error("Unable to represent system_clock in local time");
-        }
-        return PyDateTime_FromDateAndTime(localtime.tm_year + 1900,
-                                          localtime.tm_mon + 1,
-                                          localtime.tm_mday,
-                                          localtime.tm_hour,
-                                          localtime.tm_min,
-                                          localtime.tm_sec,
-                                          us.count());
-    }
-    PYBIND11_TYPE_CASTER(type, const_name("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>> {};
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/common.h

@@ -1,2 +0,0 @@
-#include "detail/common.h"
-#warning "Including 'common.h' is deprecated. It will be removed in v3.0. Use 'pybind11.h'."

deps_src/pybind11/include/pybind11/complex.h

@@ -1,74 +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
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-template <typename T>
-struct format_descriptor<std::complex<T>, detail::enable_if_t<std::is_floating_point<T>::value>> {
-    static constexpr const char c = format_descriptor<T>::c;
-    static constexpr const char value[3] = {'Z', c, '\0'};
-    static std::string format() { return std::string(value); }
-};
-
-#ifndef PYBIND11_CPP17
-
-template <typename T>
-constexpr const char
-    format_descriptor<std::complex<T>,
-                      detail::enable_if_t<std::is_floating_point<T>::value>>::value[3];
-
-#endif
-
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-template <typename T>
-struct is_fmt_numeric<std::complex<T>, detail::enable_if_t<std::is_floating_point<T>::value>> {
-    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>, const_name("complex"));
-};
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/conduit/README.txt

@@ -1,15 +0,0 @@
-NOTE
-----
-
-The C++ code here
-
-** only depends on <Python.h> **
-
-and nothing else.
-
-DO NOT ADD CODE WITH OTHER EXTERNAL DEPENDENCIES TO THIS DIRECTORY.
-
-Read on:
-
-pybind11_conduit_v1.h — Type-safe interoperability between different
-                        independent Python/C++ bindings systems.

deps_src/pybind11/include/pybind11/conduit/pybind11_conduit_v1.h

@@ -1,116 +0,0 @@
-// Copyright (c) 2024 The pybind Community.
-
-/* The pybind11_conduit_v1 feature enables type-safe interoperability between
-
-* different independent Python/C++ bindings systems,
-
-* including pybind11 versions with different PYBIND11_INTERNALS_VERSION's.
-
-    * NOTE: The conduit feature
-            only covers    from-Python-to-C++ conversions, it
-            does not cover from-C++-to-Python conversions.
-            (For the latter, a different feature would have to be added.)
-
-The naming of the feature is a bit misleading:
-
-* The feature is in no way tied to pybind11 internals.
-
-* It just happens to originate from pybind11 and currently still lives there.
-
-* The only external dependency is <Python.h>.
-
-The implementation is a VERY light-weight dependency. It is designed to be
-compatible with any ISO C++11 (or higher) compiler, and does NOT require
-C++ Exception Handling to be enabled.
-
-Please see https://github.com/pybind/pybind11/pull/5296 for more background.
-
-The implementation involves a
-
-def _pybind11_conduit_v1_(
-    self,
-    pybind11_platform_abi_id: bytes,
-    cpp_type_info_capsule: capsule,
-    pointer_kind: bytes) -> capsule
-
-method that is meant to be added to Python objects wrapping C++ objects
-(e.g. pybind11::class_-wrapped types).
-
-The design of the _pybind11_conduit_v1_ feature provides two layers of
-protection against C++ ABI mismatches:
-
-* The first and most important layer is that the pybind11_platform_abi_id's
-  must match between extensions. — This will never be perfect, but is the same
-  pragmatic approach used in pybind11 since 2017
-  (https://github.com/pybind/pybind11/commit/96997a4b9d4ec3d389a570604394af5d5eee2557,
-  PYBIND11_INTERNALS_ID).
-
-* The second layer is that the typeid(std::type_info).name()'s must match
-  between extensions.
-
-The implementation below (which is shorter than this comment!), serves as a
-battle-tested specification. The main API is this one function:
-
-auto *cpp_pointer = pybind11_conduit_v1::get_type_pointer_ephemeral<YourType>(py_obj);
-
-It is meant to be a minimalistic reference implementation, intentionally
-without comprehensive error reporting. It is expected that major bindings
-systems will roll their own, compatible implementations, potentially with
-system-specific error reporting. The essential specifications all bindings
-systems need to agree on are merely:
-
-* PYBIND11_PLATFORM_ABI_ID (const char* literal).
-
-* The cpp_type_info capsule (see below: a void *ptr and a const char *name).
-
-* The cpp_conduit capsule (see below: a void *ptr and a const char *name).
-
-* "raw_pointer_ephemeral" means: the lifetime of the pointer is the lifetime
-  of the py_obj.
-
-*/
-
-// THIS MUST STAY AT THE TOP!
-#include "pybind11_platform_abi_id.h"
-
-#include <Python.h>
-#include <typeinfo>
-
-namespace pybind11_conduit_v1 {
-
-inline void *get_raw_pointer_ephemeral(PyObject *py_obj, const std::type_info *cpp_type_info) {
-    PyObject *cpp_type_info_capsule
-        = PyCapsule_New(const_cast<void *>(static_cast<const void *>(cpp_type_info)),
-                        typeid(std::type_info).name(),
-                        nullptr);
-    if (cpp_type_info_capsule == nullptr) {
-        return nullptr;
-    }
-    PyObject *cpp_conduit = PyObject_CallMethod(py_obj,
-                                                "_pybind11_conduit_v1_",
-                                                "yOy",
-                                                PYBIND11_PLATFORM_ABI_ID,
-                                                cpp_type_info_capsule,
-                                                "raw_pointer_ephemeral");
-    Py_DECREF(cpp_type_info_capsule);
-    if (cpp_conduit == nullptr) {
-        return nullptr;
-    }
-    void *raw_ptr = PyCapsule_GetPointer(cpp_conduit, cpp_type_info->name());
-    Py_DECREF(cpp_conduit);
-    if (PyErr_Occurred()) {
-        return nullptr;
-    }
-    return raw_ptr;
-}
-
-template <typename T>
-T *get_type_pointer_ephemeral(PyObject *py_obj) {
-    void *raw_ptr = get_raw_pointer_ephemeral(py_obj, &typeid(T));
-    if (raw_ptr == nullptr) {
-        return nullptr;
-    }
-    return static_cast<T *>(raw_ptr);
-}
-
-} // namespace pybind11_conduit_v1

deps_src/pybind11/include/pybind11/conduit/pybind11_platform_abi_id.h

@@ -1,87 +0,0 @@
-#pragma once
-
-// Copyright (c) 2024 The pybind Community.
-
-// To maximize reusability:
-// DO NOT ADD CODE THAT REQUIRES C++ EXCEPTION HANDLING.
-
-#include "wrap_include_python_h.h"
-
-// Implementation details. DO NOT USE ELSEWHERE. (Unfortunately we cannot #undef them.)
-// This is duplicated here to maximize portability.
-#define PYBIND11_PLATFORM_ABI_ID_STRINGIFY(x) #x
-#define PYBIND11_PLATFORM_ABI_ID_TOSTRING(x) PYBIND11_PLATFORM_ABI_ID_STRINGIFY(x)
-
-#ifdef PYBIND11_COMPILER_TYPE
-//   // To maintain backward compatibility (see PR #5439).
-#    define PYBIND11_COMPILER_TYPE_LEADING_UNDERSCORE ""
-#else
-#    define PYBIND11_COMPILER_TYPE_LEADING_UNDERSCORE "_"
-#    if defined(__MINGW32__)
-#        define PYBIND11_COMPILER_TYPE "mingw"
-#    elif defined(__CYGWIN__)
-#        define PYBIND11_COMPILER_TYPE "gcc_cygwin"
-#    elif defined(_MSC_VER)
-#        define PYBIND11_COMPILER_TYPE "msvc"
-#    elif defined(__clang__) || defined(__GNUC__)
-#        define PYBIND11_COMPILER_TYPE "system" // Assumed compatible with system compiler.
-#    else
-#        error "Unknown PYBIND11_COMPILER_TYPE: PLEASE REVISE THIS CODE."
-#    endif
-#endif
-
-// PR #5439 made this macro obsolete. However, there are many manipulations of this macro in the
-// wild. Therefore, to maintain backward compatibility, it is kept around.
-#ifndef PYBIND11_STDLIB
-#    define PYBIND11_STDLIB ""
-#endif
-
-#ifndef PYBIND11_BUILD_ABI
-#    if defined(_MSC_VER)                 // See PR #4953.
-#        if defined(_MT) && defined(_DLL) // Corresponding to CL command line options /MD or /MDd.
-#            if (_MSC_VER) / 100 == 19
-#                define PYBIND11_BUILD_ABI "_md_mscver19"
-#            else
-#                error "Unknown major version for MSC_VER: PLEASE REVISE THIS CODE."
-#            endif
-#        elif defined(_MT) // Corresponding to CL command line options /MT or /MTd.
-#            define PYBIND11_BUILD_ABI "_mt_mscver" PYBIND11_PLATFORM_ABI_ID_TOSTRING(_MSC_VER)
-#        else
-#            if (_MSC_VER) / 100 == 19
-#                define PYBIND11_BUILD_ABI "_none_mscver19"
-#            else
-#                error "Unknown major version for MSC_VER: PLEASE REVISE THIS CODE."
-#            endif
-#        endif
-#    elif defined(_LIBCPP_ABI_VERSION) // https://libcxx.llvm.org/DesignDocs/ABIVersioning.html
-#        define PYBIND11_BUILD_ABI                                                                \
-            "_libcpp_abi" PYBIND11_PLATFORM_ABI_ID_TOSTRING(_LIBCPP_ABI_VERSION)
-#    elif defined(_GLIBCXX_USE_CXX11_ABI) // See PR #5439.
-#        if defined(__NVCOMPILER)
-//           // Assume that NVHPC is in the 1xxx ABI family.
-//           // THIS ASSUMPTION IS NOT FUTURE PROOF but apparently the best we can do.
-//           // Please let us know if there is a way to validate the assumption here.
-#        elif !defined(__GXX_ABI_VERSION)
-#            error                                                                                \
-                "Unknown platform or compiler (_GLIBCXX_USE_CXX11_ABI): PLEASE REVISE THIS CODE."
-#        endif
-#        if defined(__GXX_ABI_VERSION) && __GXX_ABI_VERSION < 1002 || __GXX_ABI_VERSION >= 2000
-#            error "Unknown platform or compiler (__GXX_ABI_VERSION): PLEASE REVISE THIS CODE."
-#        endif
-#        define PYBIND11_BUILD_ABI                                                                \
-            "_libstdcpp_gxx_abi_1xxx_use_cxx11_abi_" PYBIND11_PLATFORM_ABI_ID_TOSTRING(           \
-                _GLIBCXX_USE_CXX11_ABI)
-#    else
-#        error "Unknown platform or compiler: PLEASE REVISE THIS CODE."
-#    endif
-#endif
-
-// On MSVC, debug and release builds are not ABI-compatible!
-#if defined(_MSC_VER) && defined(_DEBUG)
-#    define PYBIND11_BUILD_TYPE "_debug"
-#else
-#    define PYBIND11_BUILD_TYPE ""
-#endif
-
-#define PYBIND11_PLATFORM_ABI_ID                                                                  \
-    PYBIND11_COMPILER_TYPE PYBIND11_STDLIB PYBIND11_BUILD_ABI PYBIND11_BUILD_TYPE

deps_src/pybind11/include/pybind11/conduit/wrap_include_python_h.h

@@ -1,72 +0,0 @@
-#pragma once
-
-// Copyright (c) 2024 The pybind Community.
-
-// STRONG REQUIREMENT:
-//   This header is a wrapper around `#include <Python.h>`, therefore it
-//   MUST BE INCLUDED BEFORE ANY STANDARD HEADERS are included.
-// See also:
-//   https://docs.python.org/3/c-api/intro.html#include-files
-// Quoting from there:
-//   Note: Since Python may define some pre-processor definitions which affect
-//   the standard headers on some systems, you must include Python.h before
-//   any standard headers are included.
-
-// To maximize reusability:
-// DO NOT ADD CODE THAT REQUIRES C++ EXCEPTION HANDLING.
-
-// Disable linking to pythonX_d.lib on Windows in debug mode.
-#if defined(_MSC_VER) && defined(_DEBUG) && !defined(Py_DEBUG)
-// Workaround for a VS 2022 issue.
-// See https://github.com/pybind/pybind11/pull/3497 for full context.
-// NOTE: This workaround knowingly violates the Python.h include order
-//       requirement (see above).
-#    include <yvals.h>
-#    if _MSVC_STL_VERSION >= 143
-#        include <crtdefs.h>
-#    endif
-#    define PYBIND11_DEBUG_MARKER
-#    undef _DEBUG
-#endif
-
-// Don't let Python.h #define (v)snprintf as macro because they are implemented
-// properly in Visual Studio since 2015.
-#if defined(_MSC_VER)
-#    define HAVE_SNPRINTF 1
-#endif
-
-#if defined(_MSC_VER)
-#    pragma warning(push)
-#    pragma warning(disable : 4505)
-// C4505: 'PySlice_GetIndicesEx': unreferenced local function has been removed
-#endif
-
-#include <Python.h>
-#include <frameobject.h>
-#include <pythread.h>
-
-#if defined(_MSC_VER)
-#    pragma warning(pop)
-#endif
-
-#if defined(PYBIND11_DEBUG_MARKER)
-#    define _DEBUG 1
-#    undef PYBIND11_DEBUG_MARKER
-#endif
-
-// Python #defines overrides on all sorts of core functions, which
-// tends to wreak havok in C++ codebases that expect these to work
-// like regular functions (potentially with several overloads).
-#if defined(isalnum)
-#    undef isalnum
-#    undef isalpha
-#    undef islower
-#    undef isspace
-#    undef isupper
-#    undef tolower
-#    undef toupper
-#endif
-
-#if defined(copysign)
-#    undef copysign
-#endif

deps_src/pybind11/include/pybind11/critical_section.h

@@ -1,56 +0,0 @@
-// Copyright (c) 2016-2025 The Pybind Development Team.
-// 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"
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-/// This does not do anything if there's a GIL. On free-threaded Python,
-/// it locks an object. This uses the CPython API, which has limits
-class scoped_critical_section {
-public:
-#ifdef Py_GIL_DISABLED
-    explicit scoped_critical_section(handle obj1, handle obj2 = handle{}) {
-        if (obj1) {
-            if (obj2) {
-                PyCriticalSection2_Begin(&section2, obj1.ptr(), obj2.ptr());
-                rank = 2;
-            } else {
-                PyCriticalSection_Begin(&section, obj1.ptr());
-                rank = 1;
-            }
-        } else if (obj2) {
-            PyCriticalSection_Begin(&section, obj2.ptr());
-            rank = 1;
-        }
-    }
-
-    ~scoped_critical_section() {
-        if (rank == 1) {
-            PyCriticalSection_End(&section);
-        } else if (rank == 2) {
-            PyCriticalSection2_End(&section2);
-        }
-    }
-#else
-    explicit scoped_critical_section(handle, handle = handle{}) {};
-    ~scoped_critical_section() = default;
-#endif
-
-    scoped_critical_section(const scoped_critical_section &) = delete;
-    scoped_critical_section &operator=(const scoped_critical_section &) = delete;
-
-private:
-#ifdef Py_GIL_DISABLED
-    int rank{0};
-    union {
-        PyCriticalSection section;
-        PyCriticalSection2 section2;
-    };
-#endif
-};
-
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/detail/class.h

@@ -1,823 +0,0 @@
-/*
-    pybind11/detail/class.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 <pybind11/attr.h>
-#include <pybind11/options.h>
-
-#include "exception_translation.h"
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-#if !defined(PYPY_VERSION)
-#    define PYBIND11_BUILTIN_QUALNAME
-#    define PYBIND11_SET_OLDPY_QUALNAME(obj, nameobj)
-#else
-// In PyPy, we still set __qualname__ so that we can produce reliable function type
-// signatures; in CPython this macro expands to nothing:
-#    define PYBIND11_SET_OLDPY_QUALNAME(obj, nameobj)                                             \
-        setattr((PyObject *) obj, "__qualname__", nameobj)
-#endif
-
-inline std::string get_fully_qualified_tp_name(PyTypeObject *type) {
-#if !defined(PYPY_VERSION)
-    return type->tp_name;
-#else
-    auto module_name = handle((PyObject *) type).attr("__module__").cast<std::string>();
-    if (module_name == PYBIND11_BUILTINS_MODULE)
-        return type->tp_name;
-    else
-        return std::move(module_name) + "." + type->tp_name;
-#endif
-}
-
-inline PyTypeObject *type_incref(PyTypeObject *type) {
-    Py_INCREF(type);
-    return type;
-}
-
-#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);
-}
-
-// Forward declaration to use in `make_static_property_type()`
-inline void enable_dynamic_attributes(PyHeapTypeObject *heap_type);
-
-/** 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();
-#    ifdef PYBIND11_BUILTIN_QUALNAME
-    heap_type->ht_qualname = name_obj.inc_ref().ptr();
-#    endif
-
-    auto *type = &heap_type->ht_type;
-    type->tp_name = name;
-    type->tp_base = type_incref(&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 PY_VERSION_HEX >= 0x030C0000
-    // Since Python-3.12 property-derived types are required to
-    // have dynamic attributes (to set `__doc__`)
-    enable_dynamic_attributes(heap_type);
-#    endif
-
-    if (PyType_Ready(type) < 0) {
-        pybind11_fail("make_static_property_type(): failure in PyType_Ready()!");
-    }
-
-    setattr((PyObject *) type, "__module__", str(PYBIND11_DUMMY_MODULE_NAME));
-    PYBIND11_SET_OLDPY_QUALNAME(type, name_obj);
-
-    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
-
-/** 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);
-
-    // The following assignment combinations are possible:
-    //   1. `Type.static_prop = value`             --> descr_set: `Type.static_prop.__set__(value)`
-    //   2. `Type.static_prop = other_static_prop` --> setattro:  replace existing `static_prop`
-    //   3. `Type.regular_attribute = value`       --> setattro:  regular attribute assignment
-    auto *const static_prop = (PyObject *) get_internals().static_property_type;
-    const auto call_descr_set = (descr != nullptr) && (value != nullptr)
-                                && (PyObject_IsInstance(descr, static_prop) != 0)
-                                && (PyObject_IsInstance(value, static_prop) == 0);
-    if (call_descr_set) {
-        // Call `static_property.__set__()` instead of replacing the `static_property`.
-#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 {
-        // Replace existing attribute.
-        return PyType_Type.tp_setattro(obj, name, value);
-    }
-}
-
-/**
- * Python 3's PyInstanceMethod_Type hides itself via its tp_descr_get, which prevents aliasing
- * methods via cls.attr("m2") = cls.attr("m1"): instead the tp_descr_get returns a plain function,
- * when called on a class, or a PyMethod, when called on an instance.  Override that behaviour here
- * to do a special case bypass for PyInstanceMethod_Types.
- */
-extern "C" inline PyObject *pybind11_meta_getattro(PyObject *obj, PyObject *name) {
-    PyObject *descr = _PyType_Lookup((PyTypeObject *) obj, name);
-    if (descr && PyInstanceMethod_Check(descr)) {
-        Py_INCREF(descr);
-        return descr;
-    }
-    return PyType_Type.tp_getattro(obj, name);
-}
-
-/// metaclass `__call__` function that is used to create all pybind11 objects.
-extern "C" inline PyObject *pybind11_meta_call(PyObject *type, PyObject *args, PyObject *kwargs) {
-
-    // use the default metaclass call to create/initialize the object
-    PyObject *self = PyType_Type.tp_call(type, args, kwargs);
-    if (self == nullptr) {
-        return nullptr;
-    }
-
-    // Ensure that the base __init__ function(s) were called
-    values_and_holders vhs(self);
-    for (const auto &vh : vhs) {
-        if (!vh.holder_constructed() && !vhs.is_redundant_value_and_holder(vh)) {
-            PyErr_Format(PyExc_TypeError,
-                         "%.200s.__init__() must be called when overriding __init__",
-                         get_fully_qualified_tp_name(vh.type->type).c_str());
-            Py_DECREF(self);
-            return nullptr;
-        }
-    }
-
-    return self;
-}
-
-/// Cleanup the type-info for a pybind11-registered type.
-extern "C" inline void pybind11_meta_dealloc(PyObject *obj) {
-    with_internals([obj](internals &internals) {
-        auto *type = (PyTypeObject *) obj;
-
-        // A pybind11-registered type will:
-        // 1) be found in internals.registered_types_py
-        // 2) have exactly one associated `detail::type_info`
-        auto found_type = internals.registered_types_py.find(type);
-        if (found_type != internals.registered_types_py.end() && found_type->second.size() == 1
-            && found_type->second[0]->type == type) {
-
-            auto *tinfo = found_type->second[0];
-            auto tindex = std::type_index(*tinfo->cpptype);
-            internals.direct_conversions.erase(tindex);
-
-            if (tinfo->module_local) {
-                get_local_internals().registered_types_cpp.erase(tindex);
-            } else {
-                internals.registered_types_cpp.erase(tindex);
-            }
-            internals.registered_types_py.erase(tinfo->type);
-
-            // Actually just `std::erase_if`, but that's only available in C++20
-            auto &cache = internals.inactive_override_cache;
-            for (auto it = cache.begin(), last = cache.end(); it != last;) {
-                if (it->first == (PyObject *) tinfo->type) {
-                    it = cache.erase(it);
-                } else {
-                    ++it;
-                }
-            }
-
-            delete tinfo;
-        }
-    });
-
-    PyType_Type.tp_dealloc(obj);
-}
-
-/** 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();
-#ifdef PYBIND11_BUILTIN_QUALNAME
-    heap_type->ht_qualname = name_obj.inc_ref().ptr();
-#endif
-
-    auto *type = &heap_type->ht_type;
-    type->tp_name = name;
-    type->tp_base = type_incref(&PyType_Type);
-    type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
-
-    type->tp_call = pybind11_meta_call;
-
-    type->tp_setattro = pybind11_meta_setattro;
-    type->tp_getattro = pybind11_meta_getattro;
-
-    type->tp_dealloc = pybind11_meta_dealloc;
-
-    if (PyType_Ready(type) < 0) {
-        pybind11_fail("make_default_metaclass(): failure in PyType_Ready()!");
-    }
-
-    setattr((PyObject *) type, "__module__", str(PYBIND11_DUMMY_MODULE_NAME));
-    PYBIND11_SET_OLDPY_QUALNAME(type, name_obj);
-
-    return type;
-}
-
-/// For multiple inheritance types we need to recursively register/deregister base pointers for any
-/// base classes with pointers that are difference from the instance value pointer so that we can
-/// correctly recognize an offset base class pointer. This calls a function with any offset base
-/// ptrs.
-inline void traverse_offset_bases(void *valueptr,
-                                  const detail::type_info *tinfo,
-                                  instance *self,
-                                  bool (*f)(void * /*parentptr*/, instance * /*self*/)) {
-    for (handle h : reinterpret_borrow<tuple>(tinfo->type->tp_bases)) {
-        if (auto *parent_tinfo = get_type_info((PyTypeObject *) h.ptr())) {
-            for (auto &c : parent_tinfo->implicit_casts) {
-                if (c.first == tinfo->cpptype) {
-                    auto *parentptr = c.second(valueptr);
-                    if (parentptr != valueptr) {
-                        f(parentptr, self);
-                    }
-                    traverse_offset_bases(parentptr, parent_tinfo, self, f);
-                    break;
-                }
-            }
-        }
-    }
-}
-
-#ifdef Py_GIL_DISABLED
-inline void enable_try_inc_ref(PyObject *obj) {
-    // TODO: Replace with PyUnstable_Object_EnableTryIncRef when available.
-    // See https://github.com/python/cpython/issues/128844
-    if (_Py_IsImmortal(obj)) {
-        return;
-    }
-    for (;;) {
-        Py_ssize_t shared = _Py_atomic_load_ssize_relaxed(&obj->ob_ref_shared);
-        if ((shared & _Py_REF_SHARED_FLAG_MASK) != 0) {
-            // Nothing to do if it's in WEAKREFS, QUEUED, or MERGED states.
-            return;
-        }
-        if (_Py_atomic_compare_exchange_ssize(
-                &obj->ob_ref_shared, &shared, shared | _Py_REF_MAYBE_WEAKREF)) {
-            return;
-        }
-    }
-}
-#endif
-
-inline bool register_instance_impl(void *ptr, instance *self) {
-#ifdef Py_GIL_DISABLED
-    enable_try_inc_ref(reinterpret_cast<PyObject *>(self));
-#endif
-    with_instance_map(ptr, [&](instance_map &instances) { instances.emplace(ptr, self); });
-    return true; // unused, but gives the same signature as the deregister func
-}
-inline bool deregister_instance_impl(void *ptr, instance *self) {
-    return with_instance_map(ptr, [&](instance_map &instances) {
-        auto range = instances.equal_range(ptr);
-        for (auto it = range.first; it != range.second; ++it) {
-            if (self == it->second) {
-                instances.erase(it);
-                return true;
-            }
-        }
-        return false;
-    });
-}
-
-inline void register_instance(instance *self, void *valptr, const type_info *tinfo) {
-    register_instance_impl(valptr, self);
-    if (!tinfo->simple_ancestors) {
-        traverse_offset_bases(valptr, tinfo, self, register_instance_impl);
-    }
-}
-
-inline bool deregister_instance(instance *self, void *valptr, const type_info *tinfo) {
-    bool ret = deregister_instance_impl(valptr, self);
-    if (!tinfo->simple_ancestors) {
-        traverse_offset_bases(valptr, tinfo, self, deregister_instance_impl);
-    }
-    return ret;
-}
-
-/// Instance creation function for all pybind11 types. It allocates the internal instance layout
-/// for holding C++ objects and holders.  Allocation is done lazily (the first time the instance is
-/// cast to a reference or pointer), and initialization is done by an `__init__` function.
-inline PyObject *make_new_instance(PyTypeObject *type) {
-#if defined(PYPY_VERSION)
-    // PyPy gets tp_basicsize wrong (issue 2482) under multiple inheritance when the first
-    // inherited object is a plain Python type (i.e. not derived from an extension type).  Fix it.
-    ssize_t instance_size = static_cast<ssize_t>(sizeof(instance));
-    if (type->tp_basicsize < instance_size) {
-        type->tp_basicsize = instance_size;
-    }
-#endif
-    PyObject *self = type->tp_alloc(type, 0);
-    auto *inst = reinterpret_cast<instance *>(self);
-    // Allocate the value/holder internals:
-    inst->allocate_layout();
-
-    return self;
-}
-
-/// 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 *) {
-    return make_new_instance(type);
-}
-
-/// 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 = get_fully_qualified_tp_name(type) + ": No constructor defined!";
-    set_error(PyExc_TypeError, msg.c_str());
-    return -1;
-}
-
-inline void add_patient(PyObject *nurse, PyObject *patient) {
-    auto *instance = reinterpret_cast<detail::instance *>(nurse);
-    instance->has_patients = true;
-    Py_INCREF(patient);
-
-    with_internals([&](internals &internals) { internals.patients[nurse].push_back(patient); });
-}
-
-inline void clear_patients(PyObject *self) {
-    auto *instance = reinterpret_cast<detail::instance *>(self);
-    std::vector<PyObject *> patients;
-
-    with_internals([&](internals &internals) {
-        auto pos = internals.patients.find(self);
-
-        if (pos == internals.patients.end()) {
-            pybind11_fail(
-                "FATAL: Internal consistency check failed: Invalid clear_patients() call.");
-        }
-
-        // Clearing the patients can cause more Python code to run, which
-        // can invalidate the iterator. Extract the vector of patients
-        // from the unordered_map first.
-        patients = std::move(pos->second);
-        internals.patients.erase(pos);
-    });
-
-    instance->has_patients = false;
-    for (PyObject *&patient : patients) {
-        Py_CLEAR(patient);
-    }
-}
-
-/// Clears all internal data from the instance and removes it from registered instances in
-/// preparation for deallocation.
-inline void clear_instance(PyObject *self) {
-    auto *instance = reinterpret_cast<detail::instance *>(self);
-
-    // Deallocate any values/holders, if present:
-    for (auto &v_h : values_and_holders(instance)) {
-        if (v_h) {
-
-            // We have to deregister before we call dealloc because, for virtual MI types, we still
-            // need to be able to get the parent pointers.
-            if (v_h.instance_registered()
-                && !deregister_instance(instance, v_h.value_ptr(), v_h.type)) {
-                pybind11_fail(
-                    "pybind11_object_dealloc(): Tried to deallocate unregistered instance!");
-            }
-
-            if (instance->owned || v_h.holder_constructed()) {
-                v_h.type->dealloc(v_h);
-            }
-        } else if (v_h.holder_constructed()) {
-            v_h.type->dealloc(v_h); // Disowned instance.
-        }
-    }
-    // Deallocate the value/holder layout internals:
-    instance->deallocate_layout();
-
-    if (instance->weakrefs) {
-        PyObject_ClearWeakRefs(self);
-    }
-
-    PyObject **dict_ptr = _PyObject_GetDictPtr(self);
-    if (dict_ptr) {
-        Py_CLEAR(*dict_ptr);
-    }
-
-    if (instance->has_patients) {
-        clear_patients(self);
-    }
-}
-
-/// 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 *type = Py_TYPE(self);
-
-    // If this is a GC tracked object, untrack it first
-    // Note that the track call is implicitly done by the
-    // default tp_alloc, which we never override.
-    if (PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC) != 0) {
-        PyObject_GC_UnTrack(self);
-    }
-
-    clear_instance(self);
-
-    type->tp_free(self);
-
-    // This was not needed before Python 3.8 (Python issue 35810)
-    // https://github.com/pybind/pybind11/issues/1946
-    Py_DECREF(type);
-}
-
-PYBIND11_WARNING_PUSH
-PYBIND11_WARNING_DISABLE_GCC("-Wredundant-decls")
-
-std::string error_string();
-
-PYBIND11_WARNING_POP
-
-/** Create the type which can be used as a common base for all classes.  This is
-    needed in order to satisfy Python's requirements for multiple inheritance.
-    Return value: New reference. */
-inline PyObject *make_object_base_type(PyTypeObject *metaclass) {
-    constexpr auto *name = "pybind11_object";
-    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 *) 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();
-#ifdef PYBIND11_BUILTIN_QUALNAME
-    heap_type->ht_qualname = name_obj.inc_ref().ptr();
-#endif
-
-    auto *type = &heap_type->ht_type;
-    type->tp_name = name;
-    type->tp_base = type_incref(&PyBaseObject_Type);
-    type->tp_basicsize = static_cast<ssize_t>(sizeof(instance));
-    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, weakrefs);
-
-    if (PyType_Ready(type) < 0) {
-        pybind11_fail("PyType_Ready failed in make_object_base_type(): " + error_string());
-    }
-
-    setattr((PyObject *) type, "__module__", str(PYBIND11_DUMMY_MODULE_NAME));
-    PYBIND11_SET_OLDPY_QUALNAME(type, name_obj);
-
-    assert(!PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC));
-    return (PyObject *) heap_type;
-}
-
-/// dynamic_attr: Allow the garbage collector to traverse the internal instance `__dict__`.
-extern "C" inline int pybind11_traverse(PyObject *self, visitproc visit, void *arg) {
-#if PY_VERSION_HEX >= 0x030D0000
-    PyObject_VisitManagedDict(self, visit, arg);
-#else
-    PyObject *&dict = *_PyObject_GetDictPtr(self);
-    Py_VISIT(dict);
-#endif
-// https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_traverse
-#if PY_VERSION_HEX >= 0x03090000
-    Py_VISIT(Py_TYPE(self));
-#endif
-    return 0;
-}
-
-/// dynamic_attr: Allow the GC to clear the dictionary.
-extern "C" inline int pybind11_clear(PyObject *self) {
-#if PY_VERSION_HEX >= 0x030D0000
-    PyObject_ClearManagedDict(self);
-#else
-    PyObject *&dict = *_PyObject_GetDictPtr(self);
-    Py_CLEAR(dict);
-#endif
-    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;
-    type->tp_flags |= Py_TPFLAGS_HAVE_GC;
-#ifdef PYBIND11_BACKWARD_COMPATIBILITY_TP_DICTOFFSET
-    type->tp_dictoffset = type->tp_basicsize;           // place dict at the end
-    type->tp_basicsize += (ssize_t) sizeof(PyObject *); // and allocate enough space for it
-#else
-    type->tp_flags |= Py_TPFLAGS_MANAGED_DICT;
-#endif
-    type->tp_traverse = pybind11_traverse;
-    type->tp_clear = pybind11_clear;
-
-    static PyGetSetDef getset[]
-        = {{"__dict__", PyObject_GenericGetDict, PyObject_GenericSetDict, 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) {
-    // Look for a `get_buffer` implementation in this type's info or any bases (following MRO).
-    type_info *tinfo = nullptr;
-    for (auto type : reinterpret_borrow<tuple>(Py_TYPE(obj)->tp_mro)) {
-        tinfo = get_type_info((PyTypeObject *) type.ptr());
-        if (tinfo && tinfo->get_buffer) {
-            break;
-        }
-    }
-    if (view == nullptr || !tinfo || !tinfo->get_buffer) {
-        if (view) {
-            view->obj = nullptr;
-        }
-        set_error(PyExc_BufferError, "pybind11_getbuffer(): Internal error");
-        return -1;
-    }
-    std::memset(view, 0, sizeof(Py_buffer));
-    std::unique_ptr<buffer_info> info = nullptr;
-    try {
-        info.reset(tinfo->get_buffer(obj, tinfo->get_buffer_data));
-    } catch (...) {
-        try_translate_exceptions();
-        raise_from(PyExc_BufferError, "Error getting buffer");
-        return -1;
-    }
-    if (info == nullptr) {
-        pybind11_fail("FATAL UNEXPECTED SITUATION: tinfo->get_buffer() returned nullptr.");
-    }
-
-    if ((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE && info->readonly) {
-        // view->obj = nullptr;  // Was just memset to 0, so not necessary
-        set_error(PyExc_BufferError, "Writable buffer requested for readonly storage");
-        return -1;
-    }
-
-    // Fill in all the information, and then downgrade as requested by the caller, or raise an
-    // error if that's not possible.
-    view->itemsize = info->itemsize;
-    view->len = view->itemsize;
-    for (auto s : info->shape) {
-        view->len *= s;
-    }
-    view->ndim = static_cast<int>(info->ndim);
-    view->shape = info->shape.data();
-    view->strides = info->strides.data();
-    view->readonly = static_cast<int>(info->readonly);
-    if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT) {
-        view->format = const_cast<char *>(info->format.c_str());
-    }
-
-    // Note, all contiguity flags imply PyBUF_STRIDES and lower.
-    if ((flags & PyBUF_C_CONTIGUOUS) == PyBUF_C_CONTIGUOUS) {
-        if (PyBuffer_IsContiguous(view, 'C') == 0) {
-            std::memset(view, 0, sizeof(Py_buffer));
-            set_error(PyExc_BufferError,
-                      "C-contiguous buffer requested for discontiguous storage");
-            return -1;
-        }
-    } else if ((flags & PyBUF_F_CONTIGUOUS) == PyBUF_F_CONTIGUOUS) {
-        if (PyBuffer_IsContiguous(view, 'F') == 0) {
-            std::memset(view, 0, sizeof(Py_buffer));
-            set_error(PyExc_BufferError,
-                      "Fortran-contiguous buffer requested for discontiguous storage");
-            return -1;
-        }
-    } else if ((flags & PyBUF_ANY_CONTIGUOUS) == PyBUF_ANY_CONTIGUOUS) {
-        if (PyBuffer_IsContiguous(view, 'A') == 0) {
-            std::memset(view, 0, sizeof(Py_buffer));
-            set_error(PyExc_BufferError, "Contiguous buffer requested for discontiguous storage");
-            return -1;
-        }
-
-    } else if ((flags & PyBUF_STRIDES) != PyBUF_STRIDES) {
-        // If no strides are requested, the buffer must be C-contiguous.
-        // https://docs.python.org/3/c-api/buffer.html#contiguity-requests
-        if (PyBuffer_IsContiguous(view, 'C') == 0) {
-            std::memset(view, 0, sizeof(Py_buffer));
-            set_error(PyExc_BufferError,
-                      "C-contiguous buffer requested for discontiguous storage");
-            return -1;
-        }
-
-        view->strides = nullptr;
-
-        // Since this is a contiguous buffer, it can also pretend to be 1D.
-        if ((flags & PyBUF_ND) != PyBUF_ND) {
-            view->shape = nullptr;
-            view->ndim = 0;
-        }
-    }
-
-    // Set these after all checks so they don't leak out into the caller, and can be automatically
-    // cleaned up on error.
-    view->buf = info->ptr;
-    view->internal = info.release();
-    view->obj = obj;
-    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;
-
-    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));
-
-    auto qualname = name;
-    if (rec.scope && !PyModule_Check(rec.scope.ptr()) && hasattr(rec.scope, "__qualname__")) {
-        qualname = reinterpret_steal<object>(
-            PyUnicode_FromFormat("%U.%U", rec.scope.attr("__qualname__").ptr(), name.ptr()));
-    }
-
-    object module_ = get_module_name_if_available(rec.scope);
-    const auto *full_name = c_str(
-#if !defined(PYPY_VERSION)
-        module_ ? str(module_).cast<std::string>() + "." + rec.name :
-#endif
-                rec.name);
-
-    char *tp_doc = nullptr;
-    if (rec.doc && options::show_user_defined_docstrings()) {
-        /* Allocate memory for docstring (Python will free this later on) */
-        size_t size = std::strlen(rec.doc) + 1;
-#if PY_VERSION_HEX >= 0x030D0000
-        tp_doc = (char *) PyMem_MALLOC(size);
-#else
-        tp_doc = (char *) PyObject_MALLOC(size);
-#endif
-        std::memcpy((void *) tp_doc, rec.doc, size);
-    }
-
-    auto &internals = get_internals();
-    auto bases = tuple(rec.bases);
-    auto *base = (bases.empty()) ? internals.instance_base : 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();
-#ifdef PYBIND11_BUILTIN_QUALNAME
-    heap_type->ht_qualname = qualname.inc_ref().ptr();
-#endif
-
-    auto *type = &heap_type->ht_type;
-    type->tp_name = full_name;
-    type->tp_doc = tp_doc;
-    type->tp_base = type_incref((PyTypeObject *) base);
-    type->tp_basicsize = static_cast<ssize_t>(sizeof(instance));
-    if (!bases.empty()) {
-        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;
-    type->tp_as_async = &heap_type->as_async;
-
-    /* Flags */
-    type->tp_flags |= Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE;
-    if (!rec.is_final) {
-        type->tp_flags |= Py_TPFLAGS_BASETYPE;
-    }
-
-    if (rec.dynamic_attr) {
-        enable_dynamic_attributes(heap_type);
-    }
-
-    if (rec.buffer_protocol) {
-        enable_buffer_protocol(heap_type);
-    }
-
-    if (rec.custom_type_setup_callback) {
-        rec.custom_type_setup_callback(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));
-
-    /* Register type with the parent scope */
-    if (rec.scope) {
-        setattr(rec.scope, rec.name, (PyObject *) type);
-    } else {
-        Py_INCREF(type); // Keep it alive forever (reference leak)
-    }
-
-    if (module_) { // Needed by pydoc
-        setattr((PyObject *) type, "__module__", module_);
-    }
-
-    PYBIND11_SET_OLDPY_QUALNAME(type, qualname);
-
-    return (PyObject *) type;
-}
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/detail/cpp_conduit.h

@@ -1,75 +0,0 @@
-// Copyright (c) 2024 The pybind Community.
-
-#pragma once
-
-#include <pybind11/pytypes.h>
-
-#include "common.h"
-#include "internals.h"
-
-#include <typeinfo>
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-// Forward declaration needed here: Refactoring opportunity.
-extern "C" inline PyObject *pybind11_object_new(PyTypeObject *type, PyObject *, PyObject *);
-
-inline bool type_is_managed_by_our_internals(PyTypeObject *type_obj) {
-#if defined(PYPY_VERSION)
-    auto &internals = get_internals();
-    return bool(internals.registered_types_py.find(type_obj)
-                != internals.registered_types_py.end());
-#else
-    return bool(type_obj->tp_new == pybind11_object_new);
-#endif
-}
-
-inline bool is_instance_method_of_type(PyTypeObject *type_obj, PyObject *attr_name) {
-    PyObject *descr = _PyType_Lookup(type_obj, attr_name);
-    return bool((descr != nullptr) && PyInstanceMethod_Check(descr));
-}
-
-inline object try_get_cpp_conduit_method(PyObject *obj) {
-    if (PyType_Check(obj)) {
-        return object();
-    }
-    PyTypeObject *type_obj = Py_TYPE(obj);
-    str attr_name("_pybind11_conduit_v1_");
-    bool assumed_to_be_callable = false;
-    if (type_is_managed_by_our_internals(type_obj)) {
-        if (!is_instance_method_of_type(type_obj, attr_name.ptr())) {
-            return object();
-        }
-        assumed_to_be_callable = true;
-    }
-    PyObject *method = PyObject_GetAttr(obj, attr_name.ptr());
-    if (method == nullptr) {
-        PyErr_Clear();
-        return object();
-    }
-    if (!assumed_to_be_callable && PyCallable_Check(method) == 0) {
-        Py_DECREF(method);
-        return object();
-    }
-    return reinterpret_steal<object>(method);
-}
-
-inline void *try_raw_pointer_ephemeral_from_cpp_conduit(handle src,
-                                                        const std::type_info *cpp_type_info) {
-    object method = try_get_cpp_conduit_method(src.ptr());
-    if (method) {
-        capsule cpp_type_info_capsule(const_cast<void *>(static_cast<const void *>(cpp_type_info)),
-                                      typeid(std::type_info).name());
-        object cpp_conduit = method(bytes(PYBIND11_PLATFORM_ABI_ID),
-                                    cpp_type_info_capsule,
-                                    bytes("raw_pointer_ephemeral"));
-        if (isinstance<capsule>(cpp_conduit)) {
-            return reinterpret_borrow<capsule>(cpp_conduit).get_pointer();
-        }
-    }
-    return nullptr;
-}
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/detail/descr.h

@@ -1,226 +0,0 @@
-/*
-    pybind11/detail/descr.h: Helper type for concatenating type signatures at compile time
-
-    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"
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-#if !defined(_MSC_VER)
-#    define PYBIND11_DESCR_CONSTEXPR static constexpr
-#else
-#    define PYBIND11_DESCR_CONSTEXPR const
-#endif
-
-/* Concatenate type signatures at compile time */
-template <size_t N, typename... Ts>
-struct descr {
-    char text[N + 1]{'\0'};
-
-    constexpr descr() = default;
-    // NOLINTNEXTLINE(google-explicit-constructor)
-    constexpr descr(char const (&s)[N + 1]) : descr(s, make_index_sequence<N>()) {}
-
-    template <size_t... Is>
-    constexpr descr(char const (&s)[N + 1], index_sequence<Is...>) : text{s[Is]..., '\0'} {}
-
-    template <typename... Chars>
-    // NOLINTNEXTLINE(google-explicit-constructor)
-    constexpr descr(char c, Chars... cs) : text{c, static_cast<char>(cs)..., '\0'} {}
-
-    static constexpr std::array<const std::type_info *, sizeof...(Ts) + 1> types() {
-        return {{&typeid(Ts)..., nullptr}};
-    }
-};
-
-template <size_t N1, size_t N2, typename... Ts1, typename... Ts2, size_t... Is1, size_t... Is2>
-constexpr descr<N1 + N2, Ts1..., Ts2...> plus_impl(const descr<N1, Ts1...> &a,
-                                                   const descr<N2, Ts2...> &b,
-                                                   index_sequence<Is1...>,
-                                                   index_sequence<Is2...>) {
-    PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(b);
-    return {a.text[Is1]..., b.text[Is2]...};
-}
-
-template <size_t N1, size_t N2, typename... Ts1, typename... Ts2>
-constexpr descr<N1 + N2, Ts1..., Ts2...> operator+(const descr<N1, Ts1...> &a,
-                                                   const descr<N2, Ts2...> &b) {
-    return plus_impl(a, b, make_index_sequence<N1>(), make_index_sequence<N2>());
-}
-
-template <size_t N>
-constexpr descr<N - 1> const_name(char const (&text)[N]) {
-    return descr<N - 1>(text);
-}
-constexpr descr<0> const_name(char const (&)[1]) { return {}; }
-
-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...> {
-    // WARNING: This only works with C++17 or higher.
-    static constexpr auto digits = descr<sizeof...(Digits)>(('0' + Digits)...);
-};
-
-// Ternary description (like std::conditional)
-template <bool B, size_t N1, size_t N2>
-constexpr enable_if_t<B, descr<N1 - 1>> const_name(char const (&text1)[N1], char const (&)[N2]) {
-    return const_name(text1);
-}
-template <bool B, size_t N1, size_t N2>
-constexpr enable_if_t<!B, descr<N2 - 1>> const_name(char const (&)[N1], char const (&text2)[N2]) {
-    return const_name(text2);
-}
-
-template <bool B, typename T1, typename T2>
-constexpr enable_if_t<B, T1> const_name(const T1 &d, const T2 &) {
-    return d;
-}
-template <bool B, typename T1, typename T2>
-constexpr enable_if_t<!B, T2> const_name(const T1 &, const T2 &d) {
-    return d;
-}
-
-template <size_t Size>
-auto constexpr const_name() -> remove_cv_t<decltype(int_to_str<Size / 10, Size % 10>::digits)> {
-    return int_to_str<Size / 10, Size % 10>::digits;
-}
-
-template <typename Type>
-constexpr descr<1, Type> const_name() {
-    return {'%'};
-}
-
-// Use a different name based on whether the parameter is used as input or output
-template <size_t N1, size_t N2>
-constexpr descr<N1 + N2 + 1> io_name(char const (&text1)[N1], char const (&text2)[N2]) {
-    return const_name("@") + const_name(text1) + const_name("@") + const_name(text2)
-           + const_name("@");
-}
-
-// Ternary description for io_name (like the numeric type_caster)
-template <bool B, size_t N1, size_t N2, size_t N3, size_t N4>
-constexpr enable_if_t<B, descr<N1 + N2 + 1>>
-io_name(char const (&text1)[N1], char const (&text2)[N2], char const (&)[N3], char const (&)[N4]) {
-    return io_name(text1, text2);
-}
-
-template <bool B, size_t N1, size_t N2, size_t N3, size_t N4>
-constexpr enable_if_t<!B, descr<N3 + N4 + 1>>
-io_name(char const (&)[N1], char const (&)[N2], char const (&text3)[N3], char const (&text4)[N4]) {
-    return io_name(text3, text4);
-}
-
-// If "_" is defined as a macro, py::detail::_ cannot be provided.
-// It is therefore best to use py::detail::const_name universally.
-// This block is for backward compatibility only.
-// (The const_name code is repeated to avoid introducing a "_" #define ourselves.)
-#ifndef _
-#    define PYBIND11_DETAIL_UNDERSCORE_BACKWARD_COMPATIBILITY
-template <size_t N>
-constexpr descr<N - 1> _(char const (&text)[N]) {
-    return const_name<N>(text);
-}
-template <bool B, size_t N1, size_t N2>
-constexpr enable_if_t<B, descr<N1 - 1>> _(char const (&text1)[N1], char const (&text2)[N2]) {
-    return const_name<B, N1, N2>(text1, text2);
-}
-template <bool B, size_t N1, size_t N2>
-constexpr enable_if_t<!B, descr<N2 - 1>> _(char const (&text1)[N1], char const (&text2)[N2]) {
-    return const_name<B, N1, N2>(text1, text2);
-}
-template <bool B, typename T1, typename T2>
-constexpr enable_if_t<B, T1> _(const T1 &d1, const T2 &d2) {
-    return const_name<B, T1, T2>(d1, d2);
-}
-template <bool B, typename T1, typename T2>
-constexpr enable_if_t<!B, T2> _(const T1 &d1, const T2 &d2) {
-    return const_name<B, T1, T2>(d1, d2);
-}
-
-template <size_t Size>
-auto constexpr _() -> remove_cv_t<decltype(int_to_str<Size / 10, Size % 10>::digits)> {
-    return const_name<Size>();
-}
-template <typename Type>
-constexpr descr<1, Type> _() {
-    return const_name<Type>();
-}
-#endif // #ifndef _
-
-constexpr descr<0> concat() { return {}; }
-constexpr descr<0> union_concat() { return {}; }
-
-template <size_t N, typename... Ts>
-constexpr descr<N, Ts...> concat(const descr<N, Ts...> &descr) {
-    return descr;
-}
-
-template <size_t N, typename... Ts>
-constexpr descr<N, Ts...> union_concat(const descr<N, Ts...> &descr) {
-    return descr;
-}
-
-template <size_t N1, size_t N2, typename... Ts1, typename... Ts2>
-constexpr descr<N1 + N2 + 3, Ts1..., Ts2...> operator|(const descr<N1, Ts1...> &a,
-                                                       const descr<N2, Ts2...> &b) {
-    return a + const_name(" | ") + b;
-}
-
-#ifdef __cpp_fold_expressions
-template <size_t N1, size_t N2, typename... Ts1, typename... Ts2>
-constexpr descr<N1 + N2 + 2, Ts1..., Ts2...> operator,(const descr<N1, Ts1...> &a,
-                                                       const descr<N2, Ts2...> &b) {
-    return a + const_name(", ") + b;
-}
-
-template <size_t N, typename... Ts, typename... Args>
-constexpr auto concat(const descr<N, Ts...> &d, const Args &...args) {
-    return (d, ..., args);
-}
-
-template <size_t N, typename... Ts, typename... Args>
-constexpr auto union_concat(const descr<N, Ts...> &d, const Args &...args) {
-    return (d | ... | args);
-}
-
-#else
-template <size_t N, typename... Ts, typename... Args>
-constexpr auto concat(const descr<N, Ts...> &d, const Args &...args)
-    -> decltype(std::declval<descr<N + 2, Ts...>>() + concat(args...)) {
-    return d + const_name(", ") + concat(args...);
-}
-
-template <size_t N, typename... Ts, typename... Args>
-constexpr auto union_concat(const descr<N, Ts...> &d, const Args &...args)
-    -> decltype(std::declval<descr<N + 3, Ts...>>() + union_concat(args...)) {
-    return d + const_name(" | ") + union_concat(args...);
-}
-
-#endif
-
-template <size_t N, typename... Ts>
-constexpr descr<N + 2, Ts...> type_descr(const descr<N, Ts...> &descr) {
-    return const_name("{") + descr + const_name("}");
-}
-
-template <size_t N, typename... Ts>
-constexpr descr<N + 4, Ts...> arg_descr(const descr<N, Ts...> &descr) {
-    return const_name("@^") + descr + const_name("@!");
-}
-
-template <size_t N, typename... Ts>
-constexpr descr<N + 4, Ts...> return_descr(const descr<N, Ts...> &descr) {
-    return const_name("@$") + descr + const_name("@!");
-}
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/detail/dynamic_raw_ptr_cast_if_possible.h

@@ -1,39 +0,0 @@
-// Copyright (c) 2021 The Pybind Development Team.
-// 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 <type_traits>
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-template <typename To, typename From, typename SFINAE = void>
-struct dynamic_raw_ptr_cast_is_possible : std::false_type {};
-
-template <typename To, typename From>
-struct dynamic_raw_ptr_cast_is_possible<
-    To,
-    From,
-    detail::enable_if_t<!std::is_same<To, void>::value && std::is_polymorphic<From>::value>>
-    : std::true_type {};
-
-template <typename To,
-          typename From,
-          detail::enable_if_t<!dynamic_raw_ptr_cast_is_possible<To, From>::value, int> = 0>
-To *dynamic_raw_ptr_cast_if_possible(From * /*ptr*/) {
-    return nullptr;
-}
-
-template <typename To,
-          typename From,
-          detail::enable_if_t<dynamic_raw_ptr_cast_is_possible<To, From>::value, int> = 0>
-To *dynamic_raw_ptr_cast_if_possible(From *ptr) {
-    return dynamic_cast<To *>(ptr);
-}
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/detail/exception_translation.h

@@ -1,71 +0,0 @@
-/*
-    pybind11/detail/exception_translation.h: means to translate C++ exceptions to Python exceptions
-
-    Copyright (c) 2024 The Pybind Development Team.
-
-    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 "internals.h"
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-// Apply all the extensions translators from a list
-// Return true if one of the translators completed without raising an exception
-// itself. Return of false indicates that if there are other translators
-// available, they should be tried.
-inline bool apply_exception_translators(std::forward_list<ExceptionTranslator> &translators) {
-    auto last_exception = std::current_exception();
-
-    for (auto &translator : translators) {
-        try {
-            translator(last_exception);
-            return true;
-        } catch (...) {
-            last_exception = std::current_exception();
-        }
-    }
-    return false;
-}
-
-inline void try_translate_exceptions() {
-    /* When an exception is caught, give each registered exception
-        translator a chance to translate it to a Python exception. First
-        all module-local translators will be tried in reverse order of
-        registration. If none of the module-locale translators handle
-        the exception (or there are no module-locale translators) then
-        the global translators will be tried, also in reverse order of
-        registration.
-
-        A translator may choose to do one of the following:
-
-        - catch the exception and call py::set_error()
-            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.
-        */
-
-    bool handled = with_exception_translators(
-        [&](std::forward_list<ExceptionTranslator> &exception_translators,
-            std::forward_list<ExceptionTranslator> &local_exception_translators) {
-            if (detail::apply_exception_translators(local_exception_translators)) {
-                return true;
-            }
-            if (detail::apply_exception_translators(exception_translators)) {
-                return true;
-            }
-            return false;
-        });
-
-    if (!handled) {
-        set_error(PyExc_SystemError, "Exception escaped from default exception translator!");
-    }
-}
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/detail/function_record_pyobject.h

@@ -1,191 +0,0 @@
-// Copyright (c) 2024-2025 The Pybind Development Team.
-// All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-// For background see the description of PR google/pybind11clif#30099.
-
-#pragma once
-
-#include <pybind11/attr.h>
-#include <pybind11/conduit/pybind11_platform_abi_id.h>
-#include <pybind11/pytypes.h>
-
-#include "common.h"
-
-#include <cstring>
-#include <utility>
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-struct function_record_PyObject {
-    PyObject_HEAD
-    function_record *cpp_func_rec;
-};
-
-PYBIND11_NAMESPACE_BEGIN(function_record_PyTypeObject_methods)
-
-PyObject *tp_new_impl(PyTypeObject *type, PyObject *args, PyObject *kwds);
-PyObject *tp_alloc_impl(PyTypeObject *type, Py_ssize_t nitems);
-int tp_init_impl(PyObject *self, PyObject *args, PyObject *kwds);
-void tp_dealloc_impl(PyObject *self);
-void tp_free_impl(void *self);
-
-static PyObject *reduce_ex_impl(PyObject *self, PyObject *, PyObject *);
-
-static PyMethodDef tp_methods_impl[]
-    = {{"__reduce_ex__",
-        // reduce_ex_impl is a PyCFunctionWithKeywords, but PyMethodDef
-        // requires a PyCFunction. The cast through void* is safe and
-        // idiomatic with METH_KEYWORDS, and it successfully sidesteps
-        // unhelpful compiler warnings.
-        // NOLINTNEXTLINE(bugprone-casting-through-void)
-        reinterpret_cast<PyCFunction>(reinterpret_cast<void *>(reduce_ex_impl)),
-        METH_VARARGS | METH_KEYWORDS,
-        nullptr},
-       {nullptr, nullptr, 0, nullptr}};
-
-// Python 3.12+ emits a DeprecationWarning for heap types whose tp_name does
-// not contain a dot ('.') and that lack a __module__ attribute. For pybind11's
-// internal function_record type, we do not have an actual module object to
-// attach, so we cannot use PyType_FromModuleAndSpec (introduced in Python 3.9)
-// to set __module__ automatically.
-//
-// As a workaround, we define a "qualified" type name that includes a dummy
-// module name (PYBIND11_DUMMY_MODULE_NAME). This is non‑idiomatic but avoids
-// the deprecation warning, and results in reprs like
-//
-//     <class 'pybind11_builtins.pybind11_detail_function_record_...'>
-//
-// even though no real pybind11_builtins module exists. If pybind11 gains an
-// actual module object in the future, this code should switch to
-// PyType_FromModuleAndSpec for Python 3.9+ and drop the dummy module
-// workaround.
-//
-// Note that this name is versioned.
-#define PYBIND11_DETAIL_FUNCTION_RECORD_TP_PLAINNAME                                              \
-    "pybind11_detail_function_record_" PYBIND11_DETAIL_FUNCTION_RECORD_ABI_ID                     \
-    "_" PYBIND11_PLATFORM_ABI_ID
-constexpr char tp_plainname_impl[] = PYBIND11_DETAIL_FUNCTION_RECORD_TP_PLAINNAME;
-constexpr char tp_qualname_impl[]
-    = PYBIND11_DUMMY_MODULE_NAME "." PYBIND11_DETAIL_FUNCTION_RECORD_TP_PLAINNAME;
-
-PYBIND11_NAMESPACE_END(function_record_PyTypeObject_methods)
-
-static PyType_Slot function_record_PyType_Slots[] = {
-    {Py_tp_dealloc,
-     reinterpret_cast<void *>(function_record_PyTypeObject_methods::tp_dealloc_impl)},
-    {Py_tp_methods,
-     reinterpret_cast<void *>(function_record_PyTypeObject_methods::tp_methods_impl)},
-    {Py_tp_init, reinterpret_cast<void *>(function_record_PyTypeObject_methods::tp_init_impl)},
-    {Py_tp_alloc, reinterpret_cast<void *>(function_record_PyTypeObject_methods::tp_alloc_impl)},
-    {Py_tp_new, reinterpret_cast<void *>(function_record_PyTypeObject_methods::tp_new_impl)},
-    {Py_tp_free, reinterpret_cast<void *>(function_record_PyTypeObject_methods::tp_free_impl)},
-    {0, nullptr}};
-
-static PyType_Spec function_record_PyType_Spec
-    = {function_record_PyTypeObject_methods::tp_qualname_impl,
-       sizeof(function_record_PyObject),
-       0,
-       Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE,
-       function_record_PyType_Slots};
-
-inline PyTypeObject *get_function_record_PyTypeObject() {
-    PyTypeObject *&py_type_obj = detail::get_local_internals().function_record_py_type;
-    if (!py_type_obj) {
-        PyObject *py_obj = PyType_FromSpec(&function_record_PyType_Spec);
-        if (py_obj == nullptr) {
-            throw error_already_set();
-        }
-        py_type_obj = reinterpret_cast<PyTypeObject *>(py_obj);
-    }
-    return py_type_obj;
-}
-
-inline bool is_function_record_PyObject(PyObject *obj) {
-    if (PyType_Check(obj) != 0) {
-        return false;
-    }
-    PyTypeObject *obj_type = Py_TYPE(obj);
-
-    PyTypeObject *frtype = get_function_record_PyTypeObject();
-
-    // Fast path (pointer comparison).
-    if (obj_type == frtype) {
-        return true;
-    }
-    // This works across extension modules. Note that tp_name is versioned.
-    if (strcmp(obj_type->tp_name, function_record_PyTypeObject_methods::tp_qualname_impl) == 0
-        || strcmp(obj_type->tp_name, function_record_PyTypeObject_methods::tp_plainname_impl)
-               == 0) {
-        return true;
-    }
-    return false;
-}
-
-inline function_record *function_record_ptr_from_PyObject(PyObject *obj) {
-    if (is_function_record_PyObject(obj)) {
-        return ((detail::function_record_PyObject *) obj)->cpp_func_rec;
-    }
-    return nullptr;
-}
-
-inline object function_record_PyObject_New() {
-    auto *py_func_rec = PyObject_New(function_record_PyObject, get_function_record_PyTypeObject());
-    if (py_func_rec == nullptr) {
-        throw error_already_set();
-    }
-    py_func_rec->cpp_func_rec = nullptr; // For clarity/purity. Redundant in practice.
-    return reinterpret_steal<object>((PyObject *) py_func_rec);
-}
-
-PYBIND11_NAMESPACE_BEGIN(function_record_PyTypeObject_methods)
-
-// Guard against accidents & oversights, in particular when porting to future Python versions.
-inline PyObject *tp_new_impl(PyTypeObject *, PyObject *, PyObject *) {
-    pybind11_fail("UNEXPECTED CALL OF function_record_PyTypeObject_methods::tp_new_impl");
-    // return nullptr; // Unreachable.
-}
-
-inline PyObject *tp_alloc_impl(PyTypeObject *, Py_ssize_t) {
-    pybind11_fail("UNEXPECTED CALL OF function_record_PyTypeObject_methods::tp_alloc_impl");
-    // return nullptr; // Unreachable.
-}
-
-inline int tp_init_impl(PyObject *, PyObject *, PyObject *) {
-    pybind11_fail("UNEXPECTED CALL OF function_record_PyTypeObject_methods::tp_init_impl");
-    // return -1; // Unreachable.
-}
-
-inline void tp_free_impl(void *) {
-    pybind11_fail("UNEXPECTED CALL OF function_record_PyTypeObject_methods::tp_free_impl");
-}
-
-inline PyObject *reduce_ex_impl(PyObject *self, PyObject *, PyObject *) {
-    // Deliberately ignoring the arguments for simplicity (expected is `protocol: int`).
-    const function_record *rec = function_record_ptr_from_PyObject(self);
-    if (rec == nullptr) {
-        pybind11_fail(
-            "FATAL: function_record_PyTypeObject reduce_ex_impl(): cannot obtain cpp_func_rec.");
-    }
-    if (rec->name != nullptr && rec->name[0] != '\0' && rec->scope
-        && PyModule_Check(rec->scope.ptr()) != 0) {
-        object scope_module = get_scope_module(rec->scope);
-        if (scope_module) {
-            auto builtins = reinterpret_borrow<dict>(PyEval_GetBuiltins());
-            auto builtins_eval = builtins["eval"];
-            auto reconstruct_args = make_tuple(str("__import__('importlib').import_module('")
-                                               + scope_module + str("')"));
-            return make_tuple(std::move(builtins_eval), std::move(reconstruct_args))
-                .release()
-                .ptr();
-        }
-    }
-    set_error(PyExc_RuntimeError, repr(self) + str(" is not pickleable."));
-    return nullptr;
-}
-
-PYBIND11_NAMESPACE_END(function_record_PyTypeObject_methods)
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/detail/init.h

@@ -1,538 +0,0 @@
-/*
-    pybind11/detail/init.h: init factory function implementation and support code.
-
-    Copyright (c) 2017 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.
-*/
-
-#pragma once
-
-#include "class.h"
-#include "using_smart_holder.h"
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-PYBIND11_WARNING_DISABLE_MSVC(4127)
-
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-template <>
-class type_caster<value_and_holder> {
-public:
-    bool load(handle h, bool) {
-        value = reinterpret_cast<value_and_holder *>(h.ptr());
-        return true;
-    }
-
-    template <typename>
-    using cast_op_type = value_and_holder &;
-    explicit operator value_and_holder &() { return *value; }
-    static constexpr auto name = const_name<value_and_holder>();
-
-private:
-    value_and_holder *value = nullptr;
-};
-
-PYBIND11_NAMESPACE_BEGIN(initimpl)
-
-inline void no_nullptr(const void *ptr) {
-    if (!ptr) {
-        throw type_error("pybind11::init(): factory function returned nullptr");
-    }
-}
-
-// Implementing functions for all forms of py::init<...> and py::init(...)
-template <typename Class>
-using Cpp = typename Class::type;
-template <typename Class>
-using Alias = typename Class::type_alias;
-template <typename Class>
-using Holder = typename Class::holder_type;
-
-template <typename Class>
-using is_alias_constructible = std::is_constructible<Alias<Class>, Cpp<Class> &&>;
-
-// Takes a Cpp pointer and returns true if it actually is a polymorphic Alias instance.
-template <typename Class, enable_if_t<Class::has_alias, int> = 0>
-bool is_alias(Cpp<Class> *ptr) {
-    return dynamic_cast<Alias<Class> *>(ptr) != nullptr;
-}
-// Failing fallback version of the above for a no-alias class (always returns false)
-template <typename /*Class*/>
-constexpr bool is_alias(const void *) {
-    return false;
-}
-
-// Constructs and returns a new object; if the given arguments don't map to a constructor, we fall
-// back to brace aggregate initialization so that for aggregate initialization can be used with
-// py::init, e.g.  `py::init<int, int>` to initialize a `struct T { int a; int b; }`.  For
-// non-aggregate types, we need to use an ordinary T(...) constructor (invoking as `T{...}` usually
-// works, but will not do the expected thing when `T` has an `initializer_list<T>` constructor).
-template <typename Class,
-          typename... Args,
-          detail::enable_if_t<std::is_constructible<Class, Args...>::value, int> = 0>
-inline Class *construct_or_initialize(Args &&...args) {
-    return new Class(std::forward<Args>(args)...);
-}
-template <typename Class,
-          typename... Args,
-          detail::enable_if_t<!std::is_constructible<Class, Args...>::value, int> = 0>
-inline Class *construct_or_initialize(Args &&...args) {
-    return new Class{std::forward<Args>(args)...};
-}
-
-// Attempts to constructs an alias using a `Alias(Cpp &&)` constructor.  This allows types with
-// an alias to provide only a single Cpp factory function as long as the Alias can be
-// constructed from an rvalue reference of the base Cpp type.  This means that Alias classes
-// can, when appropriate, simply define a `Alias(Cpp &&)` constructor rather than needing to
-// inherit all the base class constructors.
-template <typename Class>
-void construct_alias_from_cpp(std::true_type /*is_alias_constructible*/,
-                              value_and_holder &v_h,
-                              Cpp<Class> &&base) {
-    v_h.value_ptr() = new Alias<Class>(std::move(base));
-}
-template <typename Class>
-[[noreturn]] void construct_alias_from_cpp(std::false_type /*!is_alias_constructible*/,
-                                           value_and_holder &,
-                                           Cpp<Class> &&) {
-    throw type_error("pybind11::init(): unable to convert returned instance to required "
-                     "alias class: no `Alias<Class>(Class &&)` constructor available");
-}
-
-// Error-generating fallback for factories that don't match one of the below construction
-// mechanisms.
-template <typename Class>
-void construct(...) {
-    static_assert(!std::is_same<Class, Class>::value /* always false */,
-                  "pybind11::init(): init function must return a compatible pointer, "
-                  "holder, or value");
-}
-
-// Pointer return v1: the factory function returns a class pointer for a registered class.
-// If we don't need an alias (because this class doesn't have one, or because the final type is
-// inherited on the Python side) we can simply take over ownership.  Otherwise we need to try to
-// construct an Alias from the returned base instance.
-template <typename Class>
-void construct(value_and_holder &v_h, Cpp<Class> *ptr, bool need_alias) {
-    PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(need_alias);
-    no_nullptr(ptr);
-    if (Class::has_alias && need_alias && !is_alias<Class>(ptr)) {
-        // We're going to try to construct an alias by moving the cpp type.  Whether or not
-        // that succeeds, we still need to destroy the original cpp pointer (either the
-        // moved away leftover, if the alias construction works, or the value itself if we
-        // throw an error), but we can't just call `delete ptr`: it might have a special
-        // deleter, or might be shared_from_this.  So we construct a holder around it as if
-        // it was a normal instance, then steal the holder away into a local variable; thus
-        // the holder and destruction happens when we leave the C++ scope, and the holder
-        // class gets to handle the destruction however it likes.
-        v_h.value_ptr() = ptr;
-        v_h.set_instance_registered(true); // Trick to prevent init_instance from registering it
-        // DANGER ZONE BEGIN: exceptions will leave v_h in an invalid state.
-        v_h.type->init_instance(v_h.inst, nullptr);                        // Set up the holder
-        Holder<Class> temp_holder(std::move(v_h.holder<Holder<Class>>())); // Steal the holder
-        v_h.type->dealloc(v_h); // Destroys the moved-out holder remains, resets value ptr to null
-        v_h.set_instance_registered(false);
-        // DANGER ZONE END.
-
-        construct_alias_from_cpp<Class>(is_alias_constructible<Class>{}, v_h, std::move(*ptr));
-    } else {
-        // Otherwise the type isn't inherited, so we don't need an Alias
-        v_h.value_ptr() = ptr;
-    }
-}
-
-// Pointer return v2: a factory that always returns an alias instance ptr.  We simply take over
-// ownership of the pointer.
-template <typename Class, enable_if_t<Class::has_alias, int> = 0>
-void construct(value_and_holder &v_h, Alias<Class> *alias_ptr, bool) {
-    no_nullptr(alias_ptr);
-    v_h.value_ptr() = static_cast<Cpp<Class> *>(alias_ptr);
-}
-
-// Holder return: copy its pointer, and move or copy the returned holder into the new instance's
-// holder.  This also handles types like std::shared_ptr<T> and std::unique_ptr<T> where T is a
-// derived type (through those holder's implicit conversion from derived class holder
-// constructors).
-template <typename Class, detail::enable_if_t<!is_smart_holder<Holder<Class>>::value, int> = 0>
-void construct(value_and_holder &v_h, Holder<Class> holder, bool need_alias) {
-    PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(need_alias);
-    auto *ptr = holder_helper<Holder<Class>>::get(holder);
-    no_nullptr(ptr);
-    // If we need an alias, check that the held pointer is actually an alias instance
-    if (Class::has_alias && need_alias && !is_alias<Class>(ptr)) {
-        throw type_error("pybind11::init(): construction failed: returned holder-wrapped instance "
-                         "is not an alias instance");
-    }
-
-    // Cast away constness to store in void* storage.
-    // The value_and_holder storage is fundamentally untyped (void**), so we lose
-    // const-correctness here by design. The const qualifier will be restored
-    // when the pointer is later retrieved and cast back to the original type.
-    // This explicit const_cast makes the const-removal clearly visible.
-    v_h.value_ptr() = const_cast<void *>(static_cast<const void *>(ptr));
-    v_h.type->init_instance(v_h.inst, &holder);
-}
-
-// return-by-value version 1: returning a cpp class by value.  If the class has an alias and an
-// alias is required the alias must have an `Alias(Cpp &&)` constructor so that we can construct
-// the alias from the base when needed (i.e. because of Python-side inheritance).  When we don't
-// need it, we simply move-construct the cpp value into a new instance.
-template <typename Class>
-void construct(value_and_holder &v_h, Cpp<Class> &&result, bool need_alias) {
-    PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(need_alias);
-    static_assert(is_move_constructible<Cpp<Class>>::value,
-                  "pybind11::init() return-by-value factory function requires a movable class");
-    if (Class::has_alias && need_alias) {
-        construct_alias_from_cpp<Class>(is_alias_constructible<Class>{}, v_h, std::move(result));
-    } else {
-        v_h.value_ptr() = new Cpp<Class>(std::move(result));
-    }
-}
-
-// return-by-value version 2: returning a value of the alias type itself.  We move-construct an
-// Alias instance (even if no the python-side inheritance is involved).  The is intended for
-// cases where Alias initialization is always desired.
-template <typename Class>
-void construct(value_and_holder &v_h, Alias<Class> &&result, bool) {
-    static_assert(
-        is_move_constructible<Alias<Class>>::value,
-        "pybind11::init() return-by-alias-value factory function requires a movable alias class");
-    v_h.value_ptr() = new Alias<Class>(std::move(result));
-}
-
-template <typename T, typename D>
-smart_holder init_smart_holder_from_unique_ptr(std::unique_ptr<T, D> &&unq_ptr,
-                                               bool void_cast_raw_ptr) {
-    void *void_ptr = void_cast_raw_ptr ? static_cast<void *>(unq_ptr.get()) : nullptr;
-    return smart_holder::from_unique_ptr(std::move(unq_ptr), void_ptr);
-}
-
-template <typename Class,
-          typename D = std::default_delete<Cpp<Class>>,
-          detail::enable_if_t<is_smart_holder<Holder<Class>>::value, int> = 0>
-void construct(value_and_holder &v_h, std::unique_ptr<Cpp<Class>, D> &&unq_ptr, bool need_alias) {
-    PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(need_alias);
-    auto *ptr = unq_ptr.get();
-    no_nullptr(ptr);
-    if (Class::has_alias && need_alias && !is_alias<Class>(ptr)) {
-        throw type_error("pybind11::init(): construction failed: returned std::unique_ptr pointee "
-                         "is not an alias instance");
-    }
-    // Here and below: if the new object is a trampoline, the shared_from_this mechanism needs
-    // to be prevented from accessing the smart_holder vptr, because it does not keep the
-    // trampoline Python object alive. For types that don't inherit from enable_shared_from_this
-    // it does not matter if void_cast_raw_ptr is true or false, therefore it's not necessary
-    // to also inspect the type.
-    auto smhldr = init_smart_holder_from_unique_ptr(
-        std::move(unq_ptr), /*void_cast_raw_ptr*/ Class::has_alias && is_alias<Class>(ptr));
-    v_h.value_ptr() = ptr;
-    v_h.type->init_instance(v_h.inst, &smhldr);
-}
-
-template <typename Class,
-          typename D = std::default_delete<Alias<Class>>,
-          detail::enable_if_t<is_smart_holder<Holder<Class>>::value, int> = 0>
-void construct(value_and_holder &v_h,
-               std::unique_ptr<Alias<Class>, D> &&unq_ptr,
-               bool /*need_alias*/) {
-    auto *ptr = unq_ptr.get();
-    no_nullptr(ptr);
-    auto smhldr
-        = init_smart_holder_from_unique_ptr(std::move(unq_ptr), /*void_cast_raw_ptr*/ true);
-    v_h.value_ptr() = ptr;
-    v_h.type->init_instance(v_h.inst, &smhldr);
-}
-
-template <typename PtrType, typename Class>
-void construct_from_shared_ptr(value_and_holder &v_h,
-                               std::shared_ptr<PtrType> &&shd_ptr,
-                               bool need_alias) {
-    static_assert(std::is_same<PtrType, Cpp<Class>>::value
-                      || std::is_same<PtrType, const Cpp<Class>>::value,
-                  "Expected (const) Cpp<Class> as shared_ptr pointee");
-    auto *ptr = shd_ptr.get();
-    no_nullptr(ptr);
-    if (Class::has_alias && need_alias && !is_alias<Class>(ptr)) {
-        throw type_error("pybind11::init(): construction failed: returned std::shared_ptr pointee "
-                         "is not an alias instance");
-    }
-    // Cast to non-const if needed, consistent with internal design
-    auto smhldr
-        = smart_holder::from_shared_ptr(std::const_pointer_cast<Cpp<Class>>(std::move(shd_ptr)));
-    v_h.value_ptr() = const_cast<Cpp<Class> *>(ptr);
-    v_h.type->init_instance(v_h.inst, &smhldr);
-}
-
-template <typename Class, detail::enable_if_t<is_smart_holder<Holder<Class>>::value, int> = 0>
-void construct(value_and_holder &v_h, std::shared_ptr<Cpp<Class>> &&shd_ptr, bool need_alias) {
-    construct_from_shared_ptr<Cpp<Class>, Class>(v_h, std::move(shd_ptr), need_alias);
-}
-
-template <typename Class, detail::enable_if_t<is_smart_holder<Holder<Class>>::value, int> = 0>
-void construct(value_and_holder &v_h,
-               std::shared_ptr<const Cpp<Class>> &&shd_ptr,
-               bool need_alias) {
-    construct_from_shared_ptr<const Cpp<Class>, Class>(v_h, std::move(shd_ptr), need_alias);
-}
-
-template <typename Class, detail::enable_if_t<is_smart_holder<Holder<Class>>::value, int> = 0>
-void construct(value_and_holder &v_h,
-               std::shared_ptr<Alias<Class>> &&shd_ptr,
-               bool /*need_alias*/) {
-    auto *ptr = shd_ptr.get();
-    no_nullptr(ptr);
-    auto smhldr = smart_holder::from_shared_ptr(shd_ptr);
-    v_h.value_ptr() = ptr;
-    v_h.type->init_instance(v_h.inst, &smhldr);
-}
-
-// Implementing class for py::init<...>()
-template <typename... Args>
-struct constructor {
-    template <typename Class, typename... Extra, enable_if_t<!Class::has_alias, int> = 0>
-    static void execute(Class &cl, const Extra &...extra) {
-        cl.def(
-            "__init__",
-            [](value_and_holder &v_h,
-               Args... args) { // NOLINT(performance-unnecessary-value-param)
-                v_h.value_ptr() = construct_or_initialize<Cpp<Class>>(std::forward<Args>(args)...);
-            },
-            is_new_style_constructor(),
-            extra...);
-    }
-
-    template <
-        typename Class,
-        typename... Extra,
-        enable_if_t<Class::has_alias && std::is_constructible<Cpp<Class>, Args...>::value, int>
-        = 0>
-    static void execute(Class &cl, const Extra &...extra) {
-        cl.def(
-            "__init__",
-            [](value_and_holder &v_h, Args... args) {
-                if (Py_TYPE(v_h.inst) == v_h.type->type) {
-                    v_h.value_ptr()
-                        = construct_or_initialize<Cpp<Class>>(std::forward<Args>(args)...);
-                } else {
-                    v_h.value_ptr()
-                        = construct_or_initialize<Alias<Class>>(std::forward<Args>(args)...);
-                }
-            },
-            is_new_style_constructor(),
-            extra...);
-    }
-
-    template <
-        typename Class,
-        typename... Extra,
-        enable_if_t<Class::has_alias && !std::is_constructible<Cpp<Class>, Args...>::value, int>
-        = 0>
-    static void execute(Class &cl, const Extra &...extra) {
-        cl.def(
-            "__init__",
-            [](value_and_holder &v_h, Args... args) {
-                v_h.value_ptr()
-                    = construct_or_initialize<Alias<Class>>(std::forward<Args>(args)...);
-            },
-            is_new_style_constructor(),
-            extra...);
-    }
-};
-
-// Implementing class for py::init_alias<...>()
-template <typename... Args>
-struct alias_constructor {
-    template <
-        typename Class,
-        typename... Extra,
-        enable_if_t<Class::has_alias && std::is_constructible<Alias<Class>, Args...>::value, int>
-        = 0>
-    static void execute(Class &cl, const Extra &...extra) {
-        cl.def(
-            "__init__",
-            [](value_and_holder &v_h, Args... args) {
-                v_h.value_ptr()
-                    = construct_or_initialize<Alias<Class>>(std::forward<Args>(args)...);
-            },
-            is_new_style_constructor(),
-            extra...);
-    }
-};
-
-// Implementation class for py::init(Func) and py::init(Func, AliasFunc)
-template <typename CFunc,
-          typename AFunc = void_type (*)(),
-          typename = function_signature_t<CFunc>,
-          typename = function_signature_t<AFunc>>
-struct factory;
-
-// Specialization for py::init(Func)
-template <typename Func, typename Return, typename... Args>
-struct factory<Func, void_type (*)(), Return(Args...)> {
-    remove_reference_t<Func> class_factory;
-
-    // NOLINTNEXTLINE(google-explicit-constructor)
-    factory(Func &&f) : class_factory(std::forward<Func>(f)) {}
-
-    // The given class either has no alias or has no separate alias factory;
-    // this always constructs the class itself.  If the class is registered with an alias
-    // type and an alias instance is needed (i.e. because the final type is a Python class
-    // inheriting from the C++ type) the returned value needs to either already be an alias
-    // instance, or the alias needs to be constructible from a `Class &&` argument.
-    template <typename Class, typename... Extra>
-    void execute(Class &cl, const Extra &...extra) && {
-#if defined(PYBIND11_CPP14)
-        cl.def(
-            "__init__",
-            [func = std::move(class_factory)]
-#else
-        auto &func = class_factory;
-        cl.def(
-            "__init__",
-            [func]
-#endif
-            (value_and_holder &v_h, Args... args) {
-                construct<Class>(
-                    v_h, func(std::forward<Args>(args)...), Py_TYPE(v_h.inst) != v_h.type->type);
-            },
-            is_new_style_constructor(),
-            extra...);
-    }
-};
-
-// Specialization for py::init(Func, AliasFunc)
-template <typename CFunc,
-          typename AFunc,
-          typename CReturn,
-          typename... CArgs,
-          typename AReturn,
-          typename... AArgs>
-struct factory<CFunc, AFunc, CReturn(CArgs...), AReturn(AArgs...)> {
-    static_assert(sizeof...(CArgs) == sizeof...(AArgs),
-                  "pybind11::init(class_factory, alias_factory): class and alias factories "
-                  "must have identical argument signatures");
-    static_assert(all_of<std::is_same<CArgs, AArgs>...>::value,
-                  "pybind11::init(class_factory, alias_factory): class and alias factories "
-                  "must have identical argument signatures");
-
-    remove_reference_t<CFunc> class_factory;
-    remove_reference_t<AFunc> alias_factory;
-
-    factory(CFunc &&c, AFunc &&a)
-        : class_factory(std::forward<CFunc>(c)), alias_factory(std::forward<AFunc>(a)) {}
-
-    // The class factory is called when the `self` type passed to `__init__` is the direct
-    // class (i.e. not inherited), the alias factory when `self` is a Python-side subtype.
-    template <typename Class, typename... Extra>
-    void execute(Class &cl, const Extra &...extra) && {
-        static_assert(Class::has_alias,
-                      "The two-argument version of `py::init()` can "
-                      "only be used if the class has an alias");
-#if defined(PYBIND11_CPP14)
-        cl.def(
-            "__init__",
-            [class_func = std::move(class_factory), alias_func = std::move(alias_factory)]
-#else
-        auto &class_func = class_factory;
-        auto &alias_func = alias_factory;
-        cl.def(
-            "__init__",
-            [class_func, alias_func]
-#endif
-            (value_and_holder &v_h, CArgs... args) {
-                if (Py_TYPE(v_h.inst) == v_h.type->type) {
-                    // If the instance type equals the registered type we don't have inheritance,
-                    // so don't need the alias and can construct using the class function:
-                    construct<Class>(v_h, class_func(std::forward<CArgs>(args)...), false);
-                } else {
-                    construct<Class>(v_h, alias_func(std::forward<CArgs>(args)...), true);
-                }
-            },
-            is_new_style_constructor(),
-            extra...);
-    }
-};
-
-/// Set just the C++ state. Same as `__init__`.
-template <typename Class, typename T>
-void setstate(value_and_holder &v_h, T &&result, bool need_alias) {
-    construct<Class>(v_h, std::forward<T>(result), need_alias);
-}
-
-/// Set both the C++ and Python states
-template <typename Class,
-          typename T,
-          typename O,
-          enable_if_t<std::is_convertible<O, handle>::value, int> = 0>
-void setstate(value_and_holder &v_h, std::pair<T, O> &&result, bool need_alias) {
-    construct<Class>(v_h, std::move(result.first), need_alias);
-    auto d = handle(result.second);
-    if (PyDict_Check(d.ptr()) && PyDict_Size(d.ptr()) == 0) {
-        // Skipping setattr below, to not force use of py::dynamic_attr() for Class unnecessarily.
-        // See PR #2972 for details.
-        return;
-    }
-    // Our tests never run into an unset dict, but being careful here for now (see #5658)
-    auto dict = getattr((PyObject *) v_h.inst, "__dict__", none());
-    if (dict.is_none()) {
-        setattr((PyObject *) v_h.inst, "__dict__", d);
-    } else {
-        // Keep the original object dict and just update it
-        if (PyDict_Update(dict.ptr(), d.ptr()) < 0) {
-            throw error_already_set();
-        }
-    }
-}
-
-/// Implementation for py::pickle(GetState, SetState)
-template <typename Get,
-          typename Set,
-          typename = function_signature_t<Get>,
-          typename = function_signature_t<Set>>
-struct pickle_factory;
-
-template <typename Get,
-          typename Set,
-          typename RetState,
-          typename Self,
-          typename NewInstance,
-          typename ArgState>
-struct pickle_factory<Get, Set, RetState(Self), NewInstance(ArgState)> {
-    static_assert(std::is_same<intrinsic_t<RetState>, intrinsic_t<ArgState>>::value,
-                  "The type returned by `__getstate__` must be the same "
-                  "as the argument accepted by `__setstate__`");
-
-    remove_reference_t<Get> get;
-    remove_reference_t<Set> set;
-
-    pickle_factory(Get get, Set set) : get(std::forward<Get>(get)), set(std::forward<Set>(set)) {}
-
-    template <typename Class, typename... Extra>
-    void execute(Class &cl, const Extra &...extra) && {
-        cl.def("__getstate__", std::move(get), pos_only());
-
-#if defined(PYBIND11_CPP14)
-        cl.def(
-            "__setstate__",
-            [func = std::move(set)]
-#else
-        auto &func = set;
-        cl.def(
-            "__setstate__",
-            [func]
-#endif
-            (value_and_holder &v_h, ArgState state) {
-                setstate<Class>(
-                    v_h, func(std::forward<ArgState>(state)), Py_TYPE(v_h.inst) != v_h.type->type);
-            },
-            is_new_style_constructor(),
-            extra...);
-    }
-};
-
-PYBIND11_NAMESPACE_END(initimpl)
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/detail/internals.h

@@ -1,799 +0,0 @@
-/*
-    pybind11/detail/internals.h: Internal data structure and related functions
-
-    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 <pybind11/conduit/pybind11_platform_abi_id.h>
-#include <pybind11/gil_simple.h>
-#include <pybind11/pytypes.h>
-#include <pybind11/trampoline_self_life_support.h>
-
-#include "common.h"
-#include "struct_smart_holder.h"
-
-#include <atomic>
-#include <cstdint>
-#include <exception>
-#include <limits>
-#include <mutex>
-#include <thread>
-
-/// Tracks the `internals` and `type_info` ABI version independent of the main library version.
-///
-/// Some portions of the code use an ABI that is conditional depending on this
-/// version number.  That allows ABI-breaking changes to be "pre-implemented".
-/// Once the default version number is incremented, the conditional logic that
-/// no longer applies can be removed.  Additionally, users that need not
-/// maintain ABI compatibility can increase the version number in order to take
-/// advantage of any functionality/efficiency improvements that depend on the
-/// newer ABI.
-///
-/// WARNING: If you choose to manually increase the ABI version, note that
-/// pybind11 may not be tested as thoroughly with a non-default ABI version, and
-/// further ABI-incompatible changes may be made before the ABI is officially
-/// changed to the new version.
-#ifndef PYBIND11_INTERNALS_VERSION
-#    define PYBIND11_INTERNALS_VERSION 11
-#endif
-
-#if PYBIND11_INTERNALS_VERSION < 11
-#    error "PYBIND11_INTERNALS_VERSION 11 is the minimum for all platforms for pybind11v3."
-#endif
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-using ExceptionTranslator = void (*)(std::exception_ptr);
-
-// The old Python Thread Local Storage (TLS) API is deprecated in Python 3.7 in favor of the new
-// Thread Specific Storage (TSS) API.
-// Avoid unnecessary allocation of `Py_tss_t`, since we cannot use
-// `Py_LIMITED_API` anyway.
-#define PYBIND11_TLS_KEY_REF Py_tss_t &
-#if defined(__clang__)
-#    define PYBIND11_TLS_KEY_INIT(var)                                                            \
-        _Pragma("clang diagnostic push")                                         /**/             \
-            _Pragma("clang diagnostic ignored \"-Wmissing-field-initializers\"") /**/             \
-            Py_tss_t var                                                                          \
-            = Py_tss_NEEDS_INIT;                                                                  \
-        _Pragma("clang diagnostic pop")
-#elif defined(__GNUC__) && !defined(__INTEL_COMPILER)
-#    define PYBIND11_TLS_KEY_INIT(var)                                                            \
-        _Pragma("GCC diagnostic push")                                         /**/               \
-            _Pragma("GCC diagnostic ignored \"-Wmissing-field-initializers\"") /**/               \
-            Py_tss_t var                                                                          \
-            = Py_tss_NEEDS_INIT;                                                                  \
-        _Pragma("GCC diagnostic pop")
-#else
-#    define PYBIND11_TLS_KEY_INIT(var) Py_tss_t var = Py_tss_NEEDS_INIT;
-#endif
-#define PYBIND11_TLS_KEY_CREATE(var) (PyThread_tss_create(&(var)) == 0)
-#define PYBIND11_TLS_GET_VALUE(key) PyThread_tss_get(&(key))
-#define PYBIND11_TLS_REPLACE_VALUE(key, value) PyThread_tss_set(&(key), (value))
-#define PYBIND11_TLS_DELETE_VALUE(key) PyThread_tss_set(&(key), nullptr)
-#define PYBIND11_TLS_FREE(key) PyThread_tss_delete(&(key))
-
-/// A smart-pointer-like wrapper around a thread-specific value. get/set of the pointer applies to
-/// the current thread only.
-template <typename T>
-class thread_specific_storage {
-public:
-    thread_specific_storage() {
-        // NOLINTNEXTLINE(bugprone-assignment-in-if-condition)
-        if (!PYBIND11_TLS_KEY_CREATE(key_)) {
-            pybind11_fail(
-                "thread_specific_storage constructor: could not initialize the TSS key!");
-        }
-    }
-
-    ~thread_specific_storage() {
-        // This destructor is often called *after* Py_Finalize(). That *SHOULD BE* fine on most
-        // platforms. The following details what happens when PyThread_tss_free is called in
-        // CPython. PYBIND11_TLS_FREE is PyThread_tss_free on python 3.7+. On older python, it does
-        // nothing. PyThread_tss_free calls PyThread_tss_delete and PyMem_RawFree.
-        // PyThread_tss_delete just calls TlsFree (on Windows) or pthread_key_delete (on *NIX).
-        // Neither of those have anything to do with CPython internals. PyMem_RawFree *requires*
-        // that the `key` be allocated with the CPython allocator (as it is by
-        // PyThread_tss_create).
-        // However, in GraalPy (as of v24.2 or older), TSS is implemented by Java and this call
-        // requires a living Python interpreter.
-#ifdef GRAALVM_PYTHON
-        if (!Py_IsInitialized() || _Py_IsFinalizing()) {
-            return;
-        }
-#endif
-        PYBIND11_TLS_FREE(key_);
-    }
-
-    thread_specific_storage(thread_specific_storage const &) = delete;
-    thread_specific_storage(thread_specific_storage &&) = delete;
-    thread_specific_storage &operator=(thread_specific_storage const &) = delete;
-    thread_specific_storage &operator=(thread_specific_storage &&) = delete;
-
-    T *get() const { return reinterpret_cast<T *>(PYBIND11_TLS_GET_VALUE(key_)); }
-
-    T &operator*() const { return *get(); }
-    explicit operator T *() const { return get(); }
-    explicit operator bool() const { return get() != nullptr; }
-
-    void set(T *val) { PYBIND11_TLS_REPLACE_VALUE(key_, reinterpret_cast<void *>(val)); }
-    void reset(T *p = nullptr) { set(p); }
-    thread_specific_storage &operator=(T *pval) {
-        set(pval);
-        return *this;
-    }
-
-private:
-    PYBIND11_TLS_KEY_INIT(mutable key_)
-};
-
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-// This does NOT actually exist as a module.
-#define PYBIND11_DUMMY_MODULE_NAME "pybind11_builtins"
-
-// Forward declarations
-inline PyTypeObject *make_static_property_type();
-inline PyTypeObject *make_default_metaclass();
-inline PyObject *make_object_base_type(PyTypeObject *metaclass);
-inline void translate_exception(std::exception_ptr p);
-
-// Python loads modules by default with dlopen with the RTLD_LOCAL flag; under libc++ and possibly
-// other STLs, this means `typeid(A)` from one module won't equal `typeid(A)` from another module
-// even when `A` is the same, non-hidden-visibility type (e.g. from a common include).  Under
-// libstdc++, this doesn't happen: equality and the type_index hash are based on the type name,
-// which works.  If not under a known-good stl, provide our own name-based hash and equality
-// functions that use the type name.
-#if !defined(_LIBCPP_VERSION)
-inline bool same_type(const std::type_info &lhs, const std::type_info &rhs) { return lhs == rhs; }
-using type_hash = std::hash<std::type_index>;
-using type_equal_to = std::equal_to<std::type_index>;
-#else
-inline bool same_type(const std::type_info &lhs, const std::type_info &rhs) {
-    return lhs.name() == rhs.name() || std::strcmp(lhs.name(), rhs.name()) == 0;
-}
-
-struct type_hash {
-    size_t operator()(const std::type_index &t) const {
-        size_t hash = 5381;
-        const char *ptr = t.name();
-        while (auto c = static_cast<unsigned char>(*ptr++)) {
-            hash = (hash * 33) ^ c;
-        }
-        return hash;
-    }
-};
-
-struct type_equal_to {
-    bool operator()(const std::type_index &lhs, const std::type_index &rhs) const {
-        return lhs.name() == rhs.name() || std::strcmp(lhs.name(), rhs.name()) == 0;
-    }
-};
-#endif
-
-template <typename value_type>
-using type_map = std::unordered_map<std::type_index, value_type, type_hash, type_equal_to>;
-
-struct override_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;
-    }
-};
-
-using instance_map = std::unordered_multimap<const void *, instance *>;
-
-#ifdef Py_GIL_DISABLED
-// Wrapper around PyMutex to provide BasicLockable semantics
-class pymutex {
-    PyMutex mutex;
-
-public:
-    pymutex() : mutex({}) {}
-    void lock() { PyMutex_Lock(&mutex); }
-    void unlock() { PyMutex_Unlock(&mutex); }
-};
-
-// Instance map shards are used to reduce mutex contention in free-threaded Python.
-struct instance_map_shard {
-    instance_map registered_instances;
-    pymutex mutex;
-    // alignas(64) would be better, but causes compile errors in macOS before 10.14 (see #5200)
-    char padding[64 - (sizeof(instance_map) + sizeof(pymutex)) % 64];
-};
-
-static_assert(sizeof(instance_map_shard) % 64 == 0,
-              "instance_map_shard size is not a multiple of 64 bytes");
-
-inline uint64_t round_up_to_next_pow2(uint64_t x) {
-    // Round-up to the next power of two.
-    // See https://graphics.stanford.edu/~seander/bithacks.html#RoundUpPowerOf2
-    x--;
-    x |= (x >> 1);
-    x |= (x >> 2);
-    x |= (x >> 4);
-    x |= (x >> 8);
-    x |= (x >> 16);
-    x |= (x >> 32);
-    x++;
-    return x;
-}
-#endif
-
-class loader_life_support;
-
-/// Internal data structure used to track registered instances and types.
-/// Whenever binary incompatible changes are made to this structure,
-/// `PYBIND11_INTERNALS_VERSION` must be incremented.
-struct internals {
-#ifdef Py_GIL_DISABLED
-    pymutex mutex;
-    pymutex exception_translator_mutex;
-#endif
-    // std::type_index -> pybind11's type information
-    type_map<type_info *> registered_types_cpp;
-    // PyTypeObject* -> base type_info(s)
-    std::unordered_map<PyTypeObject *, std::vector<type_info *>> registered_types_py;
-#ifdef Py_GIL_DISABLED
-    std::unique_ptr<instance_map_shard[]> instance_shards; // void * -> instance*
-    size_t instance_shards_mask = 0;
-#else
-    instance_map registered_instances; // void * -> instance*
-#endif
-    std::unordered_set<std::pair<const PyObject *, const char *>, override_hash>
-        inactive_override_cache;
-    type_map<std::vector<bool (*)(PyObject *, void *&)>> direct_conversions;
-    std::unordered_map<const PyObject *, std::vector<PyObject *>> patients;
-    std::forward_list<ExceptionTranslator> registered_exception_translators;
-    std::unordered_map<std::string, void *> shared_data; // Custom data to be shared across
-                                                         // extensions
-    std::forward_list<std::string> static_strings;       // Stores the std::strings backing
-                                                         // detail::c_str()
-    PyTypeObject *static_property_type = nullptr;
-    PyTypeObject *default_metaclass = nullptr;
-    PyObject *instance_base = nullptr;
-    // Unused if PYBIND11_SIMPLE_GIL_MANAGEMENT is defined:
-    thread_specific_storage<PyThreadState> tstate;
-    thread_specific_storage<loader_life_support> loader_life_support_tls;
-    // Unused if PYBIND11_SIMPLE_GIL_MANAGEMENT is defined:
-    PyInterpreterState *istate = nullptr;
-
-    type_map<PyObject *> native_enum_type_map;
-
-    internals()
-        : static_property_type(make_static_property_type()),
-          default_metaclass(make_default_metaclass()) {
-        PyThreadState *cur_tstate = PyThreadState_Get();
-        tstate = cur_tstate;
-
-        istate = cur_tstate->interp;
-        registered_exception_translators.push_front(&translate_exception);
-#ifdef Py_GIL_DISABLED
-        // Scale proportional to the number of cores. 2x is a heuristic to reduce contention.
-        // Make sure the number isn't unreasonable by limiting it to 16 bits (65K)
-        auto num_shards = static_cast<std::uint16_t>(
-            std::min<std::size_t>(round_up_to_next_pow2(2 * std::thread::hardware_concurrency()),
-                                  std::numeric_limits<std::uint16_t>::max()));
-        if (num_shards == 0) {
-            num_shards = 1;
-        }
-        instance_shards.reset(new instance_map_shard[num_shards]);
-        instance_shards_mask = num_shards - 1;
-#endif
-    }
-    internals(const internals &other) = delete;
-    internals(internals &&other) = delete;
-    internals &operator=(const internals &other) = delete;
-    internals &operator=(internals &&other) = delete;
-    ~internals() = default;
-};
-
-// the internals struct (above) is shared between all the modules. local_internals are only
-// for a single module. Any changes made to internals may require an update to
-// PYBIND11_INTERNALS_VERSION, breaking backwards compatibility. local_internals is, by design,
-// restricted to a single module. Whether a module has local internals or not should not
-// impact any other modules, because the only things accessing the local internals is the
-// module that contains them.
-struct local_internals {
-    type_map<type_info *> registered_types_cpp;
-    std::forward_list<ExceptionTranslator> registered_exception_translators;
-    PyTypeObject *function_record_py_type = nullptr;
-};
-
-enum class holder_enum_t : uint8_t {
-    undefined,
-    std_unique_ptr, // Default, lacking interop with std::shared_ptr.
-    std_shared_ptr, // Lacking interop with std::unique_ptr.
-    smart_holder,   // Full std::unique_ptr / std::shared_ptr interop.
-    custom_holder,
-};
-
-/// Additional type information which does not fit into the PyTypeObject.
-/// Changes to this struct also require bumping `PYBIND11_INTERNALS_VERSION`.
-struct type_info {
-    PyTypeObject *type;
-    const std::type_info *cpptype;
-    size_t type_size, type_align, holder_size_in_ptrs;
-    void *(*operator_new)(size_t);
-    void (*init_instance)(instance *, const void *);
-    void (*dealloc)(value_and_holder &v_h);
-
-    // Cross-DSO-safe function pointers, to sidestep cross-DSO RTTI issues
-    // on platforms like macOS (see PR #5728 for details):
-    memory::get_guarded_delete_fn get_memory_guarded_delete = memory::get_guarded_delete;
-    get_trampoline_self_life_support_fn get_trampoline_self_life_support = nullptr;
-
-    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;
-    void *(*module_local_load)(PyObject *, const type_info *) = nullptr;
-    holder_enum_t holder_enum_v = holder_enum_t::undefined;
-    /* A simple type never occurs as a (direct or indirect) parent
-     * of a class that makes use of multiple inheritance.
-     * A type can be simple even if it has non-simple ancestors as long as it has no descendants.
-     */
-    bool simple_type : 1;
-    /* True if there is no multiple inheritance in this type's inheritance tree */
-    bool simple_ancestors : 1;
-    /* true if this is a type registered with py::module_local */
-    bool module_local : 1;
-};
-
-#define PYBIND11_INTERNALS_ID                                                                     \
-    "__pybind11_internals_v" PYBIND11_TOSTRING(PYBIND11_INTERNALS_VERSION)                        \
-        PYBIND11_COMPILER_TYPE_LEADING_UNDERSCORE PYBIND11_PLATFORM_ABI_ID "__"
-
-#define PYBIND11_MODULE_LOCAL_ID                                                                  \
-    "__pybind11_module_local_v" PYBIND11_TOSTRING(PYBIND11_INTERNALS_VERSION)                     \
-        PYBIND11_COMPILER_TYPE_LEADING_UNDERSCORE PYBIND11_PLATFORM_ABI_ID "__"
-
-inline PyThreadState *get_thread_state_unchecked() {
-#if defined(PYPY_VERSION) || defined(GRAALVM_PYTHON)
-    return PyThreadState_GET();
-#elif PY_VERSION_HEX < 0x030D0000
-    return _PyThreadState_UncheckedGet();
-#else
-    return PyThreadState_GetUnchecked();
-#endif
-}
-
-/// We use this counter to figure out if there are or have been multiple subinterpreters active at
-/// any point. This must never decrease while any interpreter may be running in any thread!
-inline std::atomic<int> &get_num_interpreters_seen() {
-    static std::atomic<int> counter(0);
-    return counter;
-}
-
-template <class T,
-          enable_if_t<std::is_same<std::nested_exception, remove_cvref_t<T>>::value, int> = 0>
-bool handle_nested_exception(const T &exc, const std::exception_ptr &p) {
-    std::exception_ptr nested = exc.nested_ptr();
-    if (nested != nullptr && nested != p) {
-        translate_exception(nested);
-        return true;
-    }
-    return false;
-}
-
-template <class T,
-          enable_if_t<!std::is_same<std::nested_exception, remove_cvref_t<T>>::value, int> = 0>
-bool handle_nested_exception(const T &exc, const std::exception_ptr &p) {
-    if (const auto *nep = dynamic_cast<const std::nested_exception *>(std::addressof(exc))) {
-        return handle_nested_exception(*nep, p);
-    }
-    return false;
-}
-
-inline bool raise_err(PyObject *exc_type, const char *msg) {
-    if (PyErr_Occurred()) {
-        raise_from(exc_type, msg);
-        return true;
-    }
-    set_error(exc_type, msg);
-    return false;
-}
-
-inline void translate_exception(std::exception_ptr p) {
-    if (!p) {
-        return;
-    }
-    try {
-        std::rethrow_exception(p);
-    } catch (error_already_set &e) {
-        handle_nested_exception(e, p);
-        e.restore();
-        return;
-    } catch (const builtin_exception &e) {
-        // Could not use template since it's an abstract class.
-        if (const auto *nep = dynamic_cast<const std::nested_exception *>(std::addressof(e))) {
-            handle_nested_exception(*nep, p);
-        }
-        e.set_error();
-        return;
-    } catch (const std::bad_alloc &e) {
-        handle_nested_exception(e, p);
-        raise_err(PyExc_MemoryError, e.what());
-        return;
-    } catch (const std::domain_error &e) {
-        handle_nested_exception(e, p);
-        raise_err(PyExc_ValueError, e.what());
-        return;
-    } catch (const std::invalid_argument &e) {
-        handle_nested_exception(e, p);
-        raise_err(PyExc_ValueError, e.what());
-        return;
-    } catch (const std::length_error &e) {
-        handle_nested_exception(e, p);
-        raise_err(PyExc_ValueError, e.what());
-        return;
-    } catch (const std::out_of_range &e) {
-        handle_nested_exception(e, p);
-        raise_err(PyExc_IndexError, e.what());
-        return;
-    } catch (const std::range_error &e) {
-        handle_nested_exception(e, p);
-        raise_err(PyExc_ValueError, e.what());
-        return;
-    } catch (const std::overflow_error &e) {
-        handle_nested_exception(e, p);
-        raise_err(PyExc_OverflowError, e.what());
-        return;
-    } catch (const std::exception &e) {
-        handle_nested_exception(e, p);
-        raise_err(PyExc_RuntimeError, e.what());
-        return;
-    } catch (const std::nested_exception &e) {
-        handle_nested_exception(e, p);
-        raise_err(PyExc_RuntimeError, "Caught an unknown nested exception!");
-        return;
-    } catch (...) {
-        raise_err(PyExc_RuntimeError, "Caught an unknown exception!");
-        return;
-    }
-}
-
-#if !defined(__GLIBCXX__)
-inline void translate_local_exception(std::exception_ptr p) {
-    try {
-        if (p) {
-            std::rethrow_exception(p);
-        }
-    } catch (error_already_set &e) {
-        e.restore();
-        return;
-    } catch (const builtin_exception &e) {
-        e.set_error();
-        return;
-    }
-}
-#endif
-
-inline object get_python_state_dict() {
-    object state_dict;
-#if defined(PYPY_VERSION) || defined(GRAALVM_PYTHON)
-    state_dict = reinterpret_borrow<object>(PyEval_GetBuiltins());
-#else
-#    if PY_VERSION_HEX < 0x03090000
-    PyInterpreterState *istate = _PyInterpreterState_Get();
-#    else
-    PyInterpreterState *istate = PyInterpreterState_Get();
-#    endif
-    if (istate) {
-        state_dict = reinterpret_borrow<object>(PyInterpreterState_GetDict(istate));
-    }
-#endif
-    if (!state_dict) {
-        raise_from(PyExc_SystemError, "pybind11::detail::get_python_state_dict() FAILED");
-        throw error_already_set();
-    }
-    return state_dict;
-}
-
-template <typename InternalsType>
-class internals_pp_manager {
-public:
-    using on_fetch_function = void(InternalsType *);
-    internals_pp_manager(char const *id, on_fetch_function *on_fetch)
-        : holder_id_(id), on_fetch_(on_fetch) {}
-
-    /// Get the current pointer-to-pointer, allocating it if it does not already exist.  May
-    /// acquire the GIL. Will never return nullptr.
-    std::unique_ptr<InternalsType> *get_pp() {
-#ifdef PYBIND11_HAS_SUBINTERPRETER_SUPPORT
-        if (get_num_interpreters_seen() > 1) {
-            // Whenever the interpreter changes on the current thread we need to invalidate the
-            // internals_pp so that it can be pulled from the interpreter's state dict.  That is
-            // slow, so we use the current PyThreadState to check if it is necessary.
-            auto *tstate = get_thread_state_unchecked();
-            if (!tstate || tstate->interp != last_istate_.get()) {
-                gil_scoped_acquire_simple gil;
-                if (!tstate) {
-                    tstate = get_thread_state_unchecked();
-                }
-                last_istate_ = tstate->interp;
-                internals_tls_p_ = get_or_create_pp_in_state_dict();
-            }
-            return internals_tls_p_.get();
-        }
-#endif
-        if (!internals_singleton_pp_) {
-            gil_scoped_acquire_simple gil;
-            internals_singleton_pp_ = get_or_create_pp_in_state_dict();
-        }
-        return internals_singleton_pp_;
-    }
-
-    /// Drop all the references we're currently holding.
-    void unref() {
-#ifdef PYBIND11_HAS_SUBINTERPRETER_SUPPORT
-        if (get_num_interpreters_seen() > 1) {
-            last_istate_.reset();
-            internals_tls_p_.reset();
-            return;
-        }
-#endif
-        internals_singleton_pp_ = nullptr;
-    }
-
-    void destroy() {
-#ifdef PYBIND11_HAS_SUBINTERPRETER_SUPPORT
-        if (get_num_interpreters_seen() > 1) {
-            auto *tstate = get_thread_state_unchecked();
-            // this could be called without an active interpreter, just use what was cached
-            if (!tstate || tstate->interp == last_istate_.get()) {
-                auto tpp = internals_tls_p_.get();
-                if (tpp) {
-                    delete tpp;
-                }
-            }
-            unref();
-            return;
-        }
-#endif
-        delete internals_singleton_pp_;
-        unref();
-    }
-
-private:
-    std::unique_ptr<InternalsType> *get_or_create_pp_in_state_dict() {
-        error_scope err_scope;
-        dict state_dict = get_python_state_dict();
-        auto internals_obj
-            = reinterpret_steal<object>(dict_getitemstringref(state_dict.ptr(), holder_id_));
-        std::unique_ptr<InternalsType> *pp = nullptr;
-        if (internals_obj) {
-            void *raw_ptr = PyCapsule_GetPointer(internals_obj.ptr(), /*name=*/nullptr);
-            if (!raw_ptr) {
-                raise_from(PyExc_SystemError,
-                           "pybind11::detail::internals_pp_manager::get_pp_from_dict() FAILED");
-                throw error_already_set();
-            }
-            pp = reinterpret_cast<std::unique_ptr<InternalsType> *>(raw_ptr);
-            if (on_fetch_ && pp) {
-                on_fetch_(pp->get());
-            }
-        } else {
-            pp = new std::unique_ptr<InternalsType>;
-            // NOLINTNEXTLINE(bugprone-casting-through-void)
-            state_dict[holder_id_] = capsule(reinterpret_cast<void *>(pp));
-        }
-        return pp;
-    }
-
-    char const *holder_id_ = nullptr;
-    on_fetch_function *on_fetch_ = nullptr;
-#ifdef PYBIND11_HAS_SUBINTERPRETER_SUPPORT
-    thread_specific_storage<PyInterpreterState> last_istate_;
-    thread_specific_storage<std::unique_ptr<InternalsType>> internals_tls_p_;
-#endif
-    std::unique_ptr<InternalsType> *internals_singleton_pp_;
-};
-
-// If We loaded the internals through `state_dict`, our `error_already_set`
-// and `builtin_exception` may be different local classes than the ones set up in the
-// initial exception translator, below, so add another for our local exception classes.
-//
-// libstdc++ doesn't require this (types there are identified only by name)
-// libc++ with CPython doesn't require this (types are explicitly exported)
-// libc++ with PyPy still need it, awaiting further investigation
-#if !defined(__GLIBCXX__)
-inline void check_internals_local_exception_translator(internals *internals_ptr) {
-    if (internals_ptr) {
-        for (auto et : internals_ptr->registered_exception_translators) {
-            if (et == &translate_local_exception) {
-                return;
-            }
-        }
-        internals_ptr->registered_exception_translators.push_front(&translate_local_exception);
-    }
-}
-#endif
-
-inline internals_pp_manager<internals> &get_internals_pp_manager() {
-#if defined(__GLIBCXX__)
-#    define ON_FETCH_FN nullptr
-#else
-#    define ON_FETCH_FN &check_internals_local_exception_translator
-#endif
-    static internals_pp_manager<internals> internals_pp_manager(PYBIND11_INTERNALS_ID,
-                                                                ON_FETCH_FN);
-#undef ON_FETCH_FN
-    return internals_pp_manager;
-}
-
-/// Return a reference to the current `internals` data
-PYBIND11_NOINLINE internals &get_internals() {
-    auto &ppmgr = get_internals_pp_manager();
-    auto &internals_ptr = *ppmgr.get_pp();
-    if (!internals_ptr) {
-        // Slow path, something needs fetched from the state dict or created
-        gil_scoped_acquire_simple gil;
-        error_scope err_scope;
-        internals_ptr.reset(new internals());
-
-        if (!internals_ptr->instance_base) {
-            // This calls get_internals, so cannot be called from within the internals constructor
-            // called above because internals_ptr must be set before get_internals is called again
-            internals_ptr->instance_base = make_object_base_type(internals_ptr->default_metaclass);
-        }
-    }
-    return *internals_ptr;
-}
-
-inline internals_pp_manager<local_internals> &get_local_internals_pp_manager() {
-    // Use the address of this static itself as part of the key, so that the value is uniquely tied
-    // to where the module is loaded in memory
-    static const std::string this_module_idstr
-        = PYBIND11_MODULE_LOCAL_ID
-          + std::to_string(reinterpret_cast<uintptr_t>(&this_module_idstr));
-    static internals_pp_manager<local_internals> local_internals_pp_manager(
-        this_module_idstr.c_str(), nullptr);
-    return local_internals_pp_manager;
-}
-
-/// Works like `get_internals`, but for things which are locally registered.
-inline local_internals &get_local_internals() {
-    auto &ppmgr = get_local_internals_pp_manager();
-    auto &internals_ptr = *ppmgr.get_pp();
-    if (!internals_ptr) {
-        internals_ptr.reset(new local_internals());
-    }
-    return *internals_ptr;
-}
-
-#ifdef Py_GIL_DISABLED
-#    define PYBIND11_LOCK_INTERNALS(internals) std::unique_lock<pymutex> lock((internals).mutex)
-#else
-#    define PYBIND11_LOCK_INTERNALS(internals)
-#endif
-
-template <typename F>
-inline auto with_internals(const F &cb) -> decltype(cb(get_internals())) {
-    auto &internals = get_internals();
-    PYBIND11_LOCK_INTERNALS(internals);
-    return cb(internals);
-}
-
-template <typename F>
-inline auto with_exception_translators(const F &cb)
-    -> decltype(cb(get_internals().registered_exception_translators,
-                   get_local_internals().registered_exception_translators)) {
-    auto &internals = get_internals();
-#ifdef Py_GIL_DISABLED
-    std::unique_lock<pymutex> lock((internals).exception_translator_mutex);
-#endif
-    auto &local_internals = get_local_internals();
-    return cb(internals.registered_exception_translators,
-              local_internals.registered_exception_translators);
-}
-
-inline std::uint64_t mix64(std::uint64_t z) {
-    // David Stafford's variant 13 of the MurmurHash3 finalizer popularized
-    // by the SplitMix PRNG.
-    // https://zimbry.blogspot.com/2011/09/better-bit-mixing-improving-on.html
-    z = (z ^ (z >> 30)) * 0xbf58476d1ce4e5b9;
-    z = (z ^ (z >> 27)) * 0x94d049bb133111eb;
-    return z ^ (z >> 31);
-}
-
-template <typename F>
-inline auto with_instance_map(const void *ptr, const F &cb)
-    -> decltype(cb(std::declval<instance_map &>())) {
-    auto &internals = get_internals();
-
-#ifdef Py_GIL_DISABLED
-    // Hash address to compute shard, but ignore low bits. We'd like allocations
-    // from the same thread/core to map to the same shard and allocations from
-    // other threads/cores to map to other shards. Using the high bits is a good
-    // heuristic because memory allocators often have a per-thread
-    // arena/superblock/segment from which smaller allocations are served.
-    auto addr = reinterpret_cast<std::uintptr_t>(ptr);
-    auto hash = mix64(static_cast<std::uint64_t>(addr >> 20));
-    auto idx = static_cast<size_t>(hash & internals.instance_shards_mask);
-
-    auto &shard = internals.instance_shards[idx];
-    std::unique_lock<pymutex> lock(shard.mutex);
-    return cb(shard.registered_instances);
-#else
-    (void) ptr;
-    return cb(internals.registered_instances);
-#endif
-}
-
-// Returns the number of registered instances for testing purposes.  The result may not be
-// consistent if other threads are registering or unregistering instances concurrently.
-inline size_t num_registered_instances() {
-    auto &internals = get_internals();
-#ifdef Py_GIL_DISABLED
-    size_t count = 0;
-    for (size_t i = 0; i <= internals.instance_shards_mask; ++i) {
-        auto &shard = internals.instance_shards[i];
-        std::unique_lock<pymutex> lock(shard.mutex);
-        count += shard.registered_instances.size();
-    }
-    return count;
-#else
-    return internals.registered_instances.size();
-#endif
-}
-
-/// Constructs a std::string with the given arguments, stores it in `internals`, and returns its
-/// `c_str()`.  Such strings objects have a long storage duration -- the internal strings are only
-/// cleared when the program exits or after interpreter shutdown (when embedding), and so are
-/// suitable for c-style strings needed by Python internals (such as PyTypeObject's tp_name).
-template <typename... Args>
-const char *c_str(Args &&...args) {
-    // GCC 4.8 doesn't like parameter unpack within lambda capture, so use
-    // PYBIND11_LOCK_INTERNALS.
-    auto &internals = get_internals();
-    PYBIND11_LOCK_INTERNALS(internals);
-    auto &strings = internals.static_strings;
-    strings.emplace_front(std::forward<Args>(args)...);
-    return strings.front().c_str();
-}
-
-PYBIND11_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.
-PYBIND11_NOINLINE void *get_shared_data(const std::string &name) {
-    return detail::with_internals([&](detail::internals &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()`.
-PYBIND11_NOINLINE void *set_shared_data(const std::string &name, void *data) {
-    return detail::with_internals([&](detail::internals &internals) {
-        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) {
-    return *detail::with_internals([&](detail::internals &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;
-    });
-}
-
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/detail/native_enum_data.h

@@ -1,209 +0,0 @@
-// Copyright (c) 2022-2025 The pybind Community.
-// 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 "common.h"
-#include "internals.h"
-
-#include <cassert>
-#include <sstream>
-#include <string>
-#include <typeindex>
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-// This is a separate function only to enable easy unit testing.
-inline std::string
-native_enum_missing_finalize_error_message(const std::string &enum_name_encoded) {
-    return "pybind11::native_enum<...>(\"" + enum_name_encoded + "\", ...): MISSING .finalize()";
-}
-
-class native_enum_data {
-public:
-    native_enum_data(const object &parent_scope,
-                     const char *enum_name,
-                     const char *native_type_name,
-                     const char *class_doc,
-                     const std::type_index &enum_type_index)
-        : enum_name_encoded{enum_name}, native_type_name_encoded{native_type_name},
-          enum_type_index{enum_type_index}, parent_scope(parent_scope), enum_name{enum_name},
-          native_type_name{native_type_name}, class_doc(class_doc), export_values_flag{false},
-          finalize_needed{false} {}
-
-    void finalize();
-
-    native_enum_data(const native_enum_data &) = delete;
-    native_enum_data &operator=(const native_enum_data &) = delete;
-
-#if !defined(NDEBUG)
-    // This dtor cannot easily be unit tested because it terminates the process.
-    ~native_enum_data() {
-        if (finalize_needed) {
-            pybind11_fail(native_enum_missing_finalize_error_message(enum_name_encoded));
-        }
-    }
-#endif
-
-protected:
-    void disarm_finalize_check(const char *error_context) {
-        if (!finalize_needed) {
-            pybind11_fail("pybind11::native_enum<...>(\"" + enum_name_encoded
-                          + "\"): " + error_context);
-        }
-        finalize_needed = false;
-    }
-
-    void arm_finalize_check() {
-        assert(!finalize_needed); // Catch redundant calls.
-        finalize_needed = true;
-    }
-
-    std::string enum_name_encoded;
-    std::string native_type_name_encoded;
-    std::type_index enum_type_index;
-
-private:
-    object parent_scope;
-    str enum_name;
-    str native_type_name;
-    std::string class_doc;
-
-protected:
-    list members;
-    list member_docs;
-    bool export_values_flag : 1; // Attention: It is best to keep the bools together.
-
-private:
-    bool finalize_needed : 1;
-};
-
-inline void global_internals_native_enum_type_map_set_item(const std::type_index &enum_type_index,
-                                                           PyObject *py_enum) {
-    with_internals(
-        [&](internals &internals) { internals.native_enum_type_map[enum_type_index] = py_enum; });
-}
-
-inline handle
-global_internals_native_enum_type_map_get_item(const std::type_index &enum_type_index) {
-    return with_internals([&](internals &internals) {
-        auto found = internals.native_enum_type_map.find(enum_type_index);
-        if (found != internals.native_enum_type_map.end()) {
-            return handle(found->second);
-        }
-        return handle();
-    });
-}
-
-inline bool
-global_internals_native_enum_type_map_contains(const std::type_index &enum_type_index) {
-    return with_internals([&](internals &internals) {
-        return internals.native_enum_type_map.count(enum_type_index) != 0;
-    });
-}
-
-inline object import_or_getattr(const std::string &fully_qualified_name,
-                                const std::string &append_to_exception_message) {
-    std::istringstream stream(fully_qualified_name);
-    std::string part;
-
-    if (!std::getline(stream, part, '.') || part.empty()) {
-        std::string msg = "Invalid fully-qualified name `";
-        msg += fully_qualified_name;
-        msg += "`";
-        msg += append_to_exception_message;
-        throw value_error(msg);
-    }
-
-    auto curr_scope = reinterpret_steal<object>(PyImport_ImportModule(part.c_str()));
-    if (!curr_scope) {
-        std::string msg = "Failed to import top-level module `";
-        msg += part;
-        msg += "`";
-        msg += append_to_exception_message;
-        raise_from(PyExc_ImportError, msg.c_str());
-        throw error_already_set();
-    }
-
-    // Now recursively getattr or import remaining parts
-    std::string curr_path = part;
-    while (std::getline(stream, part, '.')) {
-        if (part.empty()) {
-            std::string msg = "Invalid fully-qualified name `";
-            msg += fully_qualified_name;
-            msg += "`";
-            msg += append_to_exception_message;
-            throw value_error(msg);
-        }
-        std::string next_path = curr_path;
-        next_path += ".";
-        next_path += part;
-        auto next_scope
-            = reinterpret_steal<object>(PyObject_GetAttrString(curr_scope.ptr(), part.c_str()));
-        if (!next_scope) {
-            error_fetch_and_normalize stored_getattr_error("getattr");
-            // Try importing the next level
-            next_scope = reinterpret_steal<object>(PyImport_ImportModule(next_path.c_str()));
-            if (!next_scope) {
-                error_fetch_and_normalize stored_import_error("import");
-                std::string msg = "Failed to import or getattr `";
-                msg += part;
-                msg += "` from `";
-                msg += curr_path;
-                msg += "`";
-                msg += append_to_exception_message;
-                msg += "\n-------- getattr exception --------\n";
-                msg += stored_getattr_error.error_string();
-                msg += "\n-------- import exception --------\n";
-                msg += stored_import_error.error_string();
-                throw import_error(msg.c_str());
-            }
-        }
-        curr_scope = next_scope;
-        curr_path = next_path;
-    }
-    return curr_scope;
-}
-
-inline void native_enum_data::finalize() {
-    disarm_finalize_check("DOUBLE finalize");
-    if (hasattr(parent_scope, enum_name)) {
-        pybind11_fail("pybind11::native_enum<...>(\"" + enum_name_encoded
-                      + "\"): an object with that name is already defined");
-    }
-    auto py_enum_type = import_or_getattr(native_type_name, " (native_type_name)");
-    auto py_enum = py_enum_type(enum_name, members);
-    object module_name = get_module_name_if_available(parent_scope);
-    if (module_name) {
-        py_enum.attr("__module__") = module_name;
-    }
-    if (hasattr(parent_scope, "__qualname__")) {
-        const auto parent_qualname = parent_scope.attr("__qualname__").cast<std::string>();
-        py_enum.attr("__qualname__") = str(parent_qualname + "." + enum_name.cast<std::string>());
-    }
-    parent_scope.attr(enum_name) = py_enum;
-    if (export_values_flag) {
-        for (auto member : members) {
-            auto member_name = member[int_(0)];
-            if (hasattr(parent_scope, member_name)) {
-                pybind11_fail("pybind11::native_enum<...>(\"" + enum_name_encoded + "\").value(\""
-                              + member_name.cast<std::string>()
-                              + "\"): an object with that name is already defined");
-            }
-            parent_scope.attr(member_name) = py_enum[member_name];
-        }
-    }
-    if (!class_doc.empty()) {
-        py_enum.attr("__doc__") = class_doc.c_str();
-    }
-    for (auto doc : member_docs) {
-        py_enum[doc[int_(0)]].attr("__doc__") = doc[int_(1)];
-    }
-    global_internals_native_enum_type_map_set_item(enum_type_index, py_enum.release().ptr());
-}
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/detail/pybind11_namespace_macros.h

@@ -1,82 +0,0 @@
-// Copyright (c) 2016-2025 The Pybind Development Team.
-// 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
-
-// PLEASE DO NOT ADD ANY INCLUDES HERE
-
-// Define some generic pybind11 helper macros for warning management.
-//
-// Note that compiler-specific push/pop pairs are baked into the
-// PYBIND11_NAMESPACE_BEGIN/PYBIND11_NAMESPACE_END pair of macros. Therefore manual
-// PYBIND11_WARNING_PUSH/PYBIND11_WARNING_POP are usually only needed in `#include` sections.
-//
-// If you find you need to suppress a warning, please try to make the suppression as local as
-// possible using these macros. Please also be sure to push/pop with the pybind11 macros. Please
-// only use compiler specifics if you need to check specific versions, e.g. Apple Clang vs. vanilla
-// Clang.
-#if defined(_MSC_VER)
-#    define PYBIND11_COMPILER_MSVC
-#    define PYBIND11_PRAGMA(...) __pragma(__VA_ARGS__)
-#    define PYBIND11_WARNING_PUSH PYBIND11_PRAGMA(warning(push))
-#    define PYBIND11_WARNING_POP PYBIND11_PRAGMA(warning(pop))
-#elif defined(__INTEL_COMPILER)
-#    define PYBIND11_COMPILER_INTEL
-#    define PYBIND11_PRAGMA(...) _Pragma(#__VA_ARGS__)
-#    define PYBIND11_WARNING_PUSH PYBIND11_PRAGMA(warning push)
-#    define PYBIND11_WARNING_POP PYBIND11_PRAGMA(warning pop)
-#elif defined(__clang__)
-#    define PYBIND11_COMPILER_CLANG
-#    define PYBIND11_PRAGMA(...) _Pragma(#__VA_ARGS__)
-#    define PYBIND11_WARNING_PUSH PYBIND11_PRAGMA(clang diagnostic push)
-#    define PYBIND11_WARNING_POP PYBIND11_PRAGMA(clang diagnostic pop)
-#elif defined(__GNUC__)
-#    define PYBIND11_COMPILER_GCC
-#    define PYBIND11_PRAGMA(...) _Pragma(#__VA_ARGS__)
-#    define PYBIND11_WARNING_PUSH PYBIND11_PRAGMA(GCC diagnostic push)
-#    define PYBIND11_WARNING_POP PYBIND11_PRAGMA(GCC diagnostic pop)
-#endif
-
-#ifdef PYBIND11_COMPILER_MSVC
-#    define PYBIND11_WARNING_DISABLE_MSVC(name) PYBIND11_PRAGMA(warning(disable : name))
-#else
-#    define PYBIND11_WARNING_DISABLE_MSVC(name)
-#endif
-
-#ifdef PYBIND11_COMPILER_CLANG
-#    define PYBIND11_WARNING_DISABLE_CLANG(name) PYBIND11_PRAGMA(clang diagnostic ignored name)
-#else
-#    define PYBIND11_WARNING_DISABLE_CLANG(name)
-#endif
-
-#ifdef PYBIND11_COMPILER_GCC
-#    define PYBIND11_WARNING_DISABLE_GCC(name) PYBIND11_PRAGMA(GCC diagnostic ignored name)
-#else
-#    define PYBIND11_WARNING_DISABLE_GCC(name)
-#endif
-
-#ifdef PYBIND11_COMPILER_INTEL
-#    define PYBIND11_WARNING_DISABLE_INTEL(name) PYBIND11_PRAGMA(warning disable name)
-#else
-#    define PYBIND11_WARNING_DISABLE_INTEL(name)
-#endif
-
-#define PYBIND11_NAMESPACE_BEGIN(name)                                                            \
-    namespace name {                                                                              \
-    PYBIND11_WARNING_PUSH
-
-#define PYBIND11_NAMESPACE_END(name)                                                              \
-    PYBIND11_WARNING_POP                                                                          \
-    }
-
-// Robust support for some features and loading modules compiled against different pybind versions
-// requires forcing hidden visibility on pybind code, so we enforce this by setting the attribute
-// on the main `pybind11` namespace.
-#if !defined(PYBIND11_NAMESPACE)
-#    if defined(__GNUG__) && !defined(_WIN32)
-#        define PYBIND11_NAMESPACE pybind11 __attribute__((visibility("hidden")))
-#    else
-#        define PYBIND11_NAMESPACE pybind11
-#    endif
-#endif

deps_src/pybind11/include/pybind11/detail/struct_smart_holder.h

@@ -1,378 +0,0 @@
-// Copyright (c) 2020-2024 The Pybind Development Team.
-// All rights reserved. Use of this source code is governed by a
-// BSD-style license that can be found in the LICENSE file.
-
-/* Proof-of-Concept for smart pointer interoperability.
-
-High-level aspects:
-
-* Support all `unique_ptr`, `shared_ptr` interops that are feasible.
-
-* Cleanly and clearly report all interops that are infeasible.
-
-* Meant to fit into a `PyObject`, as a holder for C++ objects.
-
-* Support a system design that makes it impossible to trigger
-  C++ Undefined Behavior, especially from Python.
-
-* Support a system design with clean runtime inheritance casting. From this
-  it follows that the `smart_holder` needs to be type-erased (`void*`).
-
-* Handling of RTTI for the type-erased held pointer is NOT implemented here.
-  It is the responsibility of the caller to ensure that `static_cast<T *>`
-  is well-formed when calling `as_*` member functions. Inheritance casting
-  needs to be handled in a different layer (similar to the code organization
-  in boost/python/object/inheritance.hpp).
-
-Details:
-
-* The "root holder" chosen here is a `shared_ptr<void>` (named `vptr` in this
-  implementation). This choice is practically inevitable because `shared_ptr`
-  has only very limited support for inspecting and accessing its deleter.
-
-* If created from a raw pointer, or a `unique_ptr` without a custom deleter,
-  `vptr` always uses a custom deleter, to support `unique_ptr`-like disowning.
-  The custom deleters could be extended to included life-time management for
-  external objects (e.g. `PyObject`).
-
-* If created from an external `shared_ptr`, or a `unique_ptr` with a custom
-  deleter, including life-time management for external objects is infeasible.
-
-* By choice, the smart_holder is movable but not copyable, to keep the design
-  simple, and to guard against accidental copying overhead.
-
-* The `void_cast_raw_ptr` option is needed to make the `smart_holder` `vptr`
-  member invisible to the `shared_from_this` mechanism, in case the lifetime
-  of a `PyObject` is tied to the pointee.
-*/
-
-#pragma once
-
-#include "pybind11_namespace_macros.h"
-
-#include <cstring>
-#include <functional>
-#include <memory>
-#include <stdexcept>
-#include <string>
-#include <type_traits>
-#include <typeinfo>
-#include <utility>
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(memory)
-
-// Default fallback.
-static constexpr bool type_has_shared_from_this(...) { return false; }
-
-// This overload uses SFINAE to skip enable_shared_from_this checks when the
-// base is inaccessible (e.g. private inheritance).
-template <typename T>
-static auto type_has_shared_from_this(const T *ptr)
-    -> decltype(static_cast<const std::enable_shared_from_this<T> *>(ptr), true) {
-    return true;
-}
-
-// Inaccessible base → substitution failure → fallback overload selected
-template <typename T>
-static constexpr bool type_has_shared_from_this(const void *) {
-    return false;
-}
-
-struct guarded_delete {
-    // NOTE: PYBIND11_INTERNALS_VERSION needs to be bumped if changes are made to this struct.
-    std::weak_ptr<void> released_ptr;    // Trick to keep the smart_holder memory footprint small.
-    std::function<void(void *)> del_fun; // Rare case.
-    void (*del_ptr)(void *);             // Common case.
-    bool use_del_fun;
-    bool armed_flag;
-    guarded_delete(std::function<void(void *)> &&del_fun, bool armed_flag)
-        : del_fun{std::move(del_fun)}, del_ptr{nullptr}, use_del_fun{true},
-          armed_flag{armed_flag} {}
-    guarded_delete(void (*del_ptr)(void *), bool armed_flag)
-        : del_ptr{del_ptr}, use_del_fun{false}, armed_flag{armed_flag} {}
-    void operator()(void *raw_ptr) const {
-        if (armed_flag) {
-            if (use_del_fun) {
-                del_fun(raw_ptr);
-            } else {
-                del_ptr(raw_ptr);
-            }
-        }
-    }
-};
-
-inline guarded_delete *get_guarded_delete(const std::shared_ptr<void> &ptr) {
-    return std::get_deleter<guarded_delete>(ptr);
-}
-
-using get_guarded_delete_fn = guarded_delete *(*) (const std::shared_ptr<void> &);
-
-template <typename T, typename std::enable_if<std::is_destructible<T>::value, int>::type = 0>
-inline void std_default_delete_if_destructible(void *raw_ptr) {
-    std::default_delete<T>{}(static_cast<T *>(raw_ptr));
-}
-
-template <typename T, typename std::enable_if<!std::is_destructible<T>::value, int>::type = 0>
-inline void std_default_delete_if_destructible(void *) {
-    // This noop operator is needed to avoid a compilation error (for `delete raw_ptr;`), but
-    // throwing an exception from a destructor will std::terminate the process. Therefore the
-    // runtime check for lifetime-management correctness is implemented elsewhere (in
-    // ensure_pointee_is_destructible()).
-}
-
-template <typename T>
-guarded_delete make_guarded_std_default_delete(bool armed_flag) {
-    return guarded_delete(std_default_delete_if_destructible<T>, armed_flag);
-}
-
-template <typename T, typename D>
-struct custom_deleter {
-    // NOTE: PYBIND11_INTERNALS_VERSION needs to be bumped if changes are made to this struct.
-    D deleter;
-    explicit custom_deleter(D &&deleter) : deleter{std::forward<D>(deleter)} {}
-    void operator()(void *raw_ptr) { deleter(static_cast<T *>(raw_ptr)); }
-};
-
-template <typename T, typename D>
-guarded_delete make_guarded_custom_deleter(D &&uqp_del, bool armed_flag) {
-    return guarded_delete(
-        std::function<void(void *)>(custom_deleter<T, D>(std::forward<D>(uqp_del))), armed_flag);
-}
-
-template <typename T, typename D>
-constexpr bool uqp_del_is_std_default_delete() {
-    return std::is_same<D, std::default_delete<T>>::value
-           || std::is_same<D, std::default_delete<T const>>::value;
-}
-
-inline bool type_info_equal_across_dso_boundaries(const std::type_info &a,
-                                                  const std::type_info &b) {
-    // RTTI pointer comparison may fail across DSOs (e.g., macOS libc++).
-    // Fallback to name comparison, which is generally safe and ABI-stable enough for our use.
-    return a == b || std::strcmp(a.name(), b.name()) == 0;
-}
-
-struct smart_holder {
-    // NOTE: PYBIND11_INTERNALS_VERSION needs to be bumped if changes are made to this struct.
-    const std::type_info *rtti_uqp_del = nullptr;
-    std::shared_ptr<void> vptr;
-    bool vptr_is_using_noop_deleter : 1;
-    bool vptr_is_using_std_default_delete : 1;
-    bool vptr_is_external_shared_ptr : 1;
-    bool is_populated : 1;
-    bool is_disowned : 1;
-
-    // Design choice: smart_holder is movable but not copyable.
-    smart_holder(smart_holder &&) = default;
-    smart_holder(const smart_holder &) = delete;
-    smart_holder &operator=(smart_holder &&) = delete;
-    smart_holder &operator=(const smart_holder &) = delete;
-
-    smart_holder()
-        : vptr_is_using_noop_deleter{false}, vptr_is_using_std_default_delete{false},
-          vptr_is_external_shared_ptr{false}, is_populated{false}, is_disowned{false} {}
-
-    bool has_pointee() const { return vptr != nullptr; }
-
-    template <typename T>
-    static void ensure_pointee_is_destructible(const char *context) {
-        if (!std::is_destructible<T>::value) {
-            throw std::invalid_argument(std::string("Pointee is not destructible (") + context
-                                        + ").");
-        }
-    }
-
-    void ensure_is_populated(const char *context) const {
-        if (!is_populated) {
-            throw std::runtime_error(std::string("Unpopulated holder (") + context + ").");
-        }
-    }
-    void ensure_is_not_disowned(const char *context) const {
-        if (is_disowned) {
-            throw std::runtime_error(std::string("Holder was disowned already (") + context
-                                     + ").");
-        }
-    }
-
-    void ensure_vptr_is_using_std_default_delete(const char *context) const {
-        if (vptr_is_external_shared_ptr) {
-            throw std::invalid_argument(std::string("Cannot disown external shared_ptr (")
-                                        + context + ").");
-        }
-        if (vptr_is_using_noop_deleter) {
-            throw std::invalid_argument(std::string("Cannot disown non-owning holder (") + context
-                                        + ").");
-        }
-        if (!vptr_is_using_std_default_delete) {
-            throw std::invalid_argument(std::string("Cannot disown custom deleter (") + context
-                                        + ").");
-        }
-    }
-
-    template <typename T, typename D>
-    void ensure_compatible_uqp_del(const char *context) const {
-        if (!rtti_uqp_del) {
-            if (!uqp_del_is_std_default_delete<T, D>()) {
-                throw std::invalid_argument(std::string("Missing unique_ptr deleter (") + context
-                                            + ").");
-            }
-            ensure_vptr_is_using_std_default_delete(context);
-            return;
-        }
-        if (uqp_del_is_std_default_delete<T, D>() && vptr_is_using_std_default_delete) {
-            return;
-        }
-        if (!type_info_equal_across_dso_boundaries(typeid(D), *rtti_uqp_del)) {
-            throw std::invalid_argument(std::string("Incompatible unique_ptr deleter (") + context
-                                        + ").");
-        }
-    }
-
-    void ensure_has_pointee(const char *context) const {
-        if (!has_pointee()) {
-            throw std::invalid_argument(std::string("Disowned holder (") + context + ").");
-        }
-    }
-
-    void ensure_use_count_1(const char *context) const {
-        if (vptr == nullptr) {
-            throw std::invalid_argument(std::string("Cannot disown nullptr (") + context + ").");
-        }
-        // In multithreaded environments accessing use_count can lead to
-        // race conditions, but in the context of Python it is a bug (elsewhere)
-        // if the Global Interpreter Lock (GIL) is not being held when this code
-        // is reached.
-        // PYBIND11:REMINDER: This may need to be protected by a mutex in free-threaded Python.
-        if (vptr.use_count() != 1) {
-            throw std::invalid_argument(std::string("Cannot disown use_count != 1 (") + context
-                                        + ").");
-        }
-    }
-
-    void reset_vptr_deleter_armed_flag(const get_guarded_delete_fn ggd_fn, bool armed_flag) const {
-        auto *gd = ggd_fn(vptr);
-        if (gd == nullptr) {
-            throw std::runtime_error(
-                "smart_holder::reset_vptr_deleter_armed_flag() called in an invalid context.");
-        }
-        gd->armed_flag = armed_flag;
-    }
-
-    // Caller is responsible for precondition: ensure_compatible_uqp_del<T, D>() must succeed.
-    template <typename T, typename D>
-    std::unique_ptr<D> extract_deleter(const char *context,
-                                       const get_guarded_delete_fn ggd_fn) const {
-        auto *gd = ggd_fn(vptr);
-        if (gd && gd->use_del_fun) {
-            const auto &custom_deleter_ptr = gd->del_fun.template target<custom_deleter<T, D>>();
-            if (custom_deleter_ptr == nullptr) {
-                throw std::runtime_error(
-                    std::string("smart_holder::extract_deleter() precondition failure (") + context
-                    + ").");
-            }
-            static_assert(std::is_copy_constructible<D>::value,
-                          "Required for compatibility with smart_holder functionality.");
-            return std::unique_ptr<D>(new D(custom_deleter_ptr->deleter));
-        }
-        return nullptr;
-    }
-
-    static smart_holder from_raw_ptr_unowned(void *raw_ptr) {
-        smart_holder hld;
-        hld.vptr.reset(raw_ptr, [](void *) {});
-        hld.vptr_is_using_noop_deleter = true;
-        hld.is_populated = true;
-        return hld;
-    }
-
-    template <typename T>
-    T *as_raw_ptr_unowned() const {
-        return static_cast<T *>(vptr.get());
-    }
-
-    template <typename T>
-    static smart_holder from_raw_ptr_take_ownership(T *raw_ptr, bool void_cast_raw_ptr = false) {
-        ensure_pointee_is_destructible<T>("from_raw_ptr_take_ownership");
-        smart_holder hld;
-        auto gd = make_guarded_std_default_delete<T>(true);
-        if (void_cast_raw_ptr) {
-            hld.vptr.reset(static_cast<void *>(raw_ptr), std::move(gd));
-        } else {
-            hld.vptr.reset(raw_ptr, std::move(gd));
-        }
-        hld.vptr_is_using_std_default_delete = true;
-        hld.is_populated = true;
-        return hld;
-    }
-
-    // Caller is responsible for ensuring the complex preconditions
-    // (see `smart_holder_type_caster_support::load_helper`).
-    void disown(const get_guarded_delete_fn ggd_fn) {
-        reset_vptr_deleter_armed_flag(ggd_fn, false);
-        is_disowned = true;
-    }
-
-    // Caller is responsible for ensuring the complex preconditions
-    // (see `smart_holder_type_caster_support::load_helper`).
-    void reclaim_disowned(const get_guarded_delete_fn ggd_fn) {
-        reset_vptr_deleter_armed_flag(ggd_fn, true);
-        is_disowned = false;
-    }
-
-    // Caller is responsible for ensuring the complex preconditions
-    // (see `smart_holder_type_caster_support::load_helper`).
-    void release_disowned() { vptr.reset(); }
-
-    void ensure_can_release_ownership(const char *context = "ensure_can_release_ownership") const {
-        ensure_is_not_disowned(context);
-        ensure_vptr_is_using_std_default_delete(context);
-        ensure_use_count_1(context);
-    }
-
-    // Caller is responsible for ensuring the complex preconditions
-    // (see `smart_holder_type_caster_support::load_helper`).
-    void release_ownership(const get_guarded_delete_fn ggd_fn) {
-        reset_vptr_deleter_armed_flag(ggd_fn, false);
-        release_disowned();
-    }
-
-    template <typename T, typename D>
-    static smart_holder from_unique_ptr(std::unique_ptr<T, D> &&unq_ptr,
-                                        void *void_ptr = nullptr) {
-        smart_holder hld;
-        hld.rtti_uqp_del = &typeid(D);
-        hld.vptr_is_using_std_default_delete = uqp_del_is_std_default_delete<T, D>();
-        guarded_delete gd{nullptr, false};
-        if (hld.vptr_is_using_std_default_delete) {
-            gd = make_guarded_std_default_delete<T>(true);
-        } else {
-            gd = make_guarded_custom_deleter<T, D>(std::move(unq_ptr.get_deleter()), true);
-        }
-        if (void_ptr != nullptr) {
-            hld.vptr.reset(void_ptr, std::move(gd));
-        } else {
-            hld.vptr.reset(unq_ptr.get(), std::move(gd));
-        }
-        (void) unq_ptr.release();
-        hld.is_populated = true;
-        return hld;
-    }
-
-    template <typename T>
-    static smart_holder from_shared_ptr(const std::shared_ptr<T> &shd_ptr) {
-        smart_holder hld;
-        hld.vptr = std::static_pointer_cast<void>(shd_ptr);
-        hld.vptr_is_external_shared_ptr = true;
-        hld.is_populated = true;
-        return hld;
-    }
-
-    template <typename T>
-    std::shared_ptr<T> as_shared_ptr() const {
-        return std::static_pointer_cast<T>(vptr);
-    }
-};
-
-PYBIND11_NAMESPACE_END(memory)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/detail/typeid.h

@@ -1,65 +0,0 @@
-/*
-    pybind11/detail/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
-
-#include "common.h"
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-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 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::");
-}
-
-inline std::string clean_type_id(const char *typeid_name) {
-    std::string name(typeid_name);
-    detail::clean_type_id(name);
-    return name;
-}
-
-PYBIND11_NAMESPACE_END(detail)
-
-/// Return a string representation of a C++ type
-template <typename T>
-static std::string type_id() {
-    return detail::clean_type_id(typeid(T).name());
-}
-
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/detail/using_smart_holder.h

@@ -1,22 +0,0 @@
-// Copyright (c) 2024 The Pybind Development Team.
-// 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 "struct_smart_holder.h"
-
-#include <type_traits>
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-using pybind11::memory::smart_holder;
-
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-template <typename H>
-using is_smart_holder = std::is_same<H, smart_holder>;
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/detail/value_and_holder.h

@@ -1,90 +0,0 @@
-// Copyright (c) 2016-2024 The Pybind Development Team.
-// 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 <cstddef>
-#include <cstdint>
-#include <typeinfo>
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-struct value_and_holder {
-    instance *inst = nullptr;
-    size_t index = 0u;
-    const detail::type_info *type = nullptr;
-    void **vh = nullptr;
-
-    // Main constructor for a found value/holder:
-    value_and_holder(instance *i, const detail::type_info *type, size_t vpos, size_t index)
-        : inst{i}, index{index}, type{type},
-          vh{inst->simple_layout ? inst->simple_value_holder
-                                 : &inst->nonsimple.values_and_holders[vpos]} {}
-
-    // Default constructor (used to signal a value-and-holder not found by get_value_and_holder())
-    value_and_holder() = default;
-
-    // Used for past-the-end iterator
-    explicit value_and_holder(size_t index) : index{index} {}
-
-    template <typename V = void>
-    V *&value_ptr() const {
-        return reinterpret_cast<V *&>(vh[0]);
-    }
-    // True if this `value_and_holder` has a non-null value pointer
-    explicit operator bool() const { return value_ptr() != nullptr; }
-
-    template <typename H>
-    H &holder() const {
-        return reinterpret_cast<H &>(vh[1]);
-    }
-    bool holder_constructed() const {
-        return inst->simple_layout
-                   ? inst->simple_holder_constructed
-                   : (inst->nonsimple.status[index] & instance::status_holder_constructed) != 0u;
-    }
-    // NOLINTNEXTLINE(readability-make-member-function-const)
-    void set_holder_constructed(bool v = true) {
-        if (inst->simple_layout) {
-            inst->simple_holder_constructed = v;
-        } else if (v) {
-            inst->nonsimple.status[index] |= instance::status_holder_constructed;
-        } else {
-            inst->nonsimple.status[index] &= (std::uint8_t) ~instance::status_holder_constructed;
-        }
-    }
-    bool instance_registered() const {
-        return inst->simple_layout
-                   ? inst->simple_instance_registered
-                   : ((inst->nonsimple.status[index] & instance::status_instance_registered) != 0);
-    }
-    // NOLINTNEXTLINE(readability-make-member-function-const)
-    void set_instance_registered(bool v = true) {
-        if (inst->simple_layout) {
-            inst->simple_instance_registered = v;
-        } else if (v) {
-            inst->nonsimple.status[index] |= instance::status_instance_registered;
-        } else {
-            inst->nonsimple.status[index] &= (std::uint8_t) ~instance::status_instance_registered;
-        }
-    }
-};
-
-// This is a semi-public API to check if the corresponding instance has been constructed with a
-// holder. That is, if the instance has been constructed with a holder, the `__init__` method is
-// called and the C++ object is valid. Otherwise, the C++ object might only be allocated, but not
-// initialized. This will lead to **SEGMENTATION FAULTS** if the C++ object is used in any way.
-// Example usage: https://pybind11.readthedocs.io/en/stable/advanced/classes.html#custom-type-setup
-//                for `tp_traverse` and `tp_clear` implementations.
-// WARNING: The caller is responsible for ensuring that the `reinterpret_cast` is valid.
-inline bool is_holder_constructed(PyObject *obj) {
-    auto *const instance = reinterpret_cast<pybind11::detail::instance *>(obj);
-    return instance->get_value_and_holder().holder_constructed();
-}
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/eigen.h

@@ -1,12 +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 "eigen/matrix.h"

deps_src/pybind11/include/pybind11/eigen/common.h

@@ -1,9 +0,0 @@
-// Copyright (c) 2023 The pybind Community.
-
-#pragma once
-
-// Common message for `static_assert()`s, which are useful to easily
-// preempt much less obvious errors.
-#define PYBIND11_EIGEN_MESSAGE_POINTER_TYPES_ARE_NOT_SUPPORTED                                    \
-    "Pointer types (in particular `PyObject *`) are not supported as scalar types for Eigen "     \
-    "types."

deps_src/pybind11/include/pybind11/eigen/matrix.h

@@ -1,723 +0,0 @@
-/*
-    pybind11/eigen/matrix.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 <pybind11/numpy.h>
-
-#include "common.h"
-
-/* HINT: To suppress warnings originating from the Eigen headers, use -isystem.
-   See also:
-       https://stackoverflow.com/questions/2579576/i-dir-vs-isystem-dir
-       https://stackoverflow.com/questions/1741816/isystem-for-ms-visual-studio-c-compiler
-*/
-PYBIND11_WARNING_PUSH
-PYBIND11_WARNING_DISABLE_MSVC(5054) // https://github.com/pybind/pybind11/pull/3741
-//       C5054: operator '&': deprecated between enumerations of different types
-#if defined(__MINGW32__)
-PYBIND11_WARNING_DISABLE_GCC("-Wmaybe-uninitialized")
-#endif
-
-#include <Eigen/Core>
-#include <Eigen/SparseCore>
-
-PYBIND11_WARNING_POP
-
-// 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 matrix support in pybind11 requires Eigen >= 3.2.7");
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-PYBIND11_WARNING_DISABLE_MSVC(4127)
-
-// 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>;
-
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-#if EIGEN_VERSION_AT_LEAST(3, 3, 0)
-using EigenIndex = Eigen::Index;
-template <typename Scalar, int Flags, typename StorageIndex>
-using EigenMapSparseMatrix = Eigen::Map<Eigen::SparseMatrix<Scalar, Flags, StorageIndex>>;
-#else
-using EigenIndex = EIGEN_DEFAULT_DENSE_INDEX_TYPE;
-template <typename Scalar, int Flags, typename StorageIndex>
-using EigenMapSparseMatrix = Eigen::MappedSparseMatrix<Scalar, Flags, StorageIndex>;
-#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};    // Only valid if negativestrides is false!
-    bool negativestrides = false; // If true, do not use stride!
-
-    // NOLINTNEXTLINE(google-explicit-constructor)
-    EigenConformable(bool fits = false) : conformable{fits} {}
-    // Matrix type:
-    EigenConformable(EigenIndex r, EigenIndex c, EigenIndex rstride, EigenIndex cstride)
-        : conformable{true}, rows{r}, cols{c},
-          // TODO: when Eigen bug #747 is fixed, remove the tests for non-negativity.
-          // http://eigen.tuxfamily.org/bz/show_bug.cgi?id=747
-          stride{EigenRowMajor ? (rstride > 0 ? rstride : 0)
-                               : (cstride > 0 ? cstride : 0) /* outer stride */,
-                 EigenRowMajor ? (cstride > 0 ? cstride : 0)
-                               : (rstride > 0 ? rstride : 0) /* inner stride */},
-          negativestrides{rstride < 0 || cstride < 0} {}
-    // 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). Alternatively, if any dimension size is 0, the strides are not relevant
-        // (and numpy ≥ 1.23 sets the strides to 0 in that case, so we need to check explicitly).
-        if (negativestrides) {
-            return false;
-        }
-        if (rows == 0 || cols == 0) {
-            return true;
-        }
-        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);
-    }
-    // NOLINTNEXTLINE(google-explicit-constructor)
-    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) / static_cast<ssize_t>(sizeof(Scalar)),
-                       np_cstride = a.strides(1) / static_cast<ssize_t>(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) / static_cast<ssize_t>(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};
-        }
-        if (fixed) {
-            // The type has a fixed size, but is not a vector: abort
-            return false;
-        }
-        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};
-        } // 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 constexpr bool show_writeable
-        = is_eigen_dense_map<Type>::value && is_eigen_mutable_map<Type>::value;
-    static constexpr bool show_order = is_eigen_dense_map<Type>::value;
-    static constexpr bool show_c_contiguous = show_order && requires_row_major;
-    static constexpr bool show_f_contiguous
-        = !show_c_contiguous && show_order && requires_col_major;
-
-    static constexpr auto descriptor
-        = const_name("typing.Annotated[")
-          + io_name("numpy.typing.ArrayLike, ", "numpy.typing.NDArray[")
-          + npy_format_descriptor<Scalar>::name + io_name("", "]") + const_name(", \"[")
-          + const_name<fixed_rows>(const_name<(size_t) rows>(), const_name("m")) + const_name(", ")
-          + const_name<fixed_cols>(const_name<(size_t) cols>(), const_name("n"))
-          + const_name("]\"")
-          // 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
-          // 'typing.Annotated[numpy.typing.NDArray[numpy.float64], "[3,2]"]' and an error message
-          // that you *gave* a numpy.ndarray of the right type and dimensions.
-          + const_name<show_writeable>(", \"flags.writeable\"", "")
-          + const_name<show_c_contiguous>(", \"flags.c_contiguous\"", "")
-          + const_name<show_f_contiguous>(", \"flags.f_contiguous\"", "") + const_name("]");
-};
-
-// 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 ssize_t elem_size = sizeof(typename props::Scalar);
-    array a;
-    if (props::vector) {
-        a = array({src.size()}, {elem_size * src.innerStride()}, src.data(), base);
-    } else {
-        a = array({src.rows(), src.cols()},
-                  {elem_size * src.rowStride(), elem_size * src.colStride()},
-                  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;
-    static_assert(!std::is_pointer<Scalar>::value,
-                  PYBIND11_EIGEN_MESSAGE_POINTER_TYPES_ARE_NOT_SUPPORTED);
-    using props = EigenProps<Type>;
-
-    bool load(handle src, bool convert) {
-        // If we're in no-convert mode, only load if given an array of the correct type
-        if (!convert && !isinstance<array_t<Scalar>>(src)) {
-            return false;
-        }
-
-        // Coerce into an array, but don't do type conversion yet; the copy below handles it.
-        auto buf = array::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;
-        }
-
-        PYBIND11_WARNING_PUSH
-        PYBIND11_WARNING_DISABLE_GCC("-Wmaybe-uninitialized") // See PR #5516
-        // Allocate the new type, then build a numpy reference into it
-        value = Type(fits.rows, fits.cols);
-        PYBIND11_WARNING_POP
-        auto ref = reinterpret_steal<array>(eigen_ref_array<props>(value));
-        if (dims == 1) {
-            ref = ref.squeeze();
-        } else if (ref.ndim() == 1) {
-            buf = buf.squeeze();
-        }
-
-        int result = detail::npy_api::get().PyArray_CopyInto_(ref.ptr(), buf.ptr());
-
-        if (result < 0) { // Copy failed!
-            PyErr_Clear();
-            return false;
-        }
-
-        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 constexpr auto name = props::descriptor;
-
-    // NOLINTNEXTLINE(google-explicit-constructor)
-    operator Type *() { return &value; }
-    // NOLINTNEXTLINE(google-explicit-constructor)
-    operator Type &() { return value; }
-    // NOLINTNEXTLINE(google-explicit-constructor)
-    operator Type &&() && { return std::move(value); }
-    template <typename T>
-    using cast_op_type = movable_cast_op_type<T>;
-
-private:
-    Type value;
-};
-
-// Base class for casting reference/map/block/etc. objects back to python.
-template <typename MapType>
-struct eigen_map_caster {
-    static_assert(!std::is_pointer<typename MapType::Scalar>::value,
-                  PYBIND11_EIGEN_MESSAGE_POINTER_TYPES_ARE_NOT_SUPPORTED);
-
-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");
-        }
-    }
-
-    // return_descr forces the use of NDArray instead of ArrayLike in args
-    // since Ref<...> args can only accept arrays.
-    static constexpr auto name = return_descr(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;
-    static_assert(!std::is_pointer<Scalar>::value,
-                  PYBIND11_EIGEN_MESSAGE_POINTER_TYPES_ARE_NOT_SUPPORTED);
-    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
-            auto 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);
-            loader_life_support::add_patient(copy_or_ref);
-        }
-
-        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;
-    }
-
-    // NOLINTNEXTLINE(google-explicit-constructor)
-    operator Type *() { return ref.get(); }
-    // NOLINTNEXTLINE(google-explicit-constructor)
-    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>> {
-    static_assert(!std::is_pointer<typename Type::Scalar>::value,
-                  PYBIND11_EIGEN_MESSAGE_POINTER_TYPES_ARE_NOT_SUPPORTED);
-
-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 constexpr auto name = 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>> {
-    using Scalar = typename Type::Scalar;
-    static_assert(!std::is_pointer<Scalar>::value,
-                  PYBIND11_EIGEN_MESSAGE_POINTER_TYPES_ARE_NOT_SUPPORTED);
-    using StorageIndex = remove_reference_t<decltype(*std::declval<Type>().outerIndexPtr())>;
-    using Index = typename Type::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 (!type::handle_of(obj).is(matrix_type)) {
-            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 = EigenMapSparseMatrix<Scalar,
-                                     Type::Flags &(Eigen::RowMajor | Eigen::ColMajor),
-                                     StorageIndex>(shape[0].cast<Index>(),
-                                                   shape[1].cast<Index>(),
-                                                   std::move(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(src.nonZeros(), src.valuePtr());
-        array outerIndices((rowMajor ? src.rows() : src.cols()) + 1, src.outerIndexPtr());
-        array innerIndices(src.nonZeros(), src.innerIndexPtr());
-
-        return matrix_type(pybind11::make_tuple(
-                               std::move(data), std::move(innerIndices), std::move(outerIndices)),
-                           pybind11::make_tuple(src.rows(), src.cols()))
-            .release();
-    }
-
-    PYBIND11_TYPE_CASTER(Type,
-                         const_name<(Type::IsRowMajor) != 0>("scipy.sparse.csr_matrix[",
-                                                             "scipy.sparse.csc_matrix[")
-                             + npy_format_descriptor<Scalar>::name + const_name("]"));
-};
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/eigen/tensor.h

@@ -1,521 +0,0 @@
-/*
-    pybind11/eigen/tensor.h: Transparent conversion for Eigen tensors
-
-    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/numpy.h>
-
-#include "common.h"
-
-#if defined(__GNUC__) && !defined(__clang__) && !defined(__INTEL_COMPILER)
-static_assert(__GNUC__ > 5, "Eigen Tensor support in pybind11 requires GCC > 5.0");
-#endif
-
-// Disable warnings for Eigen
-PYBIND11_WARNING_PUSH
-PYBIND11_WARNING_DISABLE_MSVC(4554)
-PYBIND11_WARNING_DISABLE_MSVC(4127)
-#if defined(__MINGW32__)
-PYBIND11_WARNING_DISABLE_GCC("-Wmaybe-uninitialized")
-#endif
-
-#include <unsupported/Eigen/CXX11/Tensor>
-
-PYBIND11_WARNING_POP
-
-static_assert(EIGEN_VERSION_AT_LEAST(3, 3, 0),
-              "Eigen Tensor support in pybind11 requires Eigen >= 3.3.0");
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-PYBIND11_WARNING_DISABLE_MSVC(4127)
-
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-inline bool is_tensor_aligned(const void *data) {
-    return (reinterpret_cast<std::size_t>(data) % EIGEN_DEFAULT_ALIGN_BYTES) == 0;
-}
-
-template <typename T>
-constexpr int compute_array_flag_from_tensor() {
-    static_assert((static_cast<int>(T::Layout) == static_cast<int>(Eigen::RowMajor))
-                      || (static_cast<int>(T::Layout) == static_cast<int>(Eigen::ColMajor)),
-                  "Layout must be row or column major");
-    return (static_cast<int>(T::Layout) == static_cast<int>(Eigen::RowMajor)) ? array::c_style
-                                                                              : array::f_style;
-}
-
-template <typename T>
-struct eigen_tensor_helper {};
-
-template <typename Scalar_, int NumIndices_, int Options_, typename IndexType>
-struct eigen_tensor_helper<Eigen::Tensor<Scalar_, NumIndices_, Options_, IndexType>> {
-    using Type = Eigen::Tensor<Scalar_, NumIndices_, Options_, IndexType>;
-    using ValidType = void;
-
-    static Eigen::DSizes<typename Type::Index, Type::NumIndices> get_shape(const Type &f) {
-        return f.dimensions();
-    }
-
-    static constexpr bool
-    is_correct_shape(const Eigen::DSizes<typename Type::Index, Type::NumIndices> & /*shape*/) {
-        return true;
-    }
-
-    template <typename T>
-    struct helper {};
-
-    template <size_t... Is>
-    struct helper<index_sequence<Is...>> {
-        static constexpr auto value = ::pybind11::detail::concat(const_name(((void) Is, "?"))...);
-    };
-
-    static constexpr auto dimensions_descriptor
-        = helper<decltype(make_index_sequence<Type::NumIndices>())>::value;
-
-    template <typename... Args>
-    static Type *alloc(Args &&...args) {
-        return new Type(std::forward<Args>(args)...);
-    }
-
-    static void free(Type *tensor) { delete tensor; }
-};
-
-template <typename Scalar_, typename std::ptrdiff_t... Indices, int Options_, typename IndexType>
-struct eigen_tensor_helper<
-    Eigen::TensorFixedSize<Scalar_, Eigen::Sizes<Indices...>, Options_, IndexType>> {
-    using Type = Eigen::TensorFixedSize<Scalar_, Eigen::Sizes<Indices...>, Options_, IndexType>;
-    using ValidType = void;
-
-    static constexpr Eigen::DSizes<typename Type::Index, Type::NumIndices>
-    get_shape(const Type & /*f*/) {
-        return get_shape();
-    }
-
-    static constexpr Eigen::DSizes<typename Type::Index, Type::NumIndices> get_shape() {
-        return Eigen::DSizes<typename Type::Index, Type::NumIndices>(Indices...);
-    }
-
-    static bool
-    is_correct_shape(const Eigen::DSizes<typename Type::Index, Type::NumIndices> &shape) {
-        return get_shape() == shape;
-    }
-
-    static constexpr auto dimensions_descriptor
-        = ::pybind11::detail::concat(const_name<Indices>()...);
-
-    template <typename... Args>
-    static Type *alloc(Args &&...args) {
-        Eigen::aligned_allocator<Type> allocator;
-        return ::new (allocator.allocate(1)) Type(std::forward<Args>(args)...);
-    }
-
-    static void free(Type *tensor) {
-        Eigen::aligned_allocator<Type> allocator;
-        tensor->~Type();
-        allocator.deallocate(tensor, 1);
-    }
-};
-
-template <typename Type, bool ShowDetails, bool NeedsWriteable = false>
-struct get_tensor_descriptor {
-    static constexpr auto details
-        = const_name<NeedsWriteable>(", \"flags.writeable\"", "") + const_name
-              < static_cast<int>(Type::Layout)
-          == static_cast<int>(Eigen::RowMajor)
-                 > (", \"flags.c_contiguous\"", ", \"flags.f_contiguous\"");
-    static constexpr auto value
-        = const_name("typing.Annotated[")
-          + io_name("numpy.typing.ArrayLike, ", "numpy.typing.NDArray[")
-          + npy_format_descriptor<typename Type::Scalar>::name + io_name("", "]")
-          + const_name(", \"[") + eigen_tensor_helper<remove_cv_t<Type>>::dimensions_descriptor
-          + const_name("]\"") + const_name<ShowDetails>(details, const_name("")) + const_name("]");
-};
-
-// When EIGEN_AVOID_STL_ARRAY is defined, Eigen::DSizes<T, 0> does not have the begin() member
-// function. Falling back to a simple loop works around this issue.
-//
-// We need to disable the type-limits warning for the inner loop when size = 0.
-
-PYBIND11_WARNING_PUSH
-PYBIND11_WARNING_DISABLE_GCC("-Wtype-limits")
-
-template <typename T, int size>
-std::vector<T> convert_dsizes_to_vector(const Eigen::DSizes<T, size> &arr) {
-    std::vector<T> result(size);
-
-    for (size_t i = 0; i < size; i++) {
-        result[i] = arr[i];
-    }
-
-    return result;
-}
-
-template <typename T, int size>
-Eigen::DSizes<T, size> get_shape_for_array(const array &arr) {
-    Eigen::DSizes<T, size> result;
-    const T *shape = arr.shape();
-    for (size_t i = 0; i < size; i++) {
-        result[i] = shape[i];
-    }
-
-    return result;
-}
-
-PYBIND11_WARNING_POP
-
-template <typename Type>
-struct type_caster<Type, typename eigen_tensor_helper<Type>::ValidType> {
-    static_assert(!std::is_pointer<typename Type::Scalar>::value,
-                  PYBIND11_EIGEN_MESSAGE_POINTER_TYPES_ARE_NOT_SUPPORTED);
-    using Helper = eigen_tensor_helper<Type>;
-    static constexpr auto temp_name = get_tensor_descriptor<Type, false>::value;
-    PYBIND11_TYPE_CASTER(Type, temp_name);
-
-    bool load(handle src, bool convert) {
-        if (!convert) {
-            if (!isinstance<array>(src)) {
-                return false;
-            }
-            array temp = array::ensure(src);
-            if (!temp) {
-                return false;
-            }
-
-            if (!temp.dtype().is(dtype::of<typename Type::Scalar>())) {
-                return false;
-            }
-        }
-
-        array_t<typename Type::Scalar, compute_array_flag_from_tensor<Type>()> arr(
-            reinterpret_borrow<object>(src));
-
-        if (arr.ndim() != Type::NumIndices) {
-            return false;
-        }
-        auto shape = get_shape_for_array<typename Type::Index, Type::NumIndices>(arr);
-
-        if (!Helper::is_correct_shape(shape)) {
-            return false;
-        }
-
-#if EIGEN_VERSION_AT_LEAST(3, 4, 0)
-        auto data_pointer = arr.data();
-#else
-        // Handle Eigen bug
-        auto data_pointer = const_cast<typename Type::Scalar *>(arr.data());
-#endif
-
-        if (is_tensor_aligned(arr.data())) {
-            value = Eigen::TensorMap<const Type, Eigen::Aligned>(data_pointer, shape);
-        } else {
-            value = Eigen::TensorMap<const Type>(data_pointer, shape);
-        }
-
-        return true;
-    }
-
-    static handle cast(Type &&src, return_value_policy policy, handle parent) {
-        if (policy == return_value_policy::reference
-            || policy == return_value_policy::reference_internal) {
-            pybind11_fail("Cannot use a reference return value policy for an rvalue");
-        }
-        return cast_impl(&src, return_value_policy::move, parent);
-    }
-
-    static handle cast(const Type &&src, return_value_policy policy, handle parent) {
-        if (policy == return_value_policy::reference
-            || policy == return_value_policy::reference_internal) {
-            pybind11_fail("Cannot use a reference return value policy for an rvalue");
-        }
-        return cast_impl(&src, return_value_policy::move, parent);
-    }
-
-    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);
-    }
-
-    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);
-    }
-
-    static handle cast(Type *src, return_value_policy policy, handle parent) {
-        if (policy == return_value_policy::automatic) {
-            policy = return_value_policy::take_ownership;
-        } else if (policy == return_value_policy::automatic_reference) {
-            policy = return_value_policy::reference;
-        }
-        return cast_impl(src, policy, parent);
-    }
-
-    static handle cast(const Type *src, return_value_policy policy, handle parent) {
-        if (policy == return_value_policy::automatic) {
-            policy = return_value_policy::take_ownership;
-        } else if (policy == return_value_policy::automatic_reference) {
-            policy = return_value_policy::reference;
-        }
-        return cast_impl(src, policy, parent);
-    }
-
-    template <typename C>
-    static handle cast_impl(C *src, return_value_policy policy, handle parent) {
-        object parent_object;
-        bool writeable = false;
-        switch (policy) {
-            case return_value_policy::move:
-                if (std::is_const<C>::value) {
-                    pybind11_fail("Cannot move from a constant reference");
-                }
-
-                src = Helper::alloc(std::move(*src));
-
-                parent_object
-                    = capsule(src, [](void *ptr) { Helper::free(reinterpret_cast<Type *>(ptr)); });
-                writeable = true;
-                break;
-
-            case return_value_policy::take_ownership:
-                if (std::is_const<C>::value) {
-                    // This cast is ugly, and might be UB in some cases, but we don't have an
-                    // alternative here as we must free that memory
-                    Helper::free(const_cast<Type *>(src));
-                    pybind11_fail("Cannot take ownership of a const reference");
-                }
-
-                parent_object
-                    = capsule(src, [](void *ptr) { Helper::free(reinterpret_cast<Type *>(ptr)); });
-                writeable = true;
-                break;
-
-            case return_value_policy::copy:
-                writeable = true;
-                break;
-
-            case return_value_policy::reference:
-                parent_object = none();
-                writeable = !std::is_const<C>::value;
-                break;
-
-            case return_value_policy::reference_internal:
-                // Default should do the right thing
-                if (!parent) {
-                    pybind11_fail("Cannot use reference internal when there is no parent");
-                }
-                parent_object = reinterpret_borrow<object>(parent);
-                writeable = !std::is_const<C>::value;
-                break;
-
-            default:
-                pybind11_fail("pybind11 bug in eigen.h, please file a bug report");
-        }
-
-        auto result = array_t<typename Type::Scalar, compute_array_flag_from_tensor<Type>()>(
-            convert_dsizes_to_vector(Helper::get_shape(*src)), src->data(), parent_object);
-
-        if (!writeable) {
-            array_proxy(result.ptr())->flags &= ~detail::npy_api::NPY_ARRAY_WRITEABLE_;
-        }
-
-        return result.release();
-    }
-};
-
-template <typename StoragePointerType,
-          bool needs_writeable,
-          enable_if_t<!needs_writeable, bool> = true>
-StoragePointerType get_array_data_for_type(array &arr) {
-#if EIGEN_VERSION_AT_LEAST(3, 4, 0)
-    return reinterpret_cast<StoragePointerType>(arr.data());
-#else
-    // Handle Eigen bug
-    return reinterpret_cast<StoragePointerType>(const_cast<void *>(arr.data()));
-#endif
-}
-
-template <typename StoragePointerType,
-          bool needs_writeable,
-          enable_if_t<needs_writeable, bool> = true>
-StoragePointerType get_array_data_for_type(array &arr) {
-    return reinterpret_cast<StoragePointerType>(arr.mutable_data());
-}
-
-template <typename T, typename = void>
-struct get_storage_pointer_type;
-
-template <typename MapType>
-struct get_storage_pointer_type<MapType, void_t<typename MapType::StoragePointerType>> {
-    using SPT = typename MapType::StoragePointerType;
-};
-
-template <typename MapType>
-struct get_storage_pointer_type<MapType, void_t<typename MapType::PointerArgType>> {
-    using SPT = typename MapType::PointerArgType;
-};
-
-template <typename Type, int Options>
-struct type_caster<Eigen::TensorMap<Type, Options>,
-                   typename eigen_tensor_helper<remove_cv_t<Type>>::ValidType> {
-    static_assert(!std::is_pointer<typename Type::Scalar>::value,
-                  PYBIND11_EIGEN_MESSAGE_POINTER_TYPES_ARE_NOT_SUPPORTED);
-    using MapType = Eigen::TensorMap<Type, Options>;
-    using Helper = eigen_tensor_helper<remove_cv_t<Type>>;
-
-    bool load(handle src, bool /*convert*/) {
-        // Note that we have a lot more checks here as we want to make sure to avoid copies
-        if (!isinstance<array>(src)) {
-            return false;
-        }
-        auto arr = reinterpret_borrow<array>(src);
-        if ((arr.flags() & compute_array_flag_from_tensor<Type>()) == 0) {
-            return false;
-        }
-
-        if (!arr.dtype().is(dtype::of<typename Type::Scalar>())) {
-            return false;
-        }
-
-        if (arr.ndim() != Type::NumIndices) {
-            return false;
-        }
-
-        constexpr bool is_aligned = (Options & Eigen::Aligned) != 0;
-
-        if (is_aligned && !is_tensor_aligned(arr.data())) {
-            return false;
-        }
-
-        auto shape = get_shape_for_array<typename Type::Index, Type::NumIndices>(arr);
-
-        if (!Helper::is_correct_shape(shape)) {
-            return false;
-        }
-
-        if (needs_writeable && !arr.writeable()) {
-            return false;
-        }
-
-        auto result = get_array_data_for_type<typename get_storage_pointer_type<MapType>::SPT,
-                                              needs_writeable>(arr);
-
-        value.reset(new MapType(std::move(result), std::move(shape)));
-
-        return true;
-    }
-
-    static handle cast(MapType &&src, return_value_policy policy, handle parent) {
-        return cast_impl(&src, policy, parent);
-    }
-
-    static handle cast(const MapType &&src, return_value_policy policy, handle parent) {
-        return cast_impl(&src, policy, parent);
-    }
-
-    static handle cast(MapType &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);
-    }
-
-    static handle cast(const MapType &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(MapType *src, return_value_policy policy, handle parent) {
-        if (policy == return_value_policy::automatic) {
-            policy = return_value_policy::take_ownership;
-        } else if (policy == return_value_policy::automatic_reference) {
-            policy = return_value_policy::reference;
-        }
-        return cast_impl(src, policy, parent);
-    }
-
-    static handle cast(const MapType *src, return_value_policy policy, handle parent) {
-        if (policy == return_value_policy::automatic) {
-            policy = return_value_policy::take_ownership;
-        } else if (policy == return_value_policy::automatic_reference) {
-            policy = return_value_policy::reference;
-        }
-        return cast_impl(src, policy, parent);
-    }
-
-    template <typename C>
-    static handle cast_impl(C *src, return_value_policy policy, handle parent) {
-        object parent_object;
-        constexpr bool writeable = !std::is_const<C>::value;
-        switch (policy) {
-            case return_value_policy::reference:
-                parent_object = none();
-                break;
-
-            case return_value_policy::reference_internal:
-                // Default should do the right thing
-                if (!parent) {
-                    pybind11_fail("Cannot use reference internal when there is no parent");
-                }
-                parent_object = reinterpret_borrow<object>(parent);
-                break;
-
-            default:
-                // move, take_ownership don't make any sense for a ref/map:
-                pybind11_fail("Invalid return_value_policy for Eigen Map type, must be either "
-                              "reference or reference_internal");
-        }
-
-        auto result = array_t<typename Type::Scalar, compute_array_flag_from_tensor<Type>()>(
-            convert_dsizes_to_vector(Helper::get_shape(*src)),
-            src->data(),
-            std::move(parent_object));
-
-        if (!writeable) {
-            array_proxy(result.ptr())->flags &= ~detail::npy_api::NPY_ARRAY_WRITEABLE_;
-        }
-
-        return result.release();
-    }
-
-#if EIGEN_VERSION_AT_LEAST(3, 4, 0)
-
-    static constexpr bool needs_writeable = !std::is_const<typename std::remove_pointer<
-        typename get_storage_pointer_type<MapType>::SPT>::type>::value;
-#else
-    // Handle Eigen bug
-    static constexpr bool needs_writeable = !std::is_const<Type>::value;
-#endif
-
-protected:
-    // TODO: Move to std::optional once std::optional has more support
-    std::unique_ptr<MapType> value;
-
-public:
-    // return_descr forces the use of NDArray instead of ArrayLike since refs can only reference
-    // arrays
-    static constexpr auto name
-        = return_descr(get_tensor_descriptor<Type, true, needs_writeable>::value);
-    explicit operator MapType *() { return value.get(); }
-    explicit operator MapType &() { return *value; }
-    explicit operator MapType &&() && { return std::move(*value); }
-
-    template <typename T_>
-    using cast_op_type = ::pybind11::detail::movable_cast_op_type<T_>;
-};
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/embed.h

@@ -1,320 +0,0 @@
-/*
-    pybind11/embed.h: Support for embedding the interpreter
-
-    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 "pybind11.h"
-#include "eval.h"
-
-#include <memory>
-#include <vector>
-
-#if defined(PYPY_VERSION)
-#    error Embedding the interpreter is not supported with PyPy
-#endif
-
-#define PYBIND11_EMBEDDED_MODULE_IMPL(name)                                                       \
-    extern "C" PyObject *pybind11_init_impl_##name();                                             \
-    extern "C" PyObject *pybind11_init_impl_##name() { return pybind11_init_wrapper_##name(); }
-
-/** \rst
-    Add a new module to the table of builtins for the interpreter. Must be
-    defined in global scope. The first macro parameter is the name of the
-    module (without quotes). The second parameter is the variable which will
-    be used as the interface to add functions and classes to the module.
-
-    .. code-block:: cpp
-
-        PYBIND11_EMBEDDED_MODULE(example, m) {
-            // ... initialize functions and classes here
-            m.def("foo", []() {
-                return "Hello, World!";
-            });
-        }
-
-    The third and subsequent macro arguments are optional, and can be used to
-    mark the module as supporting various Python features.
-
-    - ``mod_gil_not_used()``
-    - ``multiple_interpreters::per_interpreter_gil()``
-    - ``multiple_interpreters::shared_gil()``
-    - ``multiple_interpreters::not_supported()``
-
-    .. code-block:: cpp
-
-        PYBIND11_EMBEDDED_MODULE(example, m, py::mod_gil_not_used()) {
-            m.def("foo", []() {
-                return "Hello, Free-threaded World!";
-            });
-        }
-
- \endrst */
-PYBIND11_WARNING_PUSH
-PYBIND11_WARNING_DISABLE_CLANG("-Wgnu-zero-variadic-macro-arguments")
-#define PYBIND11_EMBEDDED_MODULE(name, variable, ...)                                             \
-    PYBIND11_MODULE_PYINIT(name, {}, ##__VA_ARGS__)                                               \
-    ::pybind11::detail::embedded_module PYBIND11_CONCAT(pybind11_module_, name)(                  \
-        PYBIND11_TOSTRING(name), PYBIND11_CONCAT(PyInit_, name));                                 \
-    PYBIND11_MODULE_EXEC(name, variable)
-PYBIND11_WARNING_POP
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-/// Python 2.7/3.x compatible version of `PyImport_AppendInittab` and error checks.
-struct embedded_module {
-    using init_t = PyObject *(*) ();
-    embedded_module(const char *name, init_t init) {
-        if (Py_IsInitialized() != 0) {
-            pybind11_fail("Can't add new modules after the interpreter has been initialized");
-        }
-
-        auto result = PyImport_AppendInittab(name, init);
-        if (result == -1) {
-            pybind11_fail("Insufficient memory to add a new module");
-        }
-    }
-};
-
-struct wide_char_arg_deleter {
-    void operator()(wchar_t *ptr) const {
-        // API docs: https://docs.python.org/3/c-api/sys.html#c.Py_DecodeLocale
-        PyMem_RawFree(ptr);
-    }
-};
-
-inline wchar_t *widen_chars(const char *safe_arg) {
-    wchar_t *widened_arg = Py_DecodeLocale(safe_arg, nullptr);
-    return widened_arg;
-}
-
-inline void precheck_interpreter() {
-    if (Py_IsInitialized() != 0) {
-        pybind11_fail("The interpreter is already running");
-    }
-}
-
-#if !defined(PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX)
-#    define PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX (0x03080000)
-#endif
-
-#if PY_VERSION_HEX < PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX
-inline void initialize_interpreter_pre_pyconfig(bool init_signal_handlers,
-                                                int argc,
-                                                const char *const *argv,
-                                                bool add_program_dir_to_path) {
-    detail::precheck_interpreter();
-    Py_InitializeEx(init_signal_handlers ? 1 : 0);
-
-    auto argv_size = static_cast<size_t>(argc);
-    // SetArgv* on python 3 takes wchar_t, so we have to convert.
-    std::unique_ptr<wchar_t *[]> widened_argv(new wchar_t *[argv_size]);
-    std::vector<std::unique_ptr<wchar_t[], detail::wide_char_arg_deleter>> widened_argv_entries;
-    widened_argv_entries.reserve(argv_size);
-    for (size_t ii = 0; ii < argv_size; ++ii) {
-        widened_argv_entries.emplace_back(detail::widen_chars(argv[ii]));
-        if (!widened_argv_entries.back()) {
-            // A null here indicates a character-encoding failure or the python
-            // interpreter out of memory. Give up.
-            return;
-        }
-        widened_argv[ii] = widened_argv_entries.back().get();
-    }
-
-    auto *pysys_argv = widened_argv.get();
-
-    PySys_SetArgvEx(argc, pysys_argv, static_cast<int>(add_program_dir_to_path));
-}
-#endif
-
-PYBIND11_NAMESPACE_END(detail)
-
-#if PY_VERSION_HEX >= PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX
-inline void initialize_interpreter(PyConfig *config,
-                                   int argc = 0,
-                                   const char *const *argv = nullptr,
-                                   bool add_program_dir_to_path = true) {
-    detail::precheck_interpreter();
-    PyStatus status = PyConfig_SetBytesArgv(config, argc, const_cast<char *const *>(argv));
-    if (PyStatus_Exception(status) != 0) {
-        // A failure here indicates a character-encoding failure or the python
-        // interpreter out of memory. Give up.
-        PyConfig_Clear(config);
-        throw std::runtime_error(PyStatus_IsError(status) != 0 ? status.err_msg
-                                                               : "Failed to prepare CPython");
-    }
-    status = Py_InitializeFromConfig(config);
-    if (PyStatus_Exception(status) != 0) {
-        PyConfig_Clear(config);
-        throw std::runtime_error(PyStatus_IsError(status) != 0 ? status.err_msg
-                                                               : "Failed to init CPython");
-    }
-    if (add_program_dir_to_path) {
-        PyRun_SimpleString("import sys, os.path; "
-                           "sys.path.insert(0, "
-                           "os.path.abspath(os.path.dirname(sys.argv[0])) "
-                           "if sys.argv and os.path.exists(sys.argv[0]) else '')");
-    }
-    PyConfig_Clear(config);
-}
-#endif
-
-/** \rst
-    Initialize the Python interpreter. No other pybind11 or CPython API functions can be
-    called before this is done; with the exception of `PYBIND11_EMBEDDED_MODULE`. The
-    optional `init_signal_handlers` parameter can be used to skip the registration of
-    signal handlers (see the `Python documentation`_ for details). Calling this function
-    again after the interpreter has already been initialized is a fatal error.
-
-    If initializing the Python interpreter fails, then the program is terminated.  (This
-    is controlled by the CPython runtime and is an exception to pybind11's normal behavior
-    of throwing exceptions on errors.)
-
-    The remaining optional parameters, `argc`, `argv`, and `add_program_dir_to_path` are
-    used to populate ``sys.argv`` and ``sys.path``.
-    See the |PySys_SetArgvEx documentation|_ for details.
-
-    .. _Python documentation: https://docs.python.org/3/c-api/init.html#c.Py_InitializeEx
-    .. |PySys_SetArgvEx documentation| replace:: ``PySys_SetArgvEx`` documentation
-    .. _PySys_SetArgvEx documentation: https://docs.python.org/3/c-api/init.html#c.PySys_SetArgvEx
- \endrst */
-inline void initialize_interpreter(bool init_signal_handlers = true,
-                                   int argc = 0,
-                                   const char *const *argv = nullptr,
-                                   bool add_program_dir_to_path = true) {
-#if PY_VERSION_HEX < PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX
-    detail::initialize_interpreter_pre_pyconfig(
-        init_signal_handlers, argc, argv, add_program_dir_to_path);
-#else
-    PyConfig config;
-    PyConfig_InitPythonConfig(&config);
-    // See PR #4473 for background
-    config.parse_argv = 0;
-
-    config.install_signal_handlers = init_signal_handlers ? 1 : 0;
-    initialize_interpreter(&config, argc, argv, add_program_dir_to_path);
-#endif
-
-    // There is exactly one interpreter alive currently.
-    detail::get_num_interpreters_seen() = 1;
-}
-
-/** \rst
-    Shut down the Python interpreter. No pybind11 or CPython API functions can be called
-    after this. In addition, pybind11 objects must not outlive the interpreter:
-
-    .. code-block:: cpp
-
-        { // BAD
-            py::initialize_interpreter();
-            auto hello = py::str("Hello, World!");
-            py::finalize_interpreter();
-        } // <-- BOOM, hello's destructor is called after interpreter shutdown
-
-        { // GOOD
-            py::initialize_interpreter();
-            { // scoped
-                auto hello = py::str("Hello, World!");
-            } // <-- OK, hello is cleaned up properly
-            py::finalize_interpreter();
-        }
-
-        { // BETTER
-            py::scoped_interpreter guard{};
-            auto hello = py::str("Hello, World!");
-        }
-
-    .. warning::
-
-        The interpreter can be restarted by calling `initialize_interpreter` again.
-        Modules created using pybind11 can be safely re-initialized. However, Python
-        itself cannot completely unload binary extension modules and there are several
-        caveats with regard to interpreter restarting. All the details can be found
-        in the CPython documentation. In short, not all interpreter memory may be
-        freed, either due to reference cycles or user-created global data.
-
- \endrst */
-inline void finalize_interpreter() {
-    // get rid of any thread-local interpreter cache that currently exists
-    if (detail::get_num_interpreters_seen() > 1) {
-        detail::get_internals_pp_manager().unref();
-        detail::get_local_internals_pp_manager().unref();
-
-        // We know there can be no other interpreter alive now, so we can lower the count
-        detail::get_num_interpreters_seen() = 1;
-    }
-
-    // Re-fetch the internals pointer-to-pointer (but not the internals itself, which might not
-    // exist). It's possible for the  internals to be created during Py_Finalize() (e.g. if a
-    // py::capsule calls `get_internals()` during destruction), so we get the pointer-pointer here
-    // and check it after Py_Finalize().
-    detail::get_internals_pp_manager().get_pp();
-    detail::get_local_internals_pp_manager().get_pp();
-
-    Py_Finalize();
-
-    detail::get_internals_pp_manager().destroy();
-
-    // Local internals contains data managed by the current interpreter, so we must clear them to
-    // avoid undefined behaviors when initializing another interpreter
-    detail::get_local_internals_pp_manager().destroy();
-
-    // We know there is no interpreter alive now, so we can reset the count
-    detail::get_num_interpreters_seen() = 0;
-}
-
-/** \rst
-    Scope guard version of `initialize_interpreter` and `finalize_interpreter`.
-    This a move-only guard and only a single instance can exist.
-
-    See `initialize_interpreter` for a discussion of its constructor arguments.
-
-    .. code-block:: cpp
-
-        #include <pybind11/embed.h>
-
-        int main() {
-            py::scoped_interpreter guard{};
-            py::print(Hello, World!);
-        } // <-- interpreter shutdown
- \endrst */
-class scoped_interpreter {
-public:
-    explicit scoped_interpreter(bool init_signal_handlers = true,
-                                int argc = 0,
-                                const char *const *argv = nullptr,
-                                bool add_program_dir_to_path = true) {
-        initialize_interpreter(init_signal_handlers, argc, argv, add_program_dir_to_path);
-    }
-
-#if PY_VERSION_HEX >= PYBIND11_PYCONFIG_SUPPORT_PY_VERSION_HEX
-    explicit scoped_interpreter(PyConfig *config,
-                                int argc = 0,
-                                const char *const *argv = nullptr,
-                                bool add_program_dir_to_path = true) {
-        initialize_interpreter(config, argc, argv, add_program_dir_to_path);
-    }
-#endif
-
-    scoped_interpreter(const scoped_interpreter &) = delete;
-    scoped_interpreter(scoped_interpreter &&other) noexcept { other.is_valid = false; }
-    scoped_interpreter &operator=(const scoped_interpreter &) = delete;
-    scoped_interpreter &operator=(scoped_interpreter &&) = delete;
-
-    ~scoped_interpreter() {
-        if (is_valid) {
-            finalize_interpreter();
-        }
-    }
-
-private:
-    bool is_valid = true;
-};
-
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/eval.h

@@ -1,161 +0,0 @@
-/*
-    pybind11/eval.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
-
-#include "pybind11.h"
-
-#include <utility>
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-inline void ensure_builtins_in_globals(object &global) {
-#if defined(PYPY_VERSION)
-    // Running exec and eval adds `builtins` module under `__builtins__` key to
-    // globals if not yet present.  Python 3.8 made PyRun_String behave
-    // similarly. Let's also do that for older versions, for consistency. This
-    // was missing from PyPy3.8 7.3.7.
-    if (!global.contains("__builtins__"))
-        global["__builtins__"] = module_::import(PYBIND11_BUILTINS_MODULE);
-#else
-    (void) global;
-#endif
-}
-
-PYBIND11_NAMESPACE_END(detail)
-
-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(const str &expr, object global = globals(), object local = object()) {
-    if (!local) {
-        local = global;
-    }
-
-    detail::ensure_builtins_in_globals(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 = 0;
-    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_expr, size_t N>
-object eval(const char (&s)[N], object global = globals(), object local = object()) {
-    /* Support raw string literals by removing common leading whitespace */
-    auto expr = (s[0] == '\n') ? str(module_::import("textwrap").attr("dedent")(s)) : str(s);
-    return eval<mode>(expr, std::move(global), std::move(local));
-}
-
-inline void exec(const str &expr, object global = globals(), object local = object()) {
-    eval<eval_statements>(expr, std::move(global), std::move(local));
-}
-
-template <size_t N>
-void exec(const char (&s)[N], object global = globals(), object local = object()) {
-    eval<eval_statements>(s, std::move(global), std::move(local));
-}
-
-#if defined(PYPY_VERSION) || defined(GRAALVM_PYTHON)
-template <eval_mode mode = eval_statements>
-object eval_file(str, object, object) {
-    pybind11_fail("eval_file not supported in this interpreter. Use eval");
-}
-template <eval_mode mode = eval_statements>
-object eval_file(str, object) {
-    pybind11_fail("eval_file not supported in this interpreter. Use eval");
-}
-template <eval_mode mode = eval_statements>
-object eval_file(str) {
-    pybind11_fail("eval_file not supported in this interpreter. Use eval");
-}
-#else
-template <eval_mode mode = eval_statements>
-object eval_file(str fname, object global = globals(), object local = object()) {
-    if (!local) {
-        local = global;
-    }
-
-    detail::ensure_builtins_in_globals(global);
-
-    int start = 0;
-    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;
-    FILE *f =
-#    if PY_VERSION_HEX >= 0x030E0000
-        Py_fopen(fname.ptr(), "r");
-#    else
-        _Py_fopen_obj(fname.ptr(), "r");
-#    endif
-    if (!f) {
-        PyErr_Clear();
-        pybind11_fail("File \"" + fname_str + "\" could not be opened!");
-    }
-
-    if (!global.contains("__file__")) {
-        global["__file__"] = std::move(fname);
-    }
-
-    PyObject *result
-        = PyRun_FileEx(f, fname_str.c_str(), start, global.ptr(), local.ptr(), closeFile);
-
-    if (!result) {
-        throw error_already_set();
-    }
-    return reinterpret_steal<object>(result);
-}
-#endif
-
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/functional.h

@@ -1,147 +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>
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-PYBIND11_NAMESPACE_BEGIN(type_caster_std_function_specializations)
-
-// ensure GIL is held during functor destruction
-struct func_handle {
-    function f;
-#if !(defined(_MSC_VER) && _MSC_VER == 1916 && defined(PYBIND11_CPP17))
-    // This triggers a syntax error under very special conditions (very weird indeed).
-    explicit
-#endif
-        func_handle(function &&f_) noexcept
-        : f(std::move(f_)) {
-    }
-    func_handle(const func_handle &f_) { operator=(f_); }
-    func_handle &operator=(const func_handle &f_) {
-        gil_scoped_acquire acq;
-        f = f_.f;
-        return *this;
-    }
-    ~func_handle() {
-        gil_scoped_acquire acq;
-        function kill_f(std::move(f));
-    }
-};
-
-// to emulate 'move initialization capture' in C++11
-struct func_wrapper_base {
-    func_handle hfunc;
-    explicit func_wrapper_base(func_handle &&hf) noexcept : hfunc(hf) {}
-};
-
-template <typename Return, typename... Args>
-struct func_wrapper : func_wrapper_base {
-    using func_wrapper_base::func_wrapper_base;
-    Return operator()(Args... args) const { // NOLINT(performance-unnecessary-value-param)
-        gil_scoped_acquire acq;
-        // casts the returned object as a rvalue to the return type
-        return hfunc.f(std::forward<Args>(args)...).template cast<Return>();
-    }
-};
-
-PYBIND11_NAMESPACE_END(type_caster_std_function_specializations)
-
-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 convert) {
-        if (src.is_none()) {
-            // Defer accepting None to other overloads (if we aren't in convert mode):
-            if (!convert) {
-                return false;
-            }
-            return true;
-        }
-
-        if (!isinstance<function>(src)) {
-            return false;
-        }
-
-        auto func = reinterpret_borrow<function>(src);
-
-        /*
-           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 (auto cfunc = func.cpp_function()) {
-            auto *cfunc_self = PyCFunction_GET_SELF(cfunc.ptr());
-            if (cfunc_self == nullptr) {
-                PyErr_Clear();
-            } else {
-                function_record *rec = function_record_ptr_from_PyObject(cfunc_self);
-                while (rec != nullptr) {
-                    if (rec->is_stateless
-                        && same_type(typeid(function_type),
-                                     *reinterpret_cast<const std::type_info *>(rec->data[1]))) {
-                        struct capture {
-                            function_type f;
-
-                            static capture *from_data(void **data) {
-                                return PYBIND11_STD_LAUNDER(reinterpret_cast<capture *>(data));
-                            }
-                        };
-                        PYBIND11_ENSURE_PRECONDITION_FOR_FUNCTIONAL_H_PERFORMANCE_OPTIMIZATIONS(
-                            std::is_standard_layout<capture>::value);
-                        value = capture::from_data(rec->data)->f;
-                        return true;
-                    }
-                    rec = rec->next;
-                }
-            }
-            // PYPY segfaults here when passing builtin function like sum.
-            // Raising an fail exception here works to prevent the segfault, but only on gcc.
-            // See PR #1413 for full details
-        }
-
-        value = type_caster_std_function_specializations::func_wrapper<Return, Args...>(
-            type_caster_std_function_specializations::func_handle(std::move(func)));
-        return true;
-    }
-
-    template <typename Func>
-    static handle cast(Func &&f_, return_value_policy policy, handle /* parent */) {
-        if (!f_) {
-            return none().release();
-        }
-
-        auto result = f_.template target<function_type>();
-        if (result) {
-            return cpp_function(*result, policy).release();
-        }
-        return cpp_function(std::forward<Func>(f_), policy).release();
-    }
-
-    PYBIND11_TYPE_CASTER(
-        type,
-        const_name("collections.abc.Callable[[")
-            + ::pybind11::detail::concat(::pybind11::detail::arg_descr(make_caster<Args>::name)...)
-            + const_name("], ") + ::pybind11::detail::return_descr(make_caster<retval_type>::name)
-            + const_name("]"));
-};
-
-PYBIND11_NAMESPACE_END(detail)
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/gil.h

@@ -1,199 +0,0 @@
-/*
-    pybind11/gil.h: RAII helpers for managing the GIL
-
-    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(PYBIND11_SIMPLE_GIL_MANAGEMENT)
-
-#    include "detail/common.h"
-#    include "gil_simple.h"
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-using gil_scoped_acquire = gil_scoped_acquire_simple;
-using gil_scoped_release = gil_scoped_release_simple;
-
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
-
-#else
-
-#    include "detail/common.h"
-#    include "detail/internals.h"
-
-#    include <cassert>
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-PYBIND11_WARNING_PUSH
-PYBIND11_WARNING_DISABLE_GCC("-Wredundant-decls")
-
-// forward declarations
-PyThreadState *get_thread_state_unchecked();
-
-PYBIND11_WARNING_POP
-
-PYBIND11_NAMESPACE_END(detail)
-
-/* 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 &internals = detail::get_internals();
-        tstate = internals.tstate.get();
-
-        if (!tstate) {
-            /* Check if the GIL was acquired using the PyGILState_* API instead (e.g. if
-               calling from a Python thread). Since we use a different key, this ensures
-               we don't create a new thread state and deadlock in PyEval_AcquireThread
-               below. Note we don't save this state with internals.tstate, since we don't
-               create it we would fail to clear it (its reference count should be > 0). */
-            tstate = PyGILState_GetThisThreadState();
-        }
-
-        if (!tstate) {
-            tstate = PyThreadState_New(internals.istate);
-#    if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
-            if (!tstate) {
-                pybind11_fail("scoped_acquire: could not create thread state!");
-            }
-#    endif
-            tstate->gilstate_counter = 0;
-            internals.tstate = tstate;
-        } else {
-            release = detail::get_thread_state_unchecked() != tstate;
-        }
-
-        if (release) {
-            PyEval_AcquireThread(tstate);
-        }
-
-        inc_ref();
-    }
-
-    gil_scoped_acquire(const gil_scoped_acquire &) = delete;
-    gil_scoped_acquire &operator=(const gil_scoped_acquire &) = delete;
-
-    void inc_ref() { ++tstate->gilstate_counter; }
-
-    PYBIND11_NOINLINE void dec_ref() {
-        --tstate->gilstate_counter;
-#    if defined(PYBIND11_DETAILED_ERROR_MESSAGES)
-        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(PYBIND11_DETAILED_ERROR_MESSAGES)
-            if (!release) {
-                pybind11_fail("scoped_acquire::dec_ref(): internal error!");
-            }
-#    endif
-            PyThreadState_Clear(tstate);
-            if (active) {
-                PyThreadState_DeleteCurrent();
-            }
-            detail::get_internals().tstate.reset();
-            release = false;
-        }
-    }
-
-    /// This method will disable the PyThreadState_DeleteCurrent call and the
-    /// GIL won't be released. This method should be used if the interpreter
-    /// could be shutting down when this is called, as thread deletion is not
-    /// allowed during shutdown. Check _Py_IsFinalizing() on Python 3.7+, and
-    /// protect subsequent code.
-    PYBIND11_NOINLINE void disarm() { active = false; }
-
-    PYBIND11_NOINLINE ~gil_scoped_acquire() {
-        dec_ref();
-        if (release) {
-            PyEval_SaveThread();
-        }
-    }
-
-private:
-    PyThreadState *tstate = nullptr;
-    bool release = true;
-    bool active = true;
-};
-
-class gil_scoped_release {
-public:
-    // PRECONDITION: The GIL must be held when this constructor is called.
-    explicit gil_scoped_release(bool disassoc = false) : disassoc(disassoc) {
-        assert(PyGILState_Check());
-        // `get_internals()` must be called here unconditionally in order to initialize
-        // `internals.tstate` for subsequent `gil_scoped_acquire` calls. Otherwise, an
-        // initialization race could occur as multiple threads try `gil_scoped_acquire`.
-        auto &internals = detail::get_internals();
-        // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer)
-        tstate = PyEval_SaveThread();
-        if (disassoc) {
-            internals.tstate.reset();
-        }
-    }
-
-    gil_scoped_release(const gil_scoped_release &) = delete;
-    gil_scoped_release &operator=(const gil_scoped_release &) = delete;
-
-    /// This method will disable the PyThreadState_DeleteCurrent call and the
-    /// GIL won't be acquired. This method should be used if the interpreter
-    /// could be shutting down when this is called, as thread deletion is not
-    /// allowed during shutdown. Check _Py_IsFinalizing() on Python 3.7+, and
-    /// protect subsequent code.
-    PYBIND11_NOINLINE void disarm() { active = false; }
-
-    ~gil_scoped_release() {
-        if (!tstate) {
-            return;
-        }
-        // `PyEval_RestoreThread()` should not be called if runtime is finalizing
-        if (active) {
-            PyEval_RestoreThread(tstate);
-        }
-        if (disassoc) {
-            detail::get_internals().tstate = tstate;
-        }
-    }
-
-private:
-    PyThreadState *tstate;
-    bool disassoc;
-    bool active = true;
-};
-
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)
-
-#endif // !PYBIND11_SIMPLE_GIL_MANAGEMENT

deps_src/pybind11/include/pybind11/gil_safe_call_once.h

@@ -1,102 +0,0 @@
-// Copyright (c) 2023 The pybind Community.
-
-#pragma once
-
-#include "detail/common.h"
-#include "gil.h"
-
-#include <cassert>
-#include <mutex>
-
-#ifdef Py_GIL_DISABLED
-#    include <atomic>
-#endif
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-// Use the `gil_safe_call_once_and_store` class below instead of the naive
-//
-//   static auto imported_obj = py::module_::import("module_name"); // BAD, DO NOT USE!
-//
-// which has two serious issues:
-//
-//     1. Py_DECREF() calls potentially after the Python interpreter was finalized already, and
-//     2. deadlocks in multi-threaded processes (because of missing lock ordering).
-//
-// The following alternative avoids both problems:
-//
-//   PYBIND11_CONSTINIT static py::gil_safe_call_once_and_store<py::object> storage;
-//   auto &imported_obj = storage // Do NOT make this `static`!
-//       .call_once_and_store_result([]() {
-//           return py::module_::import("module_name");
-//       })
-//       .get_stored();
-//
-// The parameter of `call_once_and_store_result()` must be callable. It can make
-// CPython API calls, and in particular, it can temporarily release the GIL.
-//
-// `T` can be any C++ type, it does not have to involve CPython API types.
-//
-// The behavior with regard to signals, e.g. `SIGINT` (`KeyboardInterrupt`),
-// is not ideal. If the main thread is the one to actually run the `Callable`,
-// then a `KeyboardInterrupt` will interrupt it if it is running normal Python
-// code. The situation is different if a non-main thread runs the
-// `Callable`, and then the main thread starts waiting for it to complete:
-// a `KeyboardInterrupt` will not interrupt the non-main thread, but it will
-// get processed only when it is the main thread's turn again and it is running
-// normal Python code. However, this will be unnoticeable for quick call-once
-// functions, which is usually the case.
-//
-// For in-depth background, see docs/advanced/deadlock.md
-template <typename T>
-class gil_safe_call_once_and_store {
-public:
-    // PRECONDITION: The GIL must be held when `call_once_and_store_result()` is called.
-    template <typename Callable>
-    gil_safe_call_once_and_store &call_once_and_store_result(Callable &&fn) {
-        if (!is_initialized_) { // This read is guarded by the GIL.
-            // Multiple threads may enter here, because the GIL is released in the next line and
-            // CPython API calls in the `fn()` call below may release and reacquire the GIL.
-            gil_scoped_release gil_rel; // Needed to establish lock ordering.
-            std::call_once(once_flag_, [&] {
-                // Only one thread will ever enter here.
-                gil_scoped_acquire gil_acq;
-                ::new (storage_) T(fn()); // fn may release, but will reacquire, the GIL.
-                is_initialized_ = true;   // This write is guarded by the GIL.
-            });
-            // All threads will observe `is_initialized_` as true here.
-        }
-        // Intentionally not returning `T &` to ensure the calling code is self-documenting.
-        return *this;
-    }
-
-    // This must only be called after `call_once_and_store_result()` was called.
-    T &get_stored() {
-        assert(is_initialized_);
-        PYBIND11_WARNING_PUSH
-#if !defined(__clang__) && defined(__GNUC__) && __GNUC__ < 5
-        // Needed for gcc 4.8.5
-        PYBIND11_WARNING_DISABLE_GCC("-Wstrict-aliasing")
-#endif
-        return *reinterpret_cast<T *>(storage_);
-        PYBIND11_WARNING_POP
-    }
-
-    constexpr gil_safe_call_once_and_store() = default;
-    PYBIND11_DTOR_CONSTEXPR ~gil_safe_call_once_and_store() = default;
-
-private:
-    alignas(T) char storage_[sizeof(T)] = {};
-    std::once_flag once_flag_ = {};
-#ifdef Py_GIL_DISABLED
-    std::atomic_bool
-#else
-    bool
-#endif
-        is_initialized_{false};
-    // The `is_initialized_`-`storage_` pair is very similar to `std::optional`,
-    // but the latter does not have the triviality properties of former,
-    // therefore `std::optional` is not a viable alternative here.
-};
-
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/gil_simple.h

@@ -1,37 +0,0 @@
-// Copyright (c) 2016-2025 The Pybind Development Team.
-// 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 "detail/common.h"
-
-#include <cassert>
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-class gil_scoped_acquire_simple {
-    PyGILState_STATE state;
-
-public:
-    gil_scoped_acquire_simple() : state{PyGILState_Ensure()} {}
-    gil_scoped_acquire_simple(const gil_scoped_acquire_simple &) = delete;
-    gil_scoped_acquire_simple &operator=(const gil_scoped_acquire_simple &) = delete;
-    ~gil_scoped_acquire_simple() { PyGILState_Release(state); }
-};
-
-class gil_scoped_release_simple {
-    PyThreadState *state;
-
-public:
-    // PRECONDITION: The GIL must be held when this constructor is called.
-    gil_scoped_release_simple() {
-        assert(PyGILState_Check());
-        state = PyEval_SaveThread();
-    }
-    gil_scoped_release_simple(const gil_scoped_release_simple &) = delete;
-    gil_scoped_release_simple &operator=(const gil_scoped_release_simple &) = delete;
-    ~gil_scoped_release_simple() { PyEval_RestoreThread(state); }
-};
-
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/iostream.h

@@ -1,265 +0,0 @@
-/*
-    pybind11/iostream.h -- Tools to assist with redirecting cout and cerr to Python
-
-    Copyright (c) 2017 Henry F. Schreiner
-
-    All rights reserved. Use of this source code is governed by a
-    BSD-style license that can be found in the LICENSE file.
-
-    WARNING: The implementation in this file is NOT thread safe. Multiple
-    threads writing to a redirected ostream concurrently cause data races
-    and potentially buffer overflows. Therefore it is currently a requirement
-    that all (possibly) concurrent redirected ostream writes are protected by
-    a mutex.
-    #HelpAppreciated: Work on iostream.h thread safety.
-    For more background see the discussions under
-    https://github.com/pybind/pybind11/pull/2982 and
-    https://github.com/pybind/pybind11/pull/2995.
-*/
-
-#pragma once
-
-#include "pybind11.h"
-
-#include <algorithm>
-#include <cstring>
-#include <iostream>
-#include <iterator>
-#include <memory>
-#include <ostream>
-#include <streambuf>
-#include <string>
-#include <utility>
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-// Buffer that writes to Python instead of C++
-class pythonbuf : public std::streambuf {
-private:
-    using traits_type = std::streambuf::traits_type;
-
-    const size_t buf_size;
-    std::unique_ptr<char[]> d_buffer;
-    object pywrite;
-    object pyflush;
-
-    int overflow(int c) override {
-        if (!traits_type::eq_int_type(c, traits_type::eof())) {
-            *pptr() = traits_type::to_char_type(c);
-            pbump(1);
-        }
-        return sync() == 0 ? traits_type::not_eof(c) : traits_type::eof();
-    }
-
-    // Computes how many bytes at the end of the buffer are part of an
-    // incomplete sequence of UTF-8 bytes.
-    // Precondition: pbase() < pptr()
-    size_t utf8_remainder() const {
-        const auto rbase = std::reverse_iterator<char *>(pbase());
-        const auto rpptr = std::reverse_iterator<char *>(pptr());
-        auto is_ascii = [](char c) { return (static_cast<unsigned char>(c) & 0x80) == 0x00; };
-        auto is_leading = [](char c) { return (static_cast<unsigned char>(c) & 0xC0) == 0xC0; };
-        auto is_leading_2b = [](char c) { return static_cast<unsigned char>(c) <= 0xDF; };
-        auto is_leading_3b = [](char c) { return static_cast<unsigned char>(c) <= 0xEF; };
-        // If the last character is ASCII, there are no incomplete code points
-        if (is_ascii(*rpptr)) {
-            return 0;
-        }
-        // Otherwise, work back from the end of the buffer and find the first
-        // UTF-8 leading byte
-        const auto rpend = rbase - rpptr >= 3 ? rpptr + 3 : rbase;
-        const auto leading = std::find_if(rpptr, rpend, is_leading);
-        if (leading == rbase) {
-            return 0;
-        }
-        const auto dist = static_cast<size_t>(leading - rpptr);
-        size_t remainder = 0;
-
-        if (dist == 0) {
-            remainder = 1; // 1-byte code point is impossible
-        } else if (dist == 1) {
-            remainder = is_leading_2b(*leading) ? 0 : dist + 1;
-        } else if (dist == 2) {
-            remainder = is_leading_3b(*leading) ? 0 : dist + 1;
-        }
-        // else if (dist >= 3), at least 4 bytes before encountering an UTF-8
-        // leading byte, either no remainder or invalid UTF-8.
-        // Invalid UTF-8 will cause an exception later when converting
-        // to a Python string, so that's not handled here.
-        return remainder;
-    }
-
-    // This function must be non-virtual to be called in a destructor.
-    int _sync() {
-        if (pbase() != pptr()) { // If buffer is not empty
-            gil_scoped_acquire tmp;
-            // This subtraction cannot be negative, so dropping the sign.
-            auto size = static_cast<size_t>(pptr() - pbase());
-            size_t remainder = utf8_remainder();
-
-            if (size > remainder) {
-                str line(pbase(), size - remainder);
-                pywrite(std::move(line));
-                pyflush();
-            }
-
-            // Copy the remainder at the end of the buffer to the beginning:
-            if (remainder > 0) {
-                std::memmove(pbase(), pptr() - remainder, remainder);
-            }
-            setp(pbase(), epptr());
-            pbump(static_cast<int>(remainder));
-        }
-        return 0;
-    }
-
-    int sync() override { return _sync(); }
-
-public:
-    explicit pythonbuf(const object &pyostream, size_t buffer_size = 1024)
-        : buf_size(buffer_size), d_buffer(new char[buf_size]), pywrite(pyostream.attr("write")),
-          pyflush(pyostream.attr("flush")) {
-        setp(d_buffer.get(), d_buffer.get() + buf_size - 1);
-    }
-
-    pythonbuf(pythonbuf &&) = default;
-
-    /// Sync before destroy
-    ~pythonbuf() override { _sync(); }
-};
-
-PYBIND11_NAMESPACE_END(detail)
-
-/** \rst
-    This a move-only guard that redirects output.
-
-    .. code-block:: cpp
-
-        #include <pybind11/iostream.h>
-
-        ...
-
-        {
-            py::scoped_ostream_redirect output;
-            std::cout << "Hello, World!"; // Python stdout
-        } // <-- return std::cout to normal
-
-    You can explicitly pass the c++ stream and the python object,
-    for example to guard stderr instead.
-
-    .. code-block:: cpp
-
-        {
-            py::scoped_ostream_redirect output{
-                std::cerr, py::module::import("sys").attr("stderr")};
-            std::cout << "Hello, World!";
-        }
- \endrst */
-class scoped_ostream_redirect {
-protected:
-    std::streambuf *old;
-    std::ostream &costream;
-    detail::pythonbuf buffer;
-
-public:
-    explicit scoped_ostream_redirect(std::ostream &costream = std::cout,
-                                     const object &pyostream
-                                     = module_::import("sys").attr("stdout"))
-        : costream(costream), buffer(pyostream) {
-        old = costream.rdbuf(&buffer);
-    }
-
-    ~scoped_ostream_redirect() { costream.rdbuf(old); }
-
-    scoped_ostream_redirect(const scoped_ostream_redirect &) = delete;
-    scoped_ostream_redirect(scoped_ostream_redirect &&other) = default;
-    scoped_ostream_redirect &operator=(const scoped_ostream_redirect &) = delete;
-    scoped_ostream_redirect &operator=(scoped_ostream_redirect &&) = delete;
-};
-
-/** \rst
-    Like `scoped_ostream_redirect`, but redirects cerr by default. This class
-    is provided primary to make ``py::call_guard`` easier to make.
-
-    .. code-block:: cpp
-
-     m.def("noisy_func", &noisy_func,
-           py::call_guard<scoped_ostream_redirect,
-                          scoped_estream_redirect>());
-
-\endrst */
-class scoped_estream_redirect : public scoped_ostream_redirect {
-public:
-    explicit scoped_estream_redirect(std::ostream &costream = std::cerr,
-                                     const object &pyostream
-                                     = module_::import("sys").attr("stderr"))
-        : scoped_ostream_redirect(costream, pyostream) {}
-};
-
-PYBIND11_NAMESPACE_BEGIN(detail)
-
-// Class to redirect output as a context manager. C++ backend.
-class OstreamRedirect {
-    bool do_stdout_;
-    bool do_stderr_;
-    std::unique_ptr<scoped_ostream_redirect> redirect_stdout;
-    std::unique_ptr<scoped_estream_redirect> redirect_stderr;
-
-public:
-    explicit OstreamRedirect(bool do_stdout = true, bool do_stderr = true)
-        : do_stdout_(do_stdout), do_stderr_(do_stderr) {}
-
-    void enter() {
-        if (do_stdout_) {
-            redirect_stdout.reset(new scoped_ostream_redirect());
-        }
-        if (do_stderr_) {
-            redirect_stderr.reset(new scoped_estream_redirect());
-        }
-    }
-
-    void exit() {
-        redirect_stdout.reset();
-        redirect_stderr.reset();
-    }
-};
-
-PYBIND11_NAMESPACE_END(detail)
-
-/** \rst
-    This is a helper function to add a C++ redirect context manager to Python
-    instead of using a C++ guard. To use it, add the following to your binding code:
-
-    .. code-block:: cpp
-
-        #include <pybind11/iostream.h>
-
-        ...
-
-        py::add_ostream_redirect(m, "ostream_redirect");
-
-    You now have a Python context manager that redirects your output:
-
-    .. code-block:: python
-
-        with m.ostream_redirect():
-            m.print_to_cout_function()
-
-    This manager can optionally be told which streams to operate on:
-
-    .. code-block:: python
-
-        with m.ostream_redirect(stdout=true, stderr=true):
-            m.noisy_function_with_error_printing()
-
- \endrst */
-inline class_<detail::OstreamRedirect>
-add_ostream_redirect(module_ m, const std::string &name = "ostream_redirect") {
-    return class_<detail::OstreamRedirect>(std::move(m), name.c_str(), module_local())
-        .def(init<bool, bool>(), arg("stdout") = true, arg("stderr") = true)
-        .def("__enter__", &detail::OstreamRedirect::enter)
-        .def("__exit__", [](detail::OstreamRedirect &self_, const args &) { self_.exit(); });
-}
-
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)

deps_src/pybind11/include/pybind11/native_enum.h

@@ -1,67 +0,0 @@
-// Copyright (c) 2022-2025 The pybind Community.
-// 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 "detail/common.h"
-#include "detail/native_enum_data.h"
-#include "detail/type_caster_base.h"
-#include "cast.h"
-
-#include <cassert>
-#include <limits>
-#include <type_traits>
-#include <typeindex>
-
-PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
-
-/// Conversions between Python's native (stdlib) enum types and C++ enums.
-template <typename EnumType>
-class native_enum : public detail::native_enum_data {
-public:
-    using Underlying = typename std::underlying_type<EnumType>::type;
-
-    native_enum(const object &parent_scope,
-                const char *name,
-                const char *native_type_name,
-                const char *class_doc = "")
-        : detail::native_enum_data(
-              parent_scope, name, native_type_name, class_doc, std::type_index(typeid(EnumType))) {
-        if (detail::get_local_type_info(typeid(EnumType)) != nullptr
-            || detail::get_global_type_info(typeid(EnumType)) != nullptr) {
-            pybind11_fail(
-                "pybind11::native_enum<...>(\"" + enum_name_encoded
-                + "\") is already registered as a `pybind11::enum_` or `pybind11::class_`!");
-        }
-        if (detail::global_internals_native_enum_type_map_contains(enum_type_index)) {
-            pybind11_fail("pybind11::native_enum<...>(\"" + enum_name_encoded
-                          + "\") is already registered!");
-        }
-        arm_finalize_check();
-    }
-
-    /// Export enumeration entries into the parent scope
-    native_enum &export_values() {
-        assert(!export_values_flag); // Catch redundant calls.
-        export_values_flag = true;
-        return *this;
-    }
-
-    /// Add an enumeration entry
-    native_enum &value(char const *name, EnumType value, const char *doc = nullptr) {
-        // Disarm for the case that the native_enum_data dtor runs during exception unwinding.
-        disarm_finalize_check("value after finalize");
-        members.append(make_tuple(name, static_cast<Underlying>(value)));
-        if (doc) {
-            member_docs.append(make_tuple(name, doc));
-        }
-        arm_finalize_check(); // There was no exception.
-        return *this;
-    }
-
-    native_enum(const native_enum &) = delete;
-    native_enum &operator=(const native_enum &) = delete;
-};
-
-PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE)