IsoSpecPy 2.5.0__py3-none-win_arm64.whl

IsoSpecPy/isoFFI.py

@@ -0,0 +1,290 @@
+import cffi
+import platform
+from pathlib import Path
+
+
+class IsoFFI:
+    def __init__(self):
+        self.ffi = cffi.FFI()
+        self.ffi.cdef(
+            """
+        void * setupIso(int dimNumber,
+                const int* isotopeNumbers,
+                const int* atomCounts,
+                const double* isotopeMasses,
+                const double* isotopeProbabilities);
+
+        void * isoFromFasta(const char* fasta, bool use_nominal_masses, bool add_water);
+
+        double getLightestPeakMassIso(void* iso);
+        double getLightestPeakLProbIso(void* iso);
+        void getLightestPeakSignature(void* iso, int* space);
+        double getHeaviestPeakMassIso(void* iso);
+        double getHeaviestPeakLProbIso(void* iso);
+        void getHeaviestPeakSignature(void* iso, int* space);
+        double getMonoisotopicPeakMassIso(void* iso);
+        double getMonoisotopicPeakLProbIso(void* iso);
+        void getMonoisotopicPeakSignature(void* iso, int* space);
+        double getModeLProbIso(void* iso);
+        double getModeMassIso(void* iso);
+        double getTheoreticalAverageMassIso(void* iso);
+        double getIsoVariance(void* iso);
+        double getIsoStddev(void* iso);
+        double* getMarginalLogSizeEstimates(void* iso, double target_total_prob);
+
+        void deleteIso(void* iso);
+
+        void* setupIsoThresholdGenerator(void* iso,
+                                         double threshold,
+                                         bool _absolute,
+                                         int _tabSize,
+                                         int _hashSize,
+                                         bool reorder_marginals);
+        double massIsoThresholdGenerator(void* generator);
+        double lprobIsoThresholdGenerator(void* generator);
+        double probIsoThresholdGenerator(void* generator);
+        bool advanceToNextConfigurationIsoThresholdGenerator(void* generator);
+        void deleteIsoThresholdGenerator(void* generator);
+        void get_conf_signatureIsoThresholdGenerator(void* generator, int* space);
+
+
+
+        void* setupIsoLayeredGenerator(void* iso,
+                                       int _tabSize,
+                                       int _hashSize,
+                                       bool reorder_marginals,
+                                       double t_prob_hint);
+        double massIsoLayeredGenerator(void* generator);
+        double lprobIsoLayeredGenerator(void* generator);
+        double probIsoLayeredGenerator(void* generator);
+        bool advanceToNextConfigurationIsoLayeredGenerator(void* generator);
+        void deleteIsoLayeredGenerator(void* generator);
+        void get_conf_signatureIsoLayeredGenerator(void* generator, int* space);
+
+
+        void* setupIsoOrderedGenerator(void* iso,
+                                       int _tabSize,
+                                       int _hashSize);
+        double massIsoOrderedGenerator(void* generator);
+        double lprobIsoOrderedGenerator(void* generator);
+        double probIsoOrderedGenerator(void* generator);
+        bool advanceToNextConfigurationIsoOrderedGenerator(void* generator);
+        void deleteIsoOrderedGenerator(void* generator);
+        void get_conf_signatureIsoOrderedGenerator(void* generator, int* space);
+
+        void* setupIsoStochasticGenerator(void* iso,
+                                   size_t no_molecules,
+                                   double precision,
+                                   double beta_bias);
+        double massIsoStochasticGenerator(void* generator);
+        double lprobIsoStochasticGenerator(void* generator);
+        double probIsoStochasticGenerator(void* generator);
+        bool advanceToNextConfigurationIsoStochasticGenerator(void* generator);
+        void deleteIsoStochasticGenerator(void* generator);
+        void get_conf_signatureIsoStochasticGenerator(void* generator, int* space);
+
+        void* setupThresholdFixedEnvelope(void* iso,
+                                    double threshold,
+                                    bool absolute,
+                                    bool get_confs);
+
+        void* setupTotalProbFixedEnvelope(void* iso,
+                                      double taget_coverage,
+                                      bool optimize,
+                                      bool get_confs);
+
+        void* setupStochasticFixedEnvelope(void* iso,
+                                     size_t no_molecules,
+                                     double precision,
+                                     double beta_bias,
+                                     bool get_confs);
+
+        void* setupBinnedFixedEnvelope(void* iso,
+                            double target_total_prob,
+                            double bin_width,
+                            double bin_middle);
+
+        void* setupFixedEnvelope(double* masses, double* probs, size_t size, bool mass_sorted, bool prob_sorted, double total_prob);
+        void* setupFixedEnvelopeWithConfs(double* masses, double* probs, int* confs, size_t size, int allDim, bool mass_sorted, bool prob_sorted, double total_prob);
+        void* copyFixedEnvelope(void* other);
+        void deleteFixedEnvelope(void* tabulator, bool releaseEverything);
+
+        const double* massesFixedEnvelope(void* tabulator);
+        const double* probsFixedEnvelope(void* tabulator);
+        const int*    confsFixedEnvelope(void* tabulator);
+        size_t confs_noFixedEnvelope(void* tabulator);
+
+        typedef void (*IsoSpecArrayDeleter)(void* array, size_t size);
+
+        double* massesFixedEnvelopeWithDeleter(void* tabulator, size_t* size_out, IsoSpecArrayDeleter* deleter_out);
+        double* probsFixedEnvelopeWithDeleter(void* tabulator, size_t* size_out, IsoSpecArrayDeleter* deleter_out);
+        int*    confsFixedEnvelopeWithDeleter(void* tabulator, size_t* size_out, IsoSpecArrayDeleter* deleter_out);
+        void freeReleasedArrayWithDeleter(void* array, size_t size, IsoSpecArrayDeleter deleter);
+
+        double empiricAverageMass(void* tabulator);
+        double empiricVariance(void* tabulator);
+        double empiricStddev(void* tabulator);
+
+        double wassersteinDistance(void* tabulator1, void* tabulator2);
+        double orientedWassersteinDistance(void* tabulator1, void* tabulator2);
+        double abyssalWassersteinDistance(void* tabulator1, void* tabulator2, double abyss_depth, double other_scale);
+//        double abyssalWassersteinDistanceGrad(void* const* envelopes, const double* scales, double* ret_gradient, size_t N, double abyss_depth_exp, double abyss_depth_the);
+
+        struct ws_match_res{
+        double res1;
+        double res2;
+        double flow;
+        };
+
+        struct ws_match_res wassersteinMatch(void* tabulator1, void* tabulator2, double flow_dist, double other_scale);
+
+        void* addEnvelopes(void* tabulator1, void* tabulator2);
+        void* convolveEnvelopes(void* tabulator1, void* tabulator2);
+
+        double getTotalProbOfEnvelope(void* envelope);
+        void scaleEnvelope(void* envelope, double factor);
+        void normalizeEnvelope(void* envelope);
+        void shiftMassEnvelope(void* envelope, double d_mass);
+        void resampleEnvelope(void* envelope, size_t ionic_current, double beta_bias);
+        void* binnedEnvelope(void* envelope, double width, double middle);
+        void* linearCombination(void* const * const envelopes, const double* intensities, size_t count);
+
+        void sortEnvelopeByMass(void* envelope);
+        void sortEnvelopeByProb(void* envelope);
+
+        void freeReleasedArray(void* array);
+        void array_add(double* array, size_t N, double what);
+        void array_mul(double* array, size_t N, double what);
+        void array_fma(double* array, size_t N, double mul, double add);
+
+        void parse_fasta_c(const char* fasta, int atomCounts[6]);
+
+        void* isoFromFastaWithMods(const char* sequence, bool use_nominal_masses, bool add_water, const char* unimod_db_path);
+        void* parseFastaWithModsC(const char* sequence, const char* unimod_db_path);
+        size_t compositionSizeC(void* composition);
+        const char* const* compositionSymbolsC(void* composition);
+        const int* compositionCountsC(void* composition);
+        void deleteCompositionC(void* composition);
+
+        void* expandCompositionC(const char* const* symbols, const int* counts, size_t size, bool use_nominal_masses);
+        const int* expandedIsotopeNumbersC(void* expanded);
+        const int* expandedAtomCountsC(void* expanded);
+        const double* expandedIsotopeMassesC(void* expanded);
+        const double* expandedIsotopeProbabilitiesC(void* expanded);
+        void deleteExpandedCompositionC(void* expanded);
+
+        const char* activeSimdLevel(void);
+
+        // Must be kept in sync by hand with ISOSPEC_NUMBER_OF_ISOTOPIC_ENTRIES
+        // in element_tables.h -- see PeriodicTbl.py's comment on why this
+        // can't be read from isospec_number_of_isotopic_entries (the real
+        // compiled variable, right below) instead: cffi's dlopen ABI mode
+        // can't access plain extern const globals, only #define constants
+        // like this one. A stale value here silently drops table entries in
+        // Python without erroring (already happened once, #51/deuterium).
+        #define NUMBER_OF_ISOTOPIC_ENTRIES 293
+        extern const size_t isospec_number_of_isotopic_entries;
+        extern const int elem_table_atomicNo[NUMBER_OF_ISOTOPIC_ENTRIES];
+        extern const double elem_table_probability[NUMBER_OF_ISOTOPIC_ENTRIES];
+        extern const double elem_table_mass[NUMBER_OF_ISOTOPIC_ENTRIES];
+        extern const double elem_table_massNo[NUMBER_OF_ISOTOPIC_ENTRIES];
+        extern const int elem_table_extraNeutrons[NUMBER_OF_ISOTOPIC_ENTRIES];
+        extern const char* elem_table_element[NUMBER_OF_ISOTOPIC_ENTRIES];
+        extern const char* elem_table_symbol[NUMBER_OF_ISOTOPIC_ENTRIES];
+        extern const bool elem_table_Radioactive[NUMBER_OF_ISOTOPIC_ENTRIES];
+                        """
+        )
+
+        mod_dir = Path(__file__).resolve().parent
+
+        libnames = ["IsoSpecCppPy*", "IsoSpec++*"]
+        libprefix = ["", "lib", "Lib"]
+        extension = [".so", ".dylib", ".dll"]
+        try:
+            if platform.system() == "Linux":
+                extension = [".so", ".pyd"]
+            elif platform.system() == "Windows":
+                extension = [".dll", ".pyd"]
+        except:
+            pass
+
+        prebuilt = ["", "prebuilt-"]
+
+        def cprod(ll1, ll2):
+            res = []
+            for l1 in ll1:
+                for l2 in ll2:
+                    res.append(l1 + l2)
+            return res
+
+        paths_to_check = cprod(prebuilt, cprod(libprefix, cprod(libnames, extension)))
+        dpc = []
+
+        search_dirs = [
+            mod_dir,
+            mod_dir.parent,
+            mod_dir.parent / "bin",
+            mod_dir.parent / "lib",
+        ]
+
+        # Editable installs (scikit-build-core) redirect this module's
+        # __file__ to the source tree, but build the compiled extension
+        # straight into the installed package's own site-packages
+        # directory instead -- mod_dir above never sees it. Search that
+        # directory too, when it isn't already mod_dir.
+        try:
+            import importlib.util
+
+            installed_pkg = importlib.util.find_spec("IsoSpecPy")
+            for loc in installed_pkg.submodule_search_locations or []:
+                loc = Path(loc)
+                if loc not in search_dirs:
+                    search_dirs.append(loc)
+        except (ImportError, AttributeError, ValueError):
+            pass
+
+        for dirpath in search_dirs:
+            dpc.extend([dirpath / p for p in paths_to_check])
+
+        paths_to_check = dpc
+        # expand glob patterns using pathlib (keep only actual matches, like glob.glob did)
+        expanded = []
+        for p in paths_to_check:
+            expanded.extend(p.parent.glob(p.name))
+        paths_to_check = expanded
+        try:
+            import importlib
+
+            paths_to_check.insert(
+                0, Path(importlib.util.find_spec("IsoSpecCppPy").origin)
+            )
+        except (ImportError, AttributeError):
+            pass
+
+        errors = []
+
+        self.clib = None
+        for libpath in set(paths_to_check):
+            try:
+                self.clib = self.ffi.dlopen(str(libpath))
+                self.libpath = libpath
+                break
+            except (IndexError, OSError) as e:
+                errmsg = (
+                    "Load libIsoSpec++.so, tried: "
+                    + str(libpath)
+                    + "\n"
+                    + "Got error: "
+                    + str(type(e))
+                    + ": "
+                    + str(e)
+                )
+                errors.append(errmsg)
+
+        if self.clib == None:
+            raise ImportError(
+                "Cannot find or load the C++ part of the library\n" + "\n".join(errors)
+            )
+
+
+isoFFI = IsoFFI()  # This is done while including the module

isospecpy-2.5.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,45 @@
+bin/IsoSpecCppPy.dll,sha256=XUfxu6zbvOIZ1eYki0tuP2fWiCXGoaXU5vaXr4GAQvc,262144
+IsoSpecPy/__init__.py,sha256=Tjgv2E5pcPq4iSFiuZD4oJiOpqzaMuzkvzQVU843rrE,504
+IsoSpecPy/__main__.py,sha256=Xr6SHPmCkpA3rPFbSBwxd2xl85eEKs6XDTLVWKZxcp4,1034
+IsoSpecPy/Advanced.py,sha256=70LP-AOVr3lsfmCP_zivaXU0auhKWfgt6I8icbptxxg,1090
+IsoSpecPy/approximations.py,sha256=e9kLSARQ-VMoXFayfyp8byrbVLxk6IFwoGz1iHXzKlI,4241
+IsoSpecPy/confs_passthrough.py,sha256=Ythe_zSlI2Z69ajCCftubZSqLvHKz2kSRjF1Vc-pE6M,284
+IsoSpecPy/Distributions.py,sha256=-GayrDO1bfs5EdPBMFf5K_b8QRgY-bqgg8qKH7P62fE,2582
+IsoSpecPy/Formulas.py,sha256=blOy63xIfJcfR5WDYHNSCX3CMsdsOvVWpcAraKm67uE,1730
+IsoSpecPy/isoFFI.py,sha256=HyWpphPVTHwM_yin3Cik3VCXHTp-KBNzGP4ucjgl4ZM,13350
+IsoSpecPy/IsoSpec++/aligned_ptr.h,sha256=5Ul3I3Qkrwrb_V8cpguS50K1FQVro10PrwpvTZ9jlfs,23323
+IsoSpecPy/IsoSpec++/allocator.h,sha256=dyWhQvpCZnDEby0YMyFbA_dVhYrKwMv8Pk4hLubYaLw,1662
+IsoSpecPy/IsoSpec++/btrd.h,sha256=tPbQ6GZk1XpT9ESt4xEqL8TERKzbEnNRIKKGSq4nlNo,6226
+IsoSpecPy/IsoSpec++/composition.h,sha256=sOE3Gf4iae9ky_A46UY2mWD0sBpLTuBCgxy8CrzQDWI,6078
+IsoSpecPy/IsoSpec++/conf.h,sha256=N_dBUbO3RVO9LoSAvjRWtnrjVOqMbcKgbp5q9bJp93M,1008
+IsoSpecPy/IsoSpec++/cwrapper.h,sha256=TMmCCRXn_dmSDc7MMIYX5F1la_0UqoOCDAxm0IVukqk,14525
+IsoSpecPy/IsoSpec++/dirtyAllocator.h,sha256=aB1ebPacCfIPtGXmcxfCP7XJZpu7AuNQrsKlcOE48aI,1472
+IsoSpecPy/IsoSpec++/element_lookup.h,sha256=uAGQJZlMVLFpCRJ6wzPuU3do6_W9niUrTq9A2UEW-fs,1394
+IsoSpecPy/IsoSpec++/element_tables.h,sha256=Y8Okqc2_4ce7znXt9LArBR4JCaK0Wh_-Ih6Nh9YnLfE,1844
+IsoSpecPy/IsoSpec++/fasta.h,sha256=OwJVrrsV6P6fFmhjohxwRJkazOJhJxP1Qc9FxB7bQIE,2325
+IsoSpecPy/IsoSpec++/fasta_mods.h,sha256=pGBIp7ni3jzgOScMY9IiJnSlp4JSry0UEV1KG4P_hiU,3508
+IsoSpecPy/IsoSpec++/fixedEnvelopes.h,sha256=_oTh3R0F9QXePOzqdnLmYzt_Qg9bW_DbfuhtEjD_4Uk,17639
+IsoSpecPy/IsoSpec++/isa_kernel_impl.h,sha256=qKPfLZgYHgBfwQnHUplhMalsS595SPhXTsQhGGHcylA,7974
+IsoSpecPy/IsoSpec++/isa_kernels.h,sha256=NPTB5NYBNY8mZ6fKVt-PtYiFhwXT4g6HVYoWQgw44UA,8753
+IsoSpecPy/IsoSpec++/iso_simd.h,sha256=lkQ7wVZHp9XAMgW4FEIe1t3mWbctJKHueQPKdAX0_B4,2111
+IsoSpecPy/IsoSpec++/isoMath.h,sha256=2tGDWvSruE-eJ2Kcnm0FUakcURYzCxiVdp7S7YepNLk,4275
+IsoSpecPy/IsoSpec++/isoSpec++.h,sha256=weTRGJ8jY5ktTi_50KeJdQq3GXYrtQ4RtLvngRWBy78,36434
+IsoSpecPy/IsoSpec++/marginalTrek++.h,sha256=82iOh5EVrQEjd3w09_oqvqvkwCOMt64o2QUN2JkRGO8,28321
+IsoSpecPy/IsoSpec++/misc.h,sha256=zoBy5nhsZo0rdIQN4d1AbuGQdUQ-rywLJVV3FMcasC8,6100
+IsoSpecPy/IsoSpec++/mman.h,sha256=RxwibELl7IRwWbn672Gg4-DeDGXXL6tFhM12kIMx5EE,1751
+IsoSpecPy/IsoSpec++/operators.h,sha256=tD5hL-lPpLQ_LOEZMH61eenn-5L67Io-JJ8v7NovUpc,4131
+IsoSpecPy/IsoSpec++/platform.h,sha256=gzaU4INxV7WQn7tbmFP2GuegdLnuIox-giHz5Wigimk,7092
+IsoSpecPy/IsoSpec++/platform_incl.h,sha256=6MW4V759ZXdHaHtfH9o5nNmOXj2kCx8E_SiRO1mgBiM,966
+IsoSpecPy/IsoSpec++/pod_vector.h,sha256=apnrfZS_4mNZ_xRoa6TmP1atyMC79HYG6ofeemt7_pk,11823
+IsoSpecPy/IsoSpec++/summator.h,sha256=M-2IV9NU4PTWXIa3fq9Nz3StR9ZT22cZFH1utnmcf98,2425
+IsoSpecPy/IsoSpec++/unimod.h,sha256=MOBn1HTHn4uLQRYwwH6w9Ow8xtDGchHAFayofiiiHxE,3368
+IsoSpecPy/IsoSpec++/unimod_support.h,sha256=ESWUkCGzeA5ou9-2vGSMlNRBcMNIaxrdWLhmKftCxUk,122473
+IsoSpecPy/IsoSpec++/unimod_table_data.h,sha256=LRlguv9E5dhRHRlBKwom4e7BEFpSRIEt_N4YcV2A3fY,37860
+IsoSpecPy/IsoSpecPy.py,sha256=AG0DWfxBQYLyl7TgC5WI1AVjfPqQ0j1e0yKhQIvTveU,50472
+IsoSpecPy/IsoSpecPyOld.py,sha256=6w1sZBhtyA87zGrAibsAvVDxKfqAZwbmYk_57x70GsI,11383
+IsoSpecPy/PeriodicTbl.py,sha256=5EeB5zLJlBnWGodde-AevsCNrI0S1sgn9Nod1t1_xVs,2587
+lib/IsoSpecCppPy.lib,sha256=S9UHc4qUqCVfgH0C3CVZklGo_NGasEruJGUpWEhn4eU,27540
+isospecpy-2.5.0.dist-info/METADATA,sha256=81b8S8_GyeGmWCnqkbMMrvinLWgEzYZ5LSFpNPwvhKU,10480
+isospecpy-2.5.0.dist-info/WHEEL,sha256=5341l7rLjEaIZp8mesTxb1JV3JsiKV2GLmJQcYtx6lg,102
+isospecpy-2.5.0.dist-info/licenses/LICENCE,sha256=gfZw5llAwrHH4rkp5FJuq9VAuamp1x7x8MDmDjj8dpw,1705
+isospecpy-2.5.0.dist-info/RECORD,,

isospecpy-2.5.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 1.1.0
+Root-Is-Purelib: false
+Tag: py3-none-win_arm64
+

isospecpy-2.5.0.dist-info/licenses/LICENCE

@@ -0,0 +1,35 @@
+IsoSpec is provided under the terms of 2-clause BSD licence.
+If you require other licensing terms, please contact the authors. 
+
+We would appreciate if you let us know if you use this library in 
+your own software, but you are under no legal obligation to do so.
+
+
+-------------------------------------------------------------------------
+
+
+Copyright (c) 2015-2025, Michał Startek and Mateusz Łącki
+
+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.
+
+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 OWNER 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.
+
+