IsoSpecPy 2.3.3__tar.gz → 2.3.4__tar.gz

{isospecpy-2.3.3 → isospecpy-2.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: IsoSpecPy
-Version: 2.3.3
+Version: 2.3.4
 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

{isospecpy-2.3.3 → isospecpy-2.3.4}/pyproject.toml

@@ -9,7 +9,7 @@ cmake.source-dir = "skbuild"
 name = "IsoSpecPy"
 dependencies = ["cffi"]
 description = "IsoSpecPy is a Python library for computing isotopic distributions of molecules."
-version = "2.3.3"
+version = "2.3.4"
 license = "BSD-2-Clause"
 license-files = ["LICENCE"]
 authors = [{name = "Michał Startek"}, {name = "Mateusz Łącki"}]

{isospecpy-2.3.3 → isospecpy-2.3.4}/src/IsoSpec++/cwrapper.cpp

@@ -59,16 +59,46 @@ double getLightestPeakMassIso(void* iso)
     return reinterpret_cast<Iso*>(iso)->getLightestPeakMass();
 }
 
+double getLightestPeakLProbIso(void* iso)
+{
+    return reinterpret_cast<Iso*>(iso)->getLightestPeakLProb();
+}
+
+void getLightestPeakSignature(void* iso, int* space)
+{
+    reinterpret_cast<Iso*>(iso)->getLightestPeakSignature(space);
+}
+
 double getHeaviestPeakMassIso(void* iso)
 {
     return reinterpret_cast<Iso*>(iso)->getHeaviestPeakMass();
 }
 
+double getHeaviestPeakLProbIso(void* iso)
+{
+    return reinterpret_cast<Iso*>(iso)->getHeaviestPeakLProb();
+}
+
+void getHeaviestPeakSignature(void* iso, int* space)
+{
+    reinterpret_cast<Iso*>(iso)->getHeaviestPeakSignature(space);
+}
+
 double getMonoisotopicPeakMassIso(void* iso)
 {
     return reinterpret_cast<Iso*>(iso)->getMonoisotopicPeakMass();
 }
 
+double getMonoisotopicPeakLProbIso(void* iso)
+{
+    return reinterpret_cast<Iso*>(iso)->getMonoisotopicPeakLProb();
+}
+
+void getMonoisotopicPeakSignature(void* iso, int* space)
+{
+    reinterpret_cast<Iso*>(iso)->getMonoisotopicPeakSignature(space);
+}
+
 double getModeLProbIso(void* iso)
 {
     return reinterpret_cast<Iso*>(iso)->getModeLProb();
@@ -265,6 +295,12 @@ void* setupFixedEnvelope(double* masses, double* probs, size_t size, bool mass_s
     return reinterpret_cast<void*>(ret);
 }
 
+void* setupFixedEnvelopeWithConfs(double* masses, double* probs, int* confs, size_t size, int allDim, bool mass_sorted, bool prob_sorted, double total_prob)
+{
+    FixedEnvelope* ret = new FixedEnvelope(masses, probs, confs, size, allDim, mass_sorted, prob_sorted, total_prob);
+    return reinterpret_cast<void*>(ret);
+}
+
 void deleteFixedEnvelope(void* t, bool release_everything)
 {
     FixedEnvelope* tt = reinterpret_cast<FixedEnvelope*>(t);

{isospecpy-2.3.3 → isospecpy-2.3.4}/src/IsoSpec++/cwrapper.h

@@ -40,8 +40,14 @@ ISOSPEC_C_API void * setupIso(int             dimNumber,
 ISOSPEC_C_API void * isoFromFasta(const char* fasta, bool use_nominal_masses, bool add_water);
 
 ISOSPEC_C_API double getLightestPeakMassIso(void* iso);
+ISOSPEC_C_API double getLightestPeakLProbIso(void* iso);
+ISOSPEC_C_API void getLightestPeakSignature(void* iso, int* space);
 ISOSPEC_C_API double getHeaviestPeakMassIso(void* iso);
+ISOSPEC_C_API double getHeaviestPeakLProbIso(void* iso);
+ISOSPEC_C_API void getHeaviestPeakSignature(void* iso, int* space);
 ISOSPEC_C_API double getMonoisotopicPeakMassIso(void* iso);
+ISOSPEC_C_API double getMonoisotopicPeakLProbIso(void* iso);
+ISOSPEC_C_API void getMonoisotopicPeakSignature(void* iso, int* space);
 ISOSPEC_C_API double getModeLProbIso(void* iso);
 ISOSPEC_C_API double getModeMassIso(void* iso);
 ISOSPEC_C_API double getTheoreticalAverageMassIso(void* iso);
@@ -132,6 +138,7 @@ ISOSPEC_C_API void array_mul(double* array, size_t N, double what);
 ISOSPEC_C_API void array_fma(double* array, size_t N, double mul, double add);
 
 ISOSPEC_C_API void* setupFixedEnvelope(double* masses, double* probs, size_t size, bool mass_sorted, bool prob_sorted, double total_prob);
+ISOSPEC_C_API void* setupFixedEnvelopeWithConfs(double* masses, double* probs, int* confs, size_t size, int allDim, bool mass_sorted, bool prob_sorted, double total_prob);
 ISOSPEC_C_API void* copyFixedEnvelope(void* other);
 ISOSPEC_C_API void deleteFixedEnvelope(void* tabulator, bool releaseEverything);
 

{isospecpy-2.3.3 → isospecpy-2.3.4}/src/IsoSpec++/fixedEnvelopes.cpp

@@ -23,9 +23,9 @@ namespace IsoSpec
 {
 
 FixedEnvelope::FixedEnvelope(const FixedEnvelope& other) :
-_masses(array_copy<double>(other._masses, other._confs_no)),
-_probs(array_copy<double>(other._probs, other._confs_no)),
-_confs(array_copy_nptr<int>(other._confs, other._confs_no*other.allDim)),
+_masses(array_copy_malloc<double>(other._masses, other._confs_no)),
+_probs(array_copy_malloc<double>(other._probs, other._confs_no)),
+_confs(array_copy_nptr_malloc<int>(other._confs, other._confs_no*other.allDim)),
 _confs_no(other._confs_no),
 allDim(other.allDim),
 sorted_by_mass(other.sorted_by_mass),
@@ -56,6 +56,19 @@ _probs(in_probs),
 _confs(nullptr),
 _confs_no(in_confs_no),
 allDim(0),
+allDimSizeofInt(0),
+sorted_by_mass(masses_sorted),
+sorted_by_prob(probs_sorted),
+total_prob(_total_prob)
+{}
+
+FixedEnvelope::FixedEnvelope(double* in_masses, double* in_probs, int* in_confs, size_t in_confs_no, int _allDim, bool masses_sorted, bool probs_sorted, double _total_prob) :
+_masses(in_masses),
+_probs(in_probs),
+_confs(in_confs),
+_confs_no(in_confs_no),
+allDim(_allDim),
+allDimSizeofInt(_allDim * sizeof(int)),
 sorted_by_mass(masses_sorted),
 sorted_by_prob(probs_sorted),
 total_prob(_total_prob)

{isospecpy-2.3.3 → isospecpy-2.3.4}/src/IsoSpec++/fixedEnvelopes.h

@@ -71,6 +71,7 @@ class ISOSPEC_EXPORT_SYMBOL FixedEnvelope {
     FixedEnvelope(FixedEnvelope&& other);
 
     FixedEnvelope(double* masses, double* probs, size_t confs_no, bool masses_sorted = false, bool probs_sorted = false, double _total_prob = NAN);
+    FixedEnvelope(double* masses, double* probs, int* confs, size_t confs_no, int _allDim, bool masses_sorted = false, bool probs_sorted = false, double _total_prob = NAN);
 
     virtual ~FixedEnvelope()
     {

{isospecpy-2.3.3 → isospecpy-2.3.4}/src/IsoSpec++/isoSpec++.cpp

@@ -250,6 +250,25 @@ double Iso::getLightestPeakMass() const
     return mass;
 }
 
+double Iso::getLightestPeakLProb() const
+{
+    double lprob = 0.0;
+    for (int ii = 0; ii < dimNumber; ii++)
+        lprob += marginals[ii]->getLightestConfLProb();
+    return lprob;
+}
+
+void Iso::getLightestPeakSignature(int* space) const
+{
+    for (int ii = 0; ii < dimNumber; ii++)
+    {
+        size_t lightest_idx = marginals[ii]->getLightestAtomIndex();
+        for(int jj = 0; jj < isotopeNumbers[ii]; jj++)
+            space[jj] = (jj == lightest_idx ? atomCounts[ii] : 0);
+        space += isotopeNumbers[ii];
+    }
+}
+
 double Iso::getHeaviestPeakMass() const
 {
     double mass = 0.0;
@@ -258,6 +277,25 @@ double Iso::getHeaviestPeakMass() const
     return mass;
 }
 
+double Iso::getHeaviestPeakLProb() const
+{
+    double lprob = 0.0;
+    for (int ii = 0; ii < dimNumber; ii++)
+        lprob += marginals[ii]->getHeaviestConfLProb();
+    return lprob;
+}
+
+void Iso::getHeaviestPeakSignature(int* space) const
+{
+    for (int ii = 0; ii < dimNumber; ii++)
+    {
+        size_t heaviest_idx = marginals[ii]->getHeaviestAtomIndex();
+        for(int jj = 0; jj < isotopeNumbers[ii]; jj++)
+            space[jj] = (jj == heaviest_idx ? atomCounts[ii] : 0);
+        space += isotopeNumbers[ii];
+    }
+}
+
 double Iso::getMonoisotopicPeakMass() const
 {
     double mass = 0.0;
@@ -266,6 +304,25 @@ double Iso::getMonoisotopicPeakMass() const
     return mass;
 }
 
+double Iso::getMonoisotopicPeakLProb() const
+{
+    double lprob = 0.0;
+    for (int ii = 0; ii < dimNumber; ii++)
+        lprob += marginals[ii]->getMonoisotopicConfLProb();
+    return lprob;
+}
+
+void Iso::getMonoisotopicPeakSignature(int* space) const
+{
+    for (int ii = 0; ii < dimNumber; ii++)
+    {
+        size_t monoisotopic_idx = marginals[ii]->getMonoisotopicAtomIndex();
+        for(int jj = 0; jj < isotopeNumbers[ii]; jj++)
+            space[jj] = (jj == monoisotopic_idx ? atomCounts[ii] : 0);
+        space += isotopeNumbers[ii];
+    }
+}
+
 double Iso::getUnlikeliestPeakLProb() const
 {
     double lprob = 0.0;

{isospecpy-2.3.3 → isospecpy-2.3.4}/src/IsoSpec++/isoSpec++.h

@@ -135,9 +135,27 @@ class ISOSPEC_EXPORT_SYMBOL Iso {
     //! Get the mass of the lightest peak in the isotopic distribution.
     double getLightestPeakMass() const;
 
+    //! Get the log-probability of the lightest peak in the isotopic distribution.
+    double getLightestPeakLProb() const;
+
+    /*!
+        Write the counts of isotopes in the lightest peak into target memory location. It must be large enough to accomodate it.
+        \param space An array where counts of isotopes shall be written. Must be as big as the overall number of isotopes.
+    */
+    void getLightestPeakSignature(int* space) const;
+
     //! Get the mass of the heaviest peak in the isotopic distribution.
     double getHeaviestPeakMass() const;
 
+    //! Get the log-probability of the heaviest peak in the isotopic distribution.
+    double getHeaviestPeakLProb() const;
+
+    /*!
+        Write the counts of isotopes in the heaviest peak into target memory location. It must be large enough to accomodate it.
+        \param space An array where counts of isotopes shall be written. Must be as big as the overall number of isotopes.
+    */
+    void getHeaviestPeakSignature(int* space) const;
+
     /*!
         Get the mass of the monoisotopic peak in the isotopic distribution. Monoisotopc molecule is defined as
         consisting only of the most frequent isotopes of each element. These are often (but not always) the
@@ -145,6 +163,19 @@ class ISOSPEC_EXPORT_SYMBOL Iso {
     */
     double getMonoisotopicPeakMass() const;
 
+    /*!
+        Get the log-probability of the monoisotopic peak in the isotopic distribution. Monoisotopc molecule is defined as
+        consisting only of the most frequent isotopes of each element. These are often (but not always) the
+        lightest ones. Making this often (but again, not always) equal to getLightestPeakLProb()
+    */
+    double getMonoisotopicPeakLProb() const;
+
+    /*!
+        Write the counts of isotopes in the monoisotopic peak into target memory location. It must be large enough to accomodate it.
+        \param space An array where counts of isotopes shall be written. Must be as big as the overall number of isotopes.
+    */
+    void getMonoisotopicPeakSignature(int* space) const;
+
     //! Get the log-probability of the mode-configuration (if there are many modes, they share this value).
     double getModeLProb() const;
 

{isospecpy-2.3.3 → isospecpy-2.3.4}/src/IsoSpec++/marginalTrek++.cpp

@@ -256,6 +256,15 @@ double Marginal::getLightestConfMass() const
     return ret_mass*atomCnt;
 }
 
+double Marginal::getLightestConfLProb() const
+{
+    std::unique_ptr<int[]> lightest_conf = std::make_unique<int[]>(isotopeNo);
+    size_t lightest_idx = getLightestAtomIndex();
+    for(unsigned int ii = 0; ii < isotopeNo; ii++)
+        lightest_conf[ii] = (ii == lightest_idx ? atomCnt : 0);
+    return logProb(lightest_conf.get());
+}
+
 double Marginal::getHeaviestConfMass() const
 {
     double ret_mass = 0.0;
@@ -265,6 +274,15 @@ double Marginal::getHeaviestConfMass() const
     return ret_mass*atomCnt;
 }
 
+double Marginal::getHeaviestConfLProb() const
+{
+    std::unique_ptr<int[]> heaviest_conf = std::make_unique<int[]>(isotopeNo);
+    size_t heaviest_idx = getHeaviestAtomIndex();
+    for(unsigned int ii = 0; ii < isotopeNo; ii++)
+        heaviest_conf[ii] = (ii == heaviest_idx ? atomCnt : 0);
+    return logProb(heaviest_conf.get());
+}
+
 size_t Marginal::getMonoisotopicAtomIndex() const
 {
     double found_prob = -std::numeric_limits<double>::infinity();
@@ -278,12 +296,47 @@ size_t Marginal::getMonoisotopicAtomIndex() const
     return found_idx;
 }
 
+size_t Marginal::getLightestAtomIndex() const
+{
+    double found_mass = std::numeric_limits<double>::infinity();
+    size_t found_idx = 0;
+    for(unsigned int ii = 0; ii < isotopeNo; ii++)
+        if( found_mass > atom_masses[ii] )
+        {
+            found_mass = atom_masses[ii];
+            found_idx = ii;
+        }
+    return found_idx;
+}
+
+size_t Marginal::getHeaviestAtomIndex() const
+{
+    double found_mass = -std::numeric_limits<double>::infinity();
+    size_t found_idx = 0;
+    for(unsigned int ii = 0; ii < isotopeNo; ii++)
+        if( found_mass < atom_masses[ii] )
+        {
+            found_mass = atom_masses[ii];
+            found_idx = ii;
+        }
+    return found_idx;
+}
+
 double Marginal::getMonoisotopicConfMass() const
 {
     size_t idx = getMonoisotopicAtomIndex();
     return atom_masses[idx]*atomCnt;
 }
 
+double Marginal::getMonoisotopicConfLProb() const
+{
+    size_t idx = getMonoisotopicAtomIndex();
+    std::unique_ptr<int[]> monoisotopic_conf = std::make_unique<int[]>(isotopeNo);
+    for(unsigned int ii = 0; ii < isotopeNo; ii++)
+        monoisotopic_conf[ii] = (ii == idx ? atomCnt : 0);
+    return logProb(monoisotopic_conf.get());
+}
+
 double Marginal::getAtomAverageMass() const
 {
     double ret = 0.0;

{isospecpy-2.3.3 → isospecpy-2.3.4}/src/IsoSpec++/marginalTrek++.h

@@ -96,12 +96,18 @@ class Marginal
     */
     double getLightestConfMass() const;
 
+    //! Get the log-probability of the lightest subisotopologue.
+    double getLightestConfLProb() const;
+
     //! Get the mass of the heaviest subisotopologue.
     /*! This is trivially obtained by considering all atomNo atoms to be the heaviest isotope possible.
         \return The mass of the heaviest subisotopologue.
     */
     double getHeaviestConfMass() const;
 
+    //! Get the log-probability of the heaviest subisotopologue.
+    double getHeaviestConfLProb() const;
+
     //! Get the mass of the monoisotopic subisotopologue.
     /*! The monoisotopic subisotopologue is defined as the molecule consiting only
         of the most likely isotope. This is frequently the lightest subisotopologue,
@@ -109,12 +115,27 @@ class Marginal
     */
     double getMonoisotopicConfMass() const;
 
+    //! Get the log-probability of the monoisotopic subisotopologue.
+    double getMonoisotopicConfLProb() const;
+
     //! Get the index of the monoisotopic (most probable) atom.
     /*!
         \return The index of the most probable isotope of the element.
     */
     size_t getMonoisotopicAtomIndex() const;
 
+    //! Get the index of the lightest atom.
+    /*!
+        \return The index of the lightest isotope of the element.
+    */
+    size_t getLightestAtomIndex() const;
+
+    //! Get the index of the heaviest atom.
+    /*!
+        \return The index of the heaviest isotope of the element.
+    */
+    size_t getHeaviestAtomIndex() const;
+    
     //! The the mass of the mode subisotopologue.
     /*!
         \return The mass of one of the most probable subisotopologues.

{isospecpy-2.3.3 → isospecpy-2.3.4}/src/IsoSpec++/misc.h

@@ -128,6 +128,16 @@ template <typename T> inline static T* array_copy(const T* A, size_t size)
     return ret;
 }
 
+template <typename T> inline static T* array_copy_malloc(const T* A, size_t size)
+{
+    T* ret = reinterpret_cast<T*>(malloc(size * sizeof(T)));
+    if(ret == nullptr)
+        throw std::bad_alloc();
+    memcpy(ret, A, size*sizeof(T));
+    return ret;
+}
+
+
 template <typename T> static T* array_copy_nptr(const T* A, size_t size)
 {
     if(A == nullptr)
@@ -135,6 +145,14 @@ template <typename T> static T* array_copy_nptr(const T* A, size_t size)
     return array_copy(A, size);
 }
 
+template <typename T> static T* array_copy_nptr_malloc(const T* A, size_t size)
+{
+    if(A == nullptr)
+        return nullptr;
+    return array_copy_malloc(A, size);
+}
+
+
 template<typename T> void dealloc_table(T* tbl, int dim)
 {
     for(int i = 0; i < dim; i++)

{isospecpy-2.3.3 → isospecpy-2.3.4}/src/IsoSpecPy/IsoSpecPy.py

@@ -23,11 +23,6 @@ from .confs_passthrough import ConfsPassthrough
 from collections import namedtuple, OrderedDict
 import math
 
-try:
-    xrange
-except NameError:
-    xrange = range
-
 regex_pattern = re.compile('([A-Z][a-z]?)(-?[0-9]*)')
 ParsedFormula = namedtuple('ParsedFormula', 'atomCounts masses probs elems')
 
@@ -198,15 +193,16 @@ class Iso(object):
 
         offsets = []
 
-        if get_confs:
-            i = 0
-            for j in xrange(self.dimNumber):
-                newl = []
-                for k in xrange(self.isotopeNumbers[j]):
-                    newl.append(i)
-                    i += 1
-                offsets.append(tuple(newl))
-            self.offsets = tuple(offsets)
+        i = 0
+        for j in range(self.dimNumber):
+            newl = []
+            for k in range(self.isotopeNumbers[j]):
+                newl.append(i)
+                i += 1
+            offsets.append(tuple(newl))
+        self.offsets = tuple(offsets)
+
+        self.conf_space = isoFFI.ffi.new("int[" + str(sum(self.isotopeNumbers)) + "]")
 
         self.iso = self.ffi.setupIso(self.dimNumber, self.isotopeNumbers,
                                      self.atomCounts,
@@ -225,14 +221,41 @@ class Iso(object):
         """Get the lightest peak in the isotopic distribution."""
         return self.ffi.getLightestPeakMassIso(self.iso)
 
+    def getLightestPeakLProb(self):
+        """Get the log probability of the lightest peak in the isotopic distribution."""
+        return self.ffi.getLightestPeakLProbIso(self.iso)
+
+    def getLightestPeakConf(self):
+        """Get the isotopic configuration of the lightest peak in the isotopic distribution."""
+        self.ffi.getLightestPeakSignature(self.iso, self.conf_space)
+        return self.parse_conf(self.conf_space)
+
     def getHeaviestPeakMass(self):
         """Get the heaviest peak in the isotopic distribution."""
         return self.ffi.getHeaviestPeakMassIso(self.iso)
 
+    def getHeaviestPeakLProb(self):
+        """Get the log probability of the heaviest peak in the isotopic distribution."""
+        return self.ffi.getHeaviestPeakLProbIso(self.iso)
+
+    def getHeaviestPeakConf(self):
+        """Get the isotopic configuration of the heaviest peak in the isotopic distribution."""
+        self.ffi.getHeaviestPeakSignature(self.iso, self.conf_space)
+        return self.parse_conf(self.conf_space)
+
     def getMonoisotopicPeakMass(self):
         """Get the monoisotopic mass of the peak."""
         return self.ffi.getMonoisotopicPeakMassIso(self.iso)
 
+    def getMonoisotopicPeakLProb(self):
+        """Get the log probability of the monoisotopic peak in the isotopic distribution."""
+        return self.ffi.getMonoisotopicPeakLProbIso(self.iso)
+
+    def getMonoisotopicPeakConf(self):
+        """Get the isotopic configuration of the monoisotopic peak in the isotopic distribution."""
+        self.ffi.getMonoisotopicPeakSignature(self.iso, self.conf_space)
+        return self.parse_conf(self.conf_space)
+
     def getModeLProb(self):
         """Get the log probability of the most probable peak(s) in the isotopic distribution."""
         return self.ffi.getModeLProbIso(self.iso)
@@ -289,10 +312,10 @@ class IsoDistribution(object):
 
     def __iter__(self):
         if hasattr(self, "confs") and self.confs is not None:
-            for i in xrange(self.size):
+            for i in range(self.size):
                 yield(self.masses[i], self.probs[i], self.confs[i])
         else:
-            for i in xrange(self.size):
+            for i in range(self.size):
                 yield (self.masses[i], self.probs[i])
 
     def __getitem__(self, idx):
@@ -353,7 +376,10 @@ class IsoDistribution(object):
             raise RuntimeError("Invalid arguments for IsoDistribution constructor")
 
     def _get_cobject(self):
-        return isoFFI.clib.setupFixedEnvelope(self.masses, self.probs, len(self.masses), self.mass_sorted, self.prob_sorted, self._total_prob)
+        if hasattr(self, 'raw_confs') and self.raw_confs is not None:
+            return isoFFI.clib.setupFixedEnvelopeWithConfs(self.masses, self.probs, self.raw_confs, len(self.masses), self.sum_isotope_numbers, self.mass_sorted, self.prob_sorted, self._total_prob)
+        else:
+            return isoFFI.clib.setupFixedEnvelope(self.masses, self.probs, len(self.masses), self.mass_sorted, self.prob_sorted, self._total_prob)
 
     def copy(self):
         x = self._get_cobject()
@@ -694,7 +720,6 @@ class IsoGenerator(Iso):
         """
         self.cgen = None
         super(IsoGenerator, self).__init__(formula=formula, get_confs=get_confs, **kwargs)
-        self.conf_space = isoFFI.ffi.new("int[" + str(sum(self.isotopeNumbers)) + "]")
         self.firstuse = True
 
     def __iter__(self):

{isospecpy-2.3.3 → isospecpy-2.3.4}/src/IsoSpecPy/IsoSpecPyOld.py

@@ -9,7 +9,7 @@
 #
 #   IsoSpec is distributed in the hope that it will be useful,
 #   but WITHOUT ANY WARRANTY; without even the implied warranty of
-#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 #
 #   You should have received a copy of the Simplified BSD Licence
 #   along with IsoSpec.  If not, see <https://opensource.org/licenses/BSD-2-Clause>.
@@ -26,10 +26,6 @@ tested too...
 The current API is implemented in __init__.py, use that instead
 '''
 
-try:
-    xrange
-except NameError:
-    xrange = range
 
 import re
 from .IsoSpecPy import IsoTotalProb, IsoThreshold
@@ -80,7 +76,7 @@ class IsoSpec():
         except KeyError:
             raise Exception("Invalid ISO method")
 
-        # Reference to iso needs to be held in this object: it will deallocate masses/lprobs/etc arrays on C++ side if we 
+        # Reference to iso needs to be held in this object: it will deallocate masses/lprobs/etc arrays on C++ side if we
         # allow GC to collect it prematurely
         self.iso = algo(_stopCondition)
 
@@ -136,7 +132,7 @@ class IsoSpec():
         masses  = list(masses)
         logProbs= list(logProbs)
         confs = []
-        for i in xrange(rows_no):
+        for i in range(rows_no):
             confs.append([x for sublist in isoCounts[i] for x in sublist])
         return masses, logProbs, confs
 
@@ -157,7 +153,7 @@ class IsoSpec():
     def splitConf(self, l, offset = 0):
         conf = []
         idx = self.allIsotopeNumber * offset
-        for i in xrange(self.dimNumber):
+        for i in range(self.dimNumber):
             conf.append(tuple(l[idx:idx+self._isotopeNumbers[i]]))
             idx += self._isotopeNumbers[i]
         return tuple(conf)
@@ -169,7 +165,7 @@ class IsoSpec():
         masses, logProbs, isoCounts = self.getConfsRaw()
         confs = []
         step = sum(self._isotopeNumbers)
-        for i in xrange(len(masses)):
+        for i in range(len(masses)):
             confs.append((masses[i], logProbs[i], self.splitConf(isoCounts, i)))
 
         for conf in confs:
@@ -184,7 +180,7 @@ class IsoPlot(dict):
         self.bin_w = bin_w
         masses, logProbs, _isoCounts = iso.getConfsRaw()
         dd = defaultdict(Summator)
-        for i in xrange(len(masses)):
+        for i in range(len(masses)):
             dd[float(int(masses[i]/bin_w))*bin_w].add(math.exp(logProbs[i]))
         for key, val in dd.items():
             self[key] = val.get()

{isospecpy-2.3.3 → isospecpy-2.3.4}/src/IsoSpecPy/PeriodicTbl.py

@@ -1,10 +1,6 @@
 from .isoFFI import isoFFI
 from collections import defaultdict
 
-try:
-    xrange
-except NameError:
-    xrange = range
 
 number_of_isotopic_entries = isoFFI.clib.NUMBER_OF_ISOTOPIC_ENTRIES
 
@@ -13,7 +9,7 @@ symbol_to_massNo = defaultdict(tuple)
 symbol_to_probs  = defaultdict(tuple)
 symbol_to_atomic_number = {}
 
-for i in xrange(number_of_isotopic_entries):
+for i in range(number_of_isotopic_entries):
     symbol = isoFFI.ffi.string(isoFFI.clib.elem_table_symbol[i]).decode("ascii")
     symbol_to_masses[symbol] += (isoFFI.clib.elem_table_mass[i],)
     symbol_to_massNo[symbol] += (isoFFI.clib.elem_table_massNo[i],)

{isospecpy-2.3.3 → isospecpy-2.3.4}/src/IsoSpecPy/isoFFI.py

@@ -3,13 +3,16 @@ import platform
 import sys
 import glob
 from pathlib import Path
+
 if False:
     import IsoSpecCppPy
 
+
 class IsoFFI:
     def __init__(self):
         self.ffi = cffi.FFI()
-        self.ffi.cdef('''
+        self.ffi.cdef(
+            """
         void * setupIso(int dimNumber,
                 const int* isotopeNumbers,
                 const int* atomCounts,
@@ -19,8 +22,14 @@ class IsoFFI:
         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);
@@ -101,6 +110,7 @@ class IsoFFI:
                             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);
 
@@ -157,39 +167,47 @@ class IsoFFI:
         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
 
-        if (mod_dir.parent / 'setup.py').exists():
-            raise ImportError('''Attempted to load IsoSpecPy module from its build directory. This usually
+        if (mod_dir.parent / "setup.py").exists():
+            raise ImportError(
+                """Attempted to load IsoSpecPy module from its build directory. This usually
 won't work and is generally a Bad Idea. Please cd somewhere else, or, if you're really
-sure you want to do that, edit the source and disable this check.''')
+sure you want to do that, edit the source and disable this check."""
+            )
 
-        libnames  = ['IsoSpecCppPy*', 'IsoSpec++*']
-        libprefix = ['', 'lib', 'Lib']
-        extension = ['.so', '.dylib', '.dll']
+        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']
+            if platform.system() == "Linux":
+                extension = [".so", "pyd"]
+            elif platform.system() == "Windows":
+                extension = [".dll", ".pyd"]
         except:
             pass
 
-        prebuilt =  ['', 'prebuilt-']
+        prebuilt = ["", "prebuilt-"]
 
         def cprod(ll1, ll2):
             res = []
             for l1 in ll1:
                 for l2 in ll2:
-                    res.append(l1+l2)
+                    res.append(l1 + l2)
             return res
 
         paths_to_check = cprod(prebuilt, cprod(libprefix, cprod(libnames, extension)))
         dpc = []
 
-        for dirpath in [mod_dir, mod_dir.parent, mod_dir.parent / 'bin', mod_dir.parent / 'lib']:
+        for dirpath in [
+            mod_dir,
+            mod_dir.parent,
+            mod_dir.parent / "bin",
+            mod_dir.parent / "lib",
+        ]:
             dpc.extend([dirpath / p for p in paths_to_check])
 
         paths_to_check = dpc
@@ -200,7 +218,10 @@ sure you want to do that, edit the source and disable this check.''')
         paths_to_check = expanded
         try:
             import importlib
-            paths_to_check.insert(0, Path(importlib.util.find_spec("IsoSpecCppPy").origin))
+
+            paths_to_check.insert(
+                0, Path(importlib.util.find_spec("IsoSpecCppPy").origin)
+            )
         except (ImportError, AttributeError):
             pass
 
@@ -213,11 +234,21 @@ sure you want to do that, edit the source and disable this check.''')
                 self.libpath = libpath
                 break
             except (IndexError, OSError) as e:
-                errmsg = "Load libIsoSpec++.so, tried: " + libpath + '\n' + "Got error: " + str(type(e)) + ": " + str(e)
+                errmsg = (
+                    "Load libIsoSpec++.so, tried: "
+                    + 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))
+            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