IsoSpecPy 2.3.5__tar.gz → 2.5.0__tar.gz

isospecpy-2.5.0/PKG-INFO

@@ -0,0 +1,220 @@
+Metadata-Version: 2.4
+Name: IsoSpecPy
+Version: 2.5.0
+Summary: IsoSpecPy is a Python library for computing isotopic distributions of molecules.
+Keywords: isotopic distribution,mass spectrometry,chemistry,isotopic envelope,isotopologues
+Author: Michał Startek, Mateusz Łącki
+License-Expression: BSD-2-Clause
+License-File: LICENCE
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Operating System :: OS Independent
+Project-URL: Homepage, https://github.com/MatteoLacki/IsoSpec
+Project-URL: Repository, https://github.com/MatteoLacki/IsoSpec
+Requires-Python: >=3.9
+Requires-Dist: cffi
+Provides-Extra: testing
+Requires-Dist: pytest; extra == "testing"
+Requires-Dist: OldIsoSpecPy; extra == "testing"
+Description-Content-Type: text/markdown
+
+# IsoSpec
+
+IsoSpec is a fine-structure isotopic distribution calculator for chemical formulas — given a molecule, it computes the masses and probabilities of its isotopologues. It is fast enough to handle large molecules (proteins, oligonucleotides) where the full distribution has astronomically many configurations, and it returns provably-optimal subsets that cover a chosen fraction of the total probability mass.
+
+IsoSpec is primarily used as a library by mass spectrometry software. It is implemented in C++ (`src/IsoSpec++/`) and shipped with first-class bindings for Python (`IsoSpecPy`, on PyPI) and R (`IsoSpecR`, on CRAN).
+
+## Installation
+
+### Python
+
+```bash
+pip install IsoSpecPy
+```
+
+The wheel bundles the C++ library — no separate native install required. Compatible with CPython and PyPy on Linux, macOS, Windows, and Cygwin/MinGW. Python ≥ 3.9.
+
+To build from source: `pip install .` from a checkout. A C++20 compiler is required.
+
+### R
+
+```r
+install.packages("IsoSpecR")
+```
+
+From source: `cd src && R CMD build IsoSpecR && R CMD INSTALL IsoSpecR_*.tar.gz`.
+
+### C++ library
+
+```bash
+cd src/IsoSpec++
+make            # produces libIsoSpec++.so
+```
+
+Or via CMake from the repo root:
+
+```bash
+cmake -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build
+sudo cmake --install build
+```
+
+Requires a C++20 compiler. CMake produces both shared and static libraries and installs headers under `${CMAKE_INSTALL_INCLUDEDIR}/IsoSpec++`.
+
+## Quick start
+
+The most common usage is `IsoTotalProb`: ask for the smallest set of isotopologues whose summed probability covers a chosen fraction of the spectrum (typically 0.99–0.9999). The result is a materialized envelope — arrays of masses and probabilities you can read directly.
+
+### Python
+
+```python
+import IsoSpecPy
+
+# Isotopologues covering at least 99.9% of the probability mass of water.
+iso = IsoSpecPy.IsoTotalProb(formula="H2O1", prob_to_cover=0.999)
+
+for mass, prob in zip(iso.masses, iso.probs):
+    print(mass, prob)
+
+# From an amino-acid sequence:
+iso = IsoSpecPy.IsoTotalProb(peptide_sequence="AAAPPGQAAC", prob_to_cover=0.999)
+print(list(zip(iso.masses, iso.probs)))
+
+# ...optionally carrying [UNIMOD:<id>] modification tags (the notation this
+# monorepo's SAGE search-engine fork writes: [UNIMOD:<id>]-SEQUENCE prefix
+# for an N-terminal mod, X[UNIMOD:<id>] inline for an internal one,
+# SEQUENCE-[UNIMOD:<id>] suffix for a C-terminal one):
+iso = IsoSpecPy.IsoTotalProb(peptide_sequence="PEPTC[UNIMOD:4]DEK", prob_to_cover=0.999)
+print(list(zip(iso.masses, iso.probs)))
+
+# Mind the water: peptide_sequence= yields the *residue* composition, without
+# the terminal H2O of a free peptide, so the masses above are 18.0106 Da
+# lighter than the neutral molecule. Add it explicitly for the real peptide
+# (the C++ Iso::FromFASTAWithMods below adds it by default -- the two APIs
+# differ here, and this is the older Python behaviour kept for compatibility):
+iso = IsoSpecPy.IsoTotalProb(peptide_sequence="PEPTC[UNIMOD:4]DEK", formula="H2O1",
+                             prob_to_cover=0.999)
+
+# Or get just the composition (element -> atom count), no envelope:
+composition = IsoSpecPy.ParsePeptideSequence("PEPTC[UNIMOD:4]DEK")
+print(dict(composition))  # {'H': 60, 'C': 39, 'N': 10, 'O': 16, 'S': 1}
+```
+
+Resolves against a table of ~980 Unimod entries embedded in the library (isotope-labelled and glycan/derivatization "brick" modifications are excluded -- they aren't representable as a pure elemental delta). Pass `unimod_db_path="/path/to/table.csv"` to either function to resolve against a different table instead (same `id,name,mono_mass,composition` CSV shape as the embedded default).
+
+See `Examples/Python/` for radiolabelling, custom elements, binned spectra, and FASTA/Unimod modifications.
+
+### C++
+
+```cpp
+#include "IsoSpec++/isoSpec++.h"
+#include "IsoSpec++/fixedEnvelopes.h"
+
+using namespace IsoSpec;
+
+int main() {
+    FixedEnvelope iso = FixedEnvelope::FromTotalProb("H2O1", 0.999, true, true);
+
+    for (size_t i = 0; i < iso.confs_no(); ++i) {
+        std::cout << iso.mass(i) << '\t' << iso.prob(i) << '\n';
+    }
+}
+```
+
+From a peptide sequence, optionally carrying `[UNIMOD:<id>]` modification tags (`fasta_mods.h`; same notation as the Python/R examples above):
+
+```cpp
+#include "IsoSpec++/isoSpec++.h"
+#include "IsoSpec++/fasta_mods.h"
+#include "IsoSpec++/fixedEnvelopes.h"
+
+using namespace IsoSpec;
+
+int main() {
+    FixedEnvelope iso = FixedEnvelope::FromTotalProb(
+        Iso::FromFASTAWithMods("PEPTC[UNIMOD:4]DEK"), 0.999, true, true);
+
+    for (size_t i = 0; i < iso.confs_no(); ++i) {
+        std::cout << iso.mass(i) << '\t' << iso.prob(i) << '\n';
+    }
+}
+```
+
+`Iso::FromFASTAWithMods` takes an optional trailing `unimod_db_path` argument to resolve against a different Unimod table instead of the one embedded at compile time. For just the composition, no envelope, call `parse_fasta_with_mods`/`parse_fasta_with_mods_full` directly (or the allocation-free `_into` forms, for a hot loop over many sequences) — see `fasta_mods.h`.
+
+Quickest way to build:
+
+```bash
+clang++ -std=c++20 water.cpp src/IsoSpec++/unity-build.cpp -o water
+```
+
+(`unity-build.cpp` is a single translation unit that `#include`s every source file — see `Examples/C++/COMPILING`.)
+
+### R
+
+```r
+library(IsoSpecR)
+water <- c(H = 2, O = 1)
+IsoSpecify(molecule = water, stopCondition = 0.999)
+```
+
+`IsoSpecify` only ever takes a raw named-integer-vector `molecule` -- it has no sequence-string parameter -- so a `[UNIMOD:<id>]`-annotated peptide sequence takes two calls instead of one: `RParsePeptideSequence()` to resolve the sequence into a composition, then `IsoSpecify()` as above.
+
+```r
+composition <- RParsePeptideSequence("PEPTC[UNIMOD:4]DEK")
+print(composition)  #  H  C  N  O  S
+                     # 60 39 10 16  1
+IsoSpecify(molecule = composition, stopCondition = 0.999)
+```
+
+Like the Python `ParsePeptideSequence`, this returns the residue composition without a free peptide's terminal H2O -- add `c(H = 2, O = 1)` to it for the neutral molecule. A modification whose delta removes more atoms of an element than the bare sequence provides gives a negative count (`"G[UNIMOD:11]"` nets `H -1`, `S -1`); `IsoSpecify` rejects such a vector rather than quietly dropping those elements.
+
+See `Examples/R/` for radiolabelling, full-spectrum extraction, and Unimod-annotated sequences.
+
+## Advanced features
+
+- **Alternative algorithms** — for cases where `IsoTotalProb` isn't the right shape:
+  - `IsoThreshold` — all isotopologues with probability above a fixed threshold.
+  - `IsoStochastic` — simulate a measured spectrum by sampling integer ion counts.
+  - `IsoBinned` — histogram-style envelope at a chosen bin width.
+- **FASTA/peptide-sequence support** — build an `Iso` directly from an amino-acid sequence, with `[UNIMOD:<id>]` modification tags recognized inline; optionally include the N/C-terminal water.
+- **Custom isotopic tables** — override natural abundances per element (e.g. for radio- or stable-isotope labelling). See `Examples/*/radiolabelling.*`.
+- **Fixed-envelope arithmetic** — addition, normalization, convolution, Wasserstein distance.
+- **Nominal-mass mode** — compute distributions over nucleon counts instead of real masses.
+- **Streaming generators (for performance)** — the tabulated functions above materialize the full envelope into arrays. For large molecules where that uses too much memory, or for pipelines that consume one configuration at a time (e.g. binning on the fly), use the generator classes instead: `IsoThresholdGenerator`, `IsoLayeredGenerator`, `IsoOrderedGenerator`, `IsoStochasticGenerator`. They yield one isotopologue per call to `advanceToNextConfiguration()` without ever storing the full set. `IsoOrderedGenerator` additionally streams in strict order of decreasing probability.
+
+Algorithmic details are in the papers cited below; the Supporting Information of each is the better starting point for implementation specifics.
+
+## Repository layout
+
+```
+src/IsoSpec++/    C++ core library (the algorithms live here)
+src/IsoSpecPy/    Python binding, loaded via cffi
+src/IsoSpecR/     R binding, via Rcpp
+Examples/         Working examples in each language
+tests/            C, C++, and Python test suites
+skbuild/          scikit-build-core entry point used when installing the Python wheel
+```
+
+## Citation
+
+If IsoSpec is useful in your research, please cite:
+
+- Łącki, M. K.; Valkenborg, D.; Startek, M. P. *IsoSpec2: Ultrafast Fine Structure Calculator.* Analytical Chemistry **2020**, *92* (14), 9472–9475. <https://doi.org/10.1021/acs.analchem.0c00959>
+- Łącki, M. K.; Startek, M.; Valkenborg, D.; Gambin, A. *IsoSpec: Hyperfast Fine Structure Calculator.* Analytical Chemistry **2017**, *89* (6), 3272–3277. <https://doi.org/10.1021/acs.analchem.6b01459>
+
+The Supporting Information of each paper has the algorithmic detail.
+
+## License
+
+2-clause BSD (see `LICENCE`). If you need different licensing terms, contact the authors. The authors appreciate (but do not require) being told when IsoSpec is used in other software.

isospecpy-2.5.0/README.md

@@ -0,0 +1,190 @@
+# IsoSpec
+
+IsoSpec is a fine-structure isotopic distribution calculator for chemical formulas — given a molecule, it computes the masses and probabilities of its isotopologues. It is fast enough to handle large molecules (proteins, oligonucleotides) where the full distribution has astronomically many configurations, and it returns provably-optimal subsets that cover a chosen fraction of the total probability mass.
+
+IsoSpec is primarily used as a library by mass spectrometry software. It is implemented in C++ (`src/IsoSpec++/`) and shipped with first-class bindings for Python (`IsoSpecPy`, on PyPI) and R (`IsoSpecR`, on CRAN).
+
+## Installation
+
+### Python
+
+```bash
+pip install IsoSpecPy
+```
+
+The wheel bundles the C++ library — no separate native install required. Compatible with CPython and PyPy on Linux, macOS, Windows, and Cygwin/MinGW. Python ≥ 3.9.
+
+To build from source: `pip install .` from a checkout. A C++20 compiler is required.
+
+### R
+
+```r
+install.packages("IsoSpecR")
+```
+
+From source: `cd src && R CMD build IsoSpecR && R CMD INSTALL IsoSpecR_*.tar.gz`.
+
+### C++ library
+
+```bash
+cd src/IsoSpec++
+make            # produces libIsoSpec++.so
+```
+
+Or via CMake from the repo root:
+
+```bash
+cmake -B build -DCMAKE_BUILD_TYPE=Release
+cmake --build build
+sudo cmake --install build
+```
+
+Requires a C++20 compiler. CMake produces both shared and static libraries and installs headers under `${CMAKE_INSTALL_INCLUDEDIR}/IsoSpec++`.
+
+## Quick start
+
+The most common usage is `IsoTotalProb`: ask for the smallest set of isotopologues whose summed probability covers a chosen fraction of the spectrum (typically 0.99–0.9999). The result is a materialized envelope — arrays of masses and probabilities you can read directly.
+
+### Python
+
+```python
+import IsoSpecPy
+
+# Isotopologues covering at least 99.9% of the probability mass of water.
+iso = IsoSpecPy.IsoTotalProb(formula="H2O1", prob_to_cover=0.999)
+
+for mass, prob in zip(iso.masses, iso.probs):
+    print(mass, prob)
+
+# From an amino-acid sequence:
+iso = IsoSpecPy.IsoTotalProb(peptide_sequence="AAAPPGQAAC", prob_to_cover=0.999)
+print(list(zip(iso.masses, iso.probs)))
+
+# ...optionally carrying [UNIMOD:<id>] modification tags (the notation this
+# monorepo's SAGE search-engine fork writes: [UNIMOD:<id>]-SEQUENCE prefix
+# for an N-terminal mod, X[UNIMOD:<id>] inline for an internal one,
+# SEQUENCE-[UNIMOD:<id>] suffix for a C-terminal one):
+iso = IsoSpecPy.IsoTotalProb(peptide_sequence="PEPTC[UNIMOD:4]DEK", prob_to_cover=0.999)
+print(list(zip(iso.masses, iso.probs)))
+
+# Mind the water: peptide_sequence= yields the *residue* composition, without
+# the terminal H2O of a free peptide, so the masses above are 18.0106 Da
+# lighter than the neutral molecule. Add it explicitly for the real peptide
+# (the C++ Iso::FromFASTAWithMods below adds it by default -- the two APIs
+# differ here, and this is the older Python behaviour kept for compatibility):
+iso = IsoSpecPy.IsoTotalProb(peptide_sequence="PEPTC[UNIMOD:4]DEK", formula="H2O1",
+                             prob_to_cover=0.999)
+
+# Or get just the composition (element -> atom count), no envelope:
+composition = IsoSpecPy.ParsePeptideSequence("PEPTC[UNIMOD:4]DEK")
+print(dict(composition))  # {'H': 60, 'C': 39, 'N': 10, 'O': 16, 'S': 1}
+```
+
+Resolves against a table of ~980 Unimod entries embedded in the library (isotope-labelled and glycan/derivatization "brick" modifications are excluded -- they aren't representable as a pure elemental delta). Pass `unimod_db_path="/path/to/table.csv"` to either function to resolve against a different table instead (same `id,name,mono_mass,composition` CSV shape as the embedded default).
+
+See `Examples/Python/` for radiolabelling, custom elements, binned spectra, and FASTA/Unimod modifications.
+
+### C++
+
+```cpp
+#include "IsoSpec++/isoSpec++.h"
+#include "IsoSpec++/fixedEnvelopes.h"
+
+using namespace IsoSpec;
+
+int main() {
+    FixedEnvelope iso = FixedEnvelope::FromTotalProb("H2O1", 0.999, true, true);
+
+    for (size_t i = 0; i < iso.confs_no(); ++i) {
+        std::cout << iso.mass(i) << '\t' << iso.prob(i) << '\n';
+    }
+}
+```
+
+From a peptide sequence, optionally carrying `[UNIMOD:<id>]` modification tags (`fasta_mods.h`; same notation as the Python/R examples above):
+
+```cpp
+#include "IsoSpec++/isoSpec++.h"
+#include "IsoSpec++/fasta_mods.h"
+#include "IsoSpec++/fixedEnvelopes.h"
+
+using namespace IsoSpec;
+
+int main() {
+    FixedEnvelope iso = FixedEnvelope::FromTotalProb(
+        Iso::FromFASTAWithMods("PEPTC[UNIMOD:4]DEK"), 0.999, true, true);
+
+    for (size_t i = 0; i < iso.confs_no(); ++i) {
+        std::cout << iso.mass(i) << '\t' << iso.prob(i) << '\n';
+    }
+}
+```
+
+`Iso::FromFASTAWithMods` takes an optional trailing `unimod_db_path` argument to resolve against a different Unimod table instead of the one embedded at compile time. For just the composition, no envelope, call `parse_fasta_with_mods`/`parse_fasta_with_mods_full` directly (or the allocation-free `_into` forms, for a hot loop over many sequences) — see `fasta_mods.h`.
+
+Quickest way to build:
+
+```bash
+clang++ -std=c++20 water.cpp src/IsoSpec++/unity-build.cpp -o water
+```
+
+(`unity-build.cpp` is a single translation unit that `#include`s every source file — see `Examples/C++/COMPILING`.)
+
+### R
+
+```r
+library(IsoSpecR)
+water <- c(H = 2, O = 1)
+IsoSpecify(molecule = water, stopCondition = 0.999)
+```
+
+`IsoSpecify` only ever takes a raw named-integer-vector `molecule` -- it has no sequence-string parameter -- so a `[UNIMOD:<id>]`-annotated peptide sequence takes two calls instead of one: `RParsePeptideSequence()` to resolve the sequence into a composition, then `IsoSpecify()` as above.
+
+```r
+composition <- RParsePeptideSequence("PEPTC[UNIMOD:4]DEK")
+print(composition)  #  H  C  N  O  S
+                     # 60 39 10 16  1
+IsoSpecify(molecule = composition, stopCondition = 0.999)
+```
+
+Like the Python `ParsePeptideSequence`, this returns the residue composition without a free peptide's terminal H2O -- add `c(H = 2, O = 1)` to it for the neutral molecule. A modification whose delta removes more atoms of an element than the bare sequence provides gives a negative count (`"G[UNIMOD:11]"` nets `H -1`, `S -1`); `IsoSpecify` rejects such a vector rather than quietly dropping those elements.
+
+See `Examples/R/` for radiolabelling, full-spectrum extraction, and Unimod-annotated sequences.
+
+## Advanced features
+
+- **Alternative algorithms** — for cases where `IsoTotalProb` isn't the right shape:
+  - `IsoThreshold` — all isotopologues with probability above a fixed threshold.
+  - `IsoStochastic` — simulate a measured spectrum by sampling integer ion counts.
+  - `IsoBinned` — histogram-style envelope at a chosen bin width.
+- **FASTA/peptide-sequence support** — build an `Iso` directly from an amino-acid sequence, with `[UNIMOD:<id>]` modification tags recognized inline; optionally include the N/C-terminal water.
+- **Custom isotopic tables** — override natural abundances per element (e.g. for radio- or stable-isotope labelling). See `Examples/*/radiolabelling.*`.
+- **Fixed-envelope arithmetic** — addition, normalization, convolution, Wasserstein distance.
+- **Nominal-mass mode** — compute distributions over nucleon counts instead of real masses.
+- **Streaming generators (for performance)** — the tabulated functions above materialize the full envelope into arrays. For large molecules where that uses too much memory, or for pipelines that consume one configuration at a time (e.g. binning on the fly), use the generator classes instead: `IsoThresholdGenerator`, `IsoLayeredGenerator`, `IsoOrderedGenerator`, `IsoStochasticGenerator`. They yield one isotopologue per call to `advanceToNextConfiguration()` without ever storing the full set. `IsoOrderedGenerator` additionally streams in strict order of decreasing probability.
+
+Algorithmic details are in the papers cited below; the Supporting Information of each is the better starting point for implementation specifics.
+
+## Repository layout
+
+```
+src/IsoSpec++/    C++ core library (the algorithms live here)
+src/IsoSpecPy/    Python binding, loaded via cffi
+src/IsoSpecR/     R binding, via Rcpp
+Examples/         Working examples in each language
+tests/            C, C++, and Python test suites
+skbuild/          scikit-build-core entry point used when installing the Python wheel
+```
+
+## Citation
+
+If IsoSpec is useful in your research, please cite:
+
+- Łącki, M. K.; Valkenborg, D.; Startek, M. P. *IsoSpec2: Ultrafast Fine Structure Calculator.* Analytical Chemistry **2020**, *92* (14), 9472–9475. <https://doi.org/10.1021/acs.analchem.0c00959>
+- Łącki, M. K.; Startek, M.; Valkenborg, D.; Gambin, A. *IsoSpec: Hyperfast Fine Structure Calculator.* Analytical Chemistry **2017**, *89* (6), 3272–3277. <https://doi.org/10.1021/acs.analchem.6b01459>
+
+The Supporting Information of each paper has the algorithmic detail.
+
+## License
+
+2-clause BSD (see `LICENCE`). If you need different licensing terms, contact the authors. The authors appreciate (but do not require) being told when IsoSpec is used in other software.

isospecpy-2.5.0/VERSION

@@ -0,0 +1 @@
+2.5.0

isospecpy-2.5.0/pyproject.toml

@@ -0,0 +1,94 @@
+[build-system]
+requires = ["setuptools", "scikit-build-core"]
+build-backend = "scikit_build_core.build"
+
+# Single source of truth for the version: the VERSION file at the top of the
+# tree, which CMakeLists.txt reads too (see the note there). Keep that file to
+# one bare version number on one line.
+[[tool.dynamic-metadata]]
+field = "version"
+provider = "scikit_build_core.metadata.regex"
+input = "VERSION"
+regex = "^\\s*(?P<value>[0-9]+(?:\\.[0-9]+)*)"
+
+[tool.scikit-build]
+cmake.source-dir = "skbuild"
+# The compiled part is not a Python extension module: it is a plain C-ABI
+# shared library that isoFFI.py dlopen()s through cffi's ABI mode, and it never
+# includes Python.h or links libpython. So the wheel is tagged py3-none-<plat>
+# rather than per-interpreter (cp3XX) or Stable ABI (abi3): one binary per
+# platform serves every CPython -- free-threaded builds included, which abi3
+# does not cover -- and PyPy too. cibuildwheel builds it once per platform and
+# only *tests* it under each remaining interpreter. Should the library ever
+# start using the CPython API, this must go back to per-interpreter tags.
+wheel.py-api = "py3"
+
+[project]
+name = "IsoSpecPy"
+dependencies = ["cffi"]
+description = "IsoSpecPy is a Python library for computing isotopic distributions of molecules."
+dynamic = ["version"]
+license = "BSD-2-Clause"
+license-files = ["LICENCE"]
+authors = [{name = "Michał Startek"}, {name = "Mateusz Łącki"}]
+readme = "README.md"
+requires-python = ">=3.9"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Programming Language :: Python :: Implementation :: CPython",
+    "Programming Language :: Python :: Implementation :: PyPy",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Development Status :: 5 - Production/Stable",
+    "Operating System :: OS Independent",
+]
+keywords = ["isotopic distribution", "mass spectrometry", "chemistry", "isotopic envelope", "isotopologues"]
+
+[project.urls]
+Homepage = "https://github.com/MatteoLacki/IsoSpec"
+Repository = "https://github.com/MatteoLacki/IsoSpec"
+
+
+
+[project.optional-dependencies]
+testing = ["pytest", "OldIsoSpecPy"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests/Python"]
+
+[tool.cibuildwheel]
+enable = ["pypy"]
+test-command = "python -m pytest -o faulthandler_timeout=600 {project}/tests/Python"
+#test-sources = ["tests/Python"]
+test-extras = ["testing"]
+
+# Apple Clang's libc++ has no <experimental/simd>; build with Homebrew GCC instead.
+[tool.cibuildwheel.macos]
+before-all = "brew install gcc"
+# NB: cibuildwheel evaluates these with bashlex, which supports command
+# substitution but *not* pipelines - hence the `sh -c` wrapper.
+environment = { CC = "$(sh -c 'ls $(brew --prefix gcc)/bin/gcc-* | sort -V | tail -1')", CXX = "$(sh -c 'ls $(brew --prefix gcc)/bin/g++-* | sort -V | tail -1')" }
+
+[tool.scikit-build.sdist]
+exclude = ["**/*"]
+include = [
+    "/src/IsoSpecPy/*.py",
+    "/src/IsoSpec++/*.c",
+    "/src/IsoSpec++/*.h",
+    "/src/IsoSpec++/*.hpp",
+    "/src/IsoSpec++/*.cpp",
+    # skbuild/CMakeLists.txt include()s IsaDispatch.cmake; without this the
+    # sdist configures no further than that line.
+    "/src/IsoSpec++/*.cmake",
+    "/VERSION",
+    "/LICENCE",
+    "/README.md",
+    "/pyproject.toml",
+    "/skbuild/CMakeLists.txt"
+]

isospecpy-2.5.0/skbuild/CMakeLists.txt

@@ -0,0 +1,71 @@
+cmake_minimum_required(VERSION 3.15)
+
+project(IsoSpecPy CXX)
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
+
+#find_package(PythonExtensions REQUIRED)
+#find_package(Python COMPONENTS Interpreter Development REQUIRED)
+
+# Runtime ISA dispatch. This matters most here: the wheel is built with no
+# -march at all, so without it every user gets the x86-64 baseline -- 2-double
+# vectors -- no matter what their CPU can do.
+include(${CMAKE_CURRENT_LIST_DIR}/../src/IsoSpec++/IsaDispatch.cmake)
+
+add_library(IsoSpecCppPy SHARED ../src/IsoSpec++/unity-build.cpp ${isospec_ISA_SRCS})
+target_compile_features(IsoSpecCppPy PRIVATE cxx_std_20)
+
+# macOS wheels are built with Homebrew GCC (Apple's libc++ has no
+# <experimental/simd>), and Homebrew bottles its libstdc++.6.dylib for the
+# *current* macOS -- minos 26.0 today. delocate refuses to bundle a dylib whose
+# minimum target is newer than the wheel's (11.0 on arm64), and hard-fails the
+# build. Linking the C++ runtime statically leaves libSystem as the only
+# dependency, so there is nothing for delocate to reject. The
+# "built for newer macOS version" warnings this draws from ld are the archive
+# members' own load commands and are harmless.
+#
+# Plain -static-libstdc++ is not enough, though: the archive members keep
+# default visibility, so the dylib would re-export ~2000 libstdc++ symbols.
+# Mach-O coalesces weak definitions (templates, inline functions, vtables)
+# across *all* loaded images regardless of two-level namespace, so a process
+# that also loads anything built against Homebrew's libstdc++.6.dylib ends up
+# with two copies of that runtime spliced together and aborts inside dlopen --
+# silently, with no dyld message and nothing Python can catch. A seven-line
+# extension whose static initialiser touches std::locale is enough to trigger
+# it; OldIsoSpecPy, which the wheel test suite installs, is one such consumer.
+# -load_hidden links the archive with all of its symbols hidden, so our private
+# copy of the runtime stays private. It replaces -static-libstdc++ (which would
+# otherwise pull the same archive in again, visibly).
+if(APPLE AND CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+  execute_process(COMMAND ${CMAKE_CXX_COMPILER} -print-file-name=libstdc++.a
+                  OUTPUT_VARIABLE ISOSPEC_LIBSTDCXX_A
+                  OUTPUT_STRIP_TRAILING_WHITESPACE)
+  if(NOT IS_ABSOLUTE "${ISOSPEC_LIBSTDCXX_A}" OR NOT EXISTS "${ISOSPEC_LIBSTDCXX_A}")
+    message(FATAL_ERROR
+      "${CMAKE_CXX_COMPILER} could not locate a static libstdc++.a "
+      "(-print-file-name returned '${ISOSPEC_LIBSTDCXX_A}'). The macOS wheel "
+      "needs one: linking libstdc++ dynamically makes delocate reject the "
+      "Homebrew bottle, and linking it visibly breaks other libstdc++ users "
+      "in the same process.")
+  endif()
+  # -load_hidden needs a reasonably modern ld64; an older one rejects the
+  # option outright, which is a loud failure rather than a silent regression.
+  #
+  # The archive is only half of it: our own translation units instantiate std::
+  # templates (std::to_string, sorts, the Mersenne twister), and those weak
+  # definitions coalesce across images just as readily. std:: is not part of
+  # this library's ABI -- callers reach it through cwrapper's extern "C"
+  # interface -- so none of it has any business being exported.
+  # tests/Python/test_cxx_runtime.py fails if any of this comes undone.
+  target_link_options(IsoSpecCppPy PRIVATE
+    -static-libgcc "-Wl,-load_hidden,${ISOSPEC_LIBSTDCXX_A}"
+    "-Wl,-unexported_symbol,__ZNSt*" "-Wl,-unexported_symbol,__ZNKSt*"
+    "-Wl,-unexported_symbol,__ZSt*")
+endif()
+#python_extension_module(IsoSpecCppPy)
+install(TARGETS IsoSpecCppPy LIBRARY DESTINATION IsoSpecPy)
+install(DIRECTORY ../src/IsoSpec++/ DESTINATION IsoSpecPy/IsoSpec++
+        FILES_MATCHING PATTERN "*.h" PATTERN "*.hpp" PATTERN "*.hxx"
+)

isospecpy-2.5.0/src/IsoSpec++/IsaDispatch.cmake

@@ -0,0 +1,78 @@
+# Runtime ISA dispatch, for the CMake builds.
+#
+# The two batched fill kernels are compiled once per instruction-set level, each
+# into its own translation unit with its own -march, and the one to run is chosen
+# from the CPU at startup. They must never share a compilation with the rest of
+# the library: a raised -march would otherwise reach every inline function in the
+# headers, and the linker could then pick an AVX-512 copy of one for a code path
+# reached on a CPU without it. See isa_kernels.h for the full reasoning.
+#
+# Include this, then add ${isospec_ISA_SRCS} to your target's sources. It sets
+# the per-source flags and defines ISOSPEC_ISA_DISPATCH=1 for the directory.
+#
+# The kernel sources deliberately get no -march of their own beyond the level
+# they implement: the baseline level has to stay runnable on any CPU of the
+# target architecture, since it is what dispatch falls back to.
+
+include(CheckCXXCompilerFlag)
+include(CheckCXXSourceCompiles)
+
+set(_isa_dir ${CMAKE_CURRENT_LIST_DIR})
+
+# Worth turning off when building exclusively for the machine that will run the
+# result (-march=native, say): dispatching costs an indirect call per marginal-0
+# run -- measured at 0.5-3% on the binned fill and 2-7% on the threshold fill --
+# which a single-level build compiled for the actual CPU does not pay.
+option(ISOSPEC_ISA_DISPATCH "Build several instruction-set levels and select at run time" ON)
+
+if(NOT ISOSPEC_ISA_DISPATCH)
+	set(isospec_ISA_SRCS "")
+	message(STATUS "IsoSpec: runtime ISA dispatch disabled; single-level build")
+	return()
+endif()
+
+set(isospec_ISA_SRCS
+	${_isa_dir}/isa_kernels_baseline.cpp
+	${_isa_dir}/isa_kernels_avx.cpp
+	${_isa_dir}/isa_kernels_v3.cpp
+	${_isa_dir}/isa_kernels_v4.cpp
+	)
+
+set(_isa_avx_flags -mavx)
+set(_isa_v3_flags -mavx2 -mfma)
+set(_isa_v4_flags -mavx512f -mavx512bw -mavx512dq -mavx512vl)
+
+# Only offer a level its flags where the compiler will take them; they are
+# meaningless off x86, and older toolchains may not know the AVX-512 ones. The
+# .cpp files then self-check the predefined macros those flags produce, so a
+# level whose flags did not arrive publishes an empty table and dispatch simply
+# never selects it -- rather than it being quietly built at the wrong width.
+check_cxx_compiler_flag("-mavx" ISOSPEC_CXX_ACCEPTS_AVX)
+check_cxx_compiler_flag("-mavx2 -mfma" ISOSPEC_CXX_ACCEPTS_V3)
+check_cxx_compiler_flag("-mavx512f -mavx512bw -mavx512dq -mavx512vl" ISOSPEC_CXX_ACCEPTS_V4)
+
+if(ISOSPEC_CXX_ACCEPTS_AVX)
+	set_source_files_properties(${_isa_dir}/isa_kernels_avx.cpp
+		PROPERTIES COMPILE_OPTIONS "${_isa_avx_flags}")
+	message(STATUS "IsoSpec: building ISA level avx (AVX, no FMA)")
+else()
+	message(STATUS "IsoSpec: ISA level avx not available with this compiler/target")
+endif()
+
+if(ISOSPEC_CXX_ACCEPTS_V3)
+	set_source_files_properties(${_isa_dir}/isa_kernels_v3.cpp
+		PROPERTIES COMPILE_OPTIONS "${_isa_v3_flags}")
+	message(STATUS "IsoSpec: building ISA level v3 (AVX2+FMA)")
+else()
+	message(STATUS "IsoSpec: ISA level v3 not available with this compiler/target")
+endif()
+
+if(ISOSPEC_CXX_ACCEPTS_V4)
+	set_source_files_properties(${_isa_dir}/isa_kernels_v4.cpp
+		PROPERTIES COMPILE_OPTIONS "${_isa_v4_flags}")
+	message(STATUS "IsoSpec: building ISA level v4 (AVX-512)")
+else()
+	message(STATUS "IsoSpec: ISA level v4 not available with this compiler/target")
+endif()
+
+add_definitions(-DISOSPEC_ISA_DISPATCH=1)