b2bTools 3.0.7b2__tar.gz → 3.0.8b3__tar.gz

{b2bTools-3.0.7b2 → b2bTools-3.0.8b3}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.1
 Name: b2bTools
-Version: 3.0.7b2
+Version: 3.0.8b3
 Summary: bio2Byte software suite to predict protein biophysical properties from their amino-acid sequences
 Home-page: https://bio2byte.be
 Author: Wim Vranken
 Author-email: Wim.Vranken@vub.be
-Maintainer: Jose Gavalda-Garcia, Adrian Diaz, Wim Vranken
-Maintainer-email: jose.gavalda.garcia@vub.be, adrian.diaz@vub.be, wim.vranken@vub.be
+Maintainer: Adrián Díaz, Sophie-Luise Heidig, Wim Vranken
+Maintainer-email: adrian.diaz@vub.be, wim.vranken@vub.be
 License: OSI Approved :: GNU General Public License v3 (GPLv3)
 Project-URL: Documentation, https://bio2byte.be/b2btools/package-documentation
 Project-URL: HTML interface, https://bio2byte.be/b2btools
@@ -29,74 +29,6 @@ Classifier: Intended Audience :: Education
 Classifier: Development Status :: 5 - Production/Stable
 Requires-Python: >=3.7, <3.13
 Description-Content-Type: text/markdown
-Requires-Dist: biopython~=1.81; python_version == "3.7"
-Requires-Dist: Cython~=0.29.37; python_version == "3.7"
-Requires-Dist: matplotlib~=3.5.3; python_version == "3.7"
-Requires-Dist: numpy~=1.21; python_version == "3.7"
-Requires-Dist: pandas~=1.1; python_version == "3.7"
-Requires-Dist: pomegranate~=0.14; python_version == "3.7"
-Requires-Dist: requests~=2.0; python_version == "3.7"
-Requires-Dist: scikit-learn~=1.0.2; python_version == "3.7"
-Requires-Dist: scipy==1.7.3; python_version == "3.7"
-Requires-Dist: torch==1.13.1; python_version == "3.7"
-Requires-Dist: torchvision==0.14.1; python_version == "3.7"
-Requires-Dist: urllib3~=1.26.6; python_version == "3.7"
-Requires-Dist: biopython~=1.81; python_version == "3.8"
-Requires-Dist: Cython~=0.29.37; python_version == "3.8"
-Requires-Dist: matplotlib~=3.5.3; python_version == "3.8"
-Requires-Dist: numpy~=1.24; python_version == "3.8"
-Requires-Dist: pandas~=1.1; python_version == "3.8"
-Requires-Dist: pomegranate~=0.14; python_version == "3.8"
-Requires-Dist: requests~=2.0; python_version == "3.8"
-Requires-Dist: scikit-learn~=1.0.2; python_version == "3.8"
-Requires-Dist: scipy==1.10.1; python_version == "3.8"
-Requires-Dist: torch==1.13.1; python_version == "3.8"
-Requires-Dist: torchvision==0.14.1; python_version == "3.8"
-Requires-Dist: urllib3~=1.26.6; python_version == "3.8"
-Requires-Dist: biopython~=1.81; python_version == "3.9"
-Requires-Dist: Cython~=0.29.37; python_version == "3.9"
-Requires-Dist: matplotlib~=3.5.3; python_version == "3.9"
-Requires-Dist: numpy~=1.24; python_version == "3.9"
-Requires-Dist: pandas~=1.1; python_version == "3.9"
-Requires-Dist: pomegranate~=0.14; python_version == "3.9"
-Requires-Dist: requests~=2.0; python_version == "3.9"
-Requires-Dist: scikit-learn~=1.0.2; python_version == "3.9"
-Requires-Dist: scipy==1.10.1; python_version == "3.9"
-Requires-Dist: torch==1.13.1; python_version == "3.9"
-Requires-Dist: torchvision==0.14.1; python_version == "3.9"
-Requires-Dist: urllib3~=1.26.6; python_version == "3.9"
-Requires-Dist: biopython~=1.83; python_version == "3.10"
-Requires-Dist: Cython~=0.29.37; python_version == "3.10"
-Requires-Dist: matplotlib~=3.5.3; python_version == "3.10"
-Requires-Dist: numpy~=1.26.4; python_version == "3.10"
-Requires-Dist: pandas~=1.5.3; python_version == "3.10"
-Requires-Dist: pomegranate~=0.14; python_version == "3.10"
-Requires-Dist: requests~=2.31.0; python_version == "3.10"
-Requires-Dist: scikit-learn~=1.0.2; python_version == "3.10"
-Requires-Dist: scipy~=1.12.0; python_version == "3.10"
-Requires-Dist: torch~=1.13.1; python_version == "3.10"
-Requires-Dist: torchvision~=0.14.1; python_version == "3.10"
-Requires-Dist: urllib3~=1.26.6; python_version == "3.10"
-Requires-Dist: biopython~=1.83; python_version == "3.11"
-Requires-Dist: matplotlib~=3.8.3; python_version == "3.11"
-Requires-Dist: numpy~=1.26.4; python_version == "3.11"
-Requires-Dist: pandas~=1.5.3; python_version == "3.11"
-Requires-Dist: pomegranate~=0.14.9; python_version == "3.11"
-Requires-Dist: requests~=2.31.0; python_version == "3.11"
-Requires-Dist: scikit-learn~=1.4.1.post1; python_version == "3.11"
-Requires-Dist: scipy~=1.12.0; python_version == "3.11"
-Requires-Dist: torch~=2.2.0; python_version == "3.11"
-Requires-Dist: urllib3~=1.26.18; python_version == "3.11"
-Requires-Dist: biopython~=1.83; python_version == "3.12"
-Requires-Dist: matplotlib~=3.8.3; python_version == "3.12"
-Requires-Dist: numpy~=1.26.4; python_version == "3.12"
-Requires-Dist: pandas~=2.1.0; python_version == "3.12"
-Requires-Dist: pomegranate~=0.14.9; python_version == "3.12"
-Requires-Dist: requests~=2.31.0; python_version == "3.12"
-Requires-Dist: scikit-learn~=1.4.1.post1; python_version == "3.12"
-Requires-Dist: scipy~=1.12.0; python_version == "3.12"
-Requires-Dist: torch~=2.2.0; python_version == "3.12"
-Requires-Dist: urllib3~=1.26.6; python_version == "3.12"
 
 <h1 align="center">
   <a href="bio2byte.be/b2btools" target="_blank" ref="noreferrer noopener">

{b2bTools-3.0.7b2 → b2bTools-3.0.8b3}/b2bTools/__main__.py

@@ -109,7 +109,7 @@ def run(parsed_args):
             logging.info(f"Saving results for {sequence_key} in tabular format in: {output_tabular_file}")
             wrapper.get_all_predictions_tabular(output_tabular_file, sep=sep, sequence_key=sequence_key)
         else:
-            logging.info(f"Saving results for {sequence_key} in tabular format in: {output_tabular_file}")
+            logging.info(f"Saving results in tabular format in: {output_tabular_file}")
             wrapper.get_all_predictions_tabular(output_tabular_file, sep=sep)
 
     if metadata_file:

{b2bTools-3.0.7b2 → b2bTools-3.0.8b3}/b2bTools/general/Io.py

@@ -1,14 +1,14 @@
-import time
-import os
+import csv
 import json
-import requests
-from urllib.parse import urljoin
-from io import StringIO
+import os
 import time
-import csv
+from io import StringIO
+from urllib.parse import urljoin
 
+import requests
 from b2bTools.singleSeq import constants
 
+
 class B2bIo:
   def __init__(self, gapCode='-'):
       self.gapCode = gapCode
@@ -233,7 +233,7 @@ class B2bIo:
       elif lines[0].startswith("# STOCKHOLM"):
         fileType = 'STOCKHOLM'
       else:
-        fastaCount = balibaseCount = psiCount = blastCount = emptyLine = fastaGaps = 0
+        fastaCount = balibaseCount = psiCount = blastCount = emptyLine = 0
         for line in lines:
           if line.startswith(">"):
             fastaCount += 1
@@ -245,13 +245,13 @@ class B2bIo:
             blastCount += 1
           elif not line.strip():
             emptyLine += 1
-          elif fastaCount and line.count(gapCode):
-            fastaGaps += 1
+          # elif fastaCount and line.count(gapCode):
+          #   fastaGaps += 1
 
         if fastaCount > balibaseCount and fastaCount > blastCount:
           if fileName.endswith('a3m'):
             fileType = 'A3M'
-          elif fastaGaps:
+          else: # <--- There could be alignments without gaps (-)
             fileType = 'FASTA'
         elif blastCount:
           fileType = 'Blast'
@@ -267,7 +267,7 @@ class B2bIo:
 
     assert fileType, "Alignment file not recognised"
 
-    print("Reading {} alignment...".format(fileType))
+    # print("Reading {} alignment...".format(fileType))
 
     self.alignRefSeqID = None
     if fileType == 'CLUSTAL':
@@ -320,23 +320,26 @@ class B2bIo:
 
     return seqAlignments
 
-  def readAlignmentsA3M(self, lines):
+  def readAlignmentsA3M_old(self, lines):
 
     """
     A3M file alignment, need some magic here to align things decently
     """
 
-    startReading = True
+    # startReading = True
     sequences = {}
 
     for line in lines:
+      if line.startswith("#"):
+        continue
 
+      seqId = None
       cols = line.split()
 
       if cols:
-
         if cols[0].startswith('>'):
           seqId = self.getSeqIdKey(cols[0][1:])
+
           if not self.alignRefSeqID:
             self.alignRefSeqID = seqId
         else:
@@ -378,6 +381,103 @@ class B2bIo:
 
     return seqAlignments
 
+  def readAlignmentsA3M(self, lines):
+    """
+    Parse alignments from an A3M formatted file and produce aligned sequences.
+
+    In the A3M format, aligned columns are represented by uppercase letters,
+    whereas insertions relative to the reference are in lowercase. This function
+    collects sequences from the FASTA-like format (handling multi-line sequences)
+    and then constructs the multiple sequence alignment based on the reference sequence.
+    The first encountered sequence header is used as the reference.
+
+    Parameters
+    ----------
+    lines : List[str]
+        List of lines from the A3M file.
+
+    Returns
+    -------
+    Dict[str, str]
+        Dictionary that maps each sequence ID to its aligned sequence.
+    """
+    sequences = {}
+    current_seq_id = ""
+
+    # Process file lines: skip blank lines and comments, and handle headers and sequence lines.
+    for line in lines:
+        line = line.strip()
+        if not line:
+            self.setEmptyLineVars()
+            continue
+        if line.startswith("#"):
+            continue
+        if line.startswith('>'):
+            # Extract header fields split by tab and use only the first token as the sequence id.
+            header_fields = line[1:].strip().split("\t")
+            current_seq_id = self.getSeqIdKey(header_fields[0])
+
+            if current_seq_id not in sequences:
+                sequences[current_seq_id] = ""
+            if not hasattr(self, 'alignRefSeqID') or not self.alignRefSeqID:
+                self.alignRefSeqID = current_seq_id
+        else:
+            # Append the sequence portion to the current sequence.
+            if not current_seq_id:
+                # No valid header was encountered prior to this line; skip it.
+                continue
+            sequences[current_seq_id] += line.strip()
+
+    if not sequences:
+        return {}
+
+    # Initialize pointer indexes and alignment builders for each sequence.
+    seqIndexes = {seqId: 0 for seqId in sequences}
+    seqAlignments = {seqId: "" for seqId in sequences}
+    seqIds = list(sequences.keys())
+
+    # Ensure we have a valid reference sequence.
+    if self.alignRefSeqID not in sequences:
+        self.alignRefSeqID = seqIds[0]
+
+    ref_seq = sequences[self.alignRefSeqID]
+
+    # Walk through the reference sequence positions.
+    while seqIndexes[self.alignRefSeqID] < len(ref_seq):
+        currentColChars = []
+        # Build the current column from each sequence.
+        for seqId in seqIds:
+            # If the current sequence is shorter than expected, use gap.
+            if seqIndexes[seqId] < len(sequences[seqId]):
+                currentColChars.append(sequences[seqId][seqIndexes[seqId]])
+            else:
+                currentColChars.append(self.gapCode)
+        col_str = "".join(currentColChars)
+
+        # If all characters in the column are uppercase, it's an aligned column.
+        if col_str == col_str.upper():
+            for seqId in seqIds:
+                seqAlignments[seqId] += sequences[seqId][seqIndexes[seqId]]
+                seqIndexes[seqId] += 1
+        else:
+            # Otherwise, process insertions:
+            for seqId in seqIds:
+                if seqId == self.alignRefSeqID:
+                    # Always consume a character for the reference.
+                    seqAlignments[seqId] += sequences[seqId][seqIndexes[seqId]]
+                    seqIndexes[seqId] += 1
+                else:
+                    if (seqIndexes[seqId] < len(sequences[seqId])
+                            and sequences[seqId][seqIndexes[seqId]].islower()):
+                        # For an insertion character, add its uppercase version.
+                        seqAlignments[seqId] += sequences[seqId][seqIndexes[seqId]].upper()
+                        seqIndexes[seqId] += 1
+                    else:
+                        # For non-insertion (or missing) character, insert a gap.
+                        seqAlignments[seqId] += self.gapCode
+
+    return seqAlignments
+
   def readAlignmentsBlast(self, lines):
 
     print("Warning: BLAST format, not the full sequences in the alignment!")
@@ -387,7 +487,7 @@ class B2bIo:
 
     refQuerySeqId = ""
 
-    maxQueryLen = 0
+    # maxQueryLen = 0
 
     for line in lines:
 

b2bTools-3.0.8b3/b2bTools/multipleSeq/Predictor.py

@@ -0,0 +1,266 @@
+import numpy as np
+from b2bTools.general.Io import B2bIo
+from b2bTools.singleSeq.constants import DISTRIBUTION_KEYS
+from b2bTools.singleSeq.Predictor import MineSuite
+from sklearn import mixture
+
+
+class MineSuiteMSA(MineSuite):
+
+    scriptName = "b2bTools.msaBased.Predictor"
+
+    def predictSeqsFromMSA(self, msaFile, gapCode='-', predTypes=[]):
+        # This will read in alignment, should automatically detect format. Code is in general/Io.py
+        self.seqAlignments = self.readAlignments(msaFile, resetAlignRefSeqID=True, gapCode=gapCode)
+
+        single_sequences = [(seqId, self.seqAlignments[seqId].replace(gapCode, '')) for seqId in self.seqAlignments.keys()]
+
+        self.predictSeqs(single_sequences, predTypes=predTypes)
+
+        # Now self.allPredictions will give you the predictions for all the individual sequences in the MSA!
+
+    def predictAndMapSeqsFromMSA(self, msaFile, gapCode='-', dataRead=False, predTypes=[]):
+        # Read in data only if not yet present - can re-use this function within instance of class if data already present!
+        if not dataRead:
+            self.predictSeqsFromMSA(msaFile, gapCode=gapCode, predTypes=[*predTypes])
+
+        self.allSeqIds = list(self.seqAlignments.keys())
+        self.allSeqIds.sort()
+
+        # All the current prediction types
+        prediction_keynames = list(self.allPredictions[self.allSeqIds[0]].keys())
+
+        execution_times = []
+        single_values = []
+
+        if 'dynamine_execution_time' in prediction_keynames:
+            prediction_keynames.remove('dynamine_execution_time')
+            execution_times.append('dynamine_execution_time')
+
+        if 'disomine_execution_time' in prediction_keynames:
+            prediction_keynames.remove('disomine_execution_time')
+            execution_times.append('disomine_execution_time')
+
+        if 'efoldmine_execution_time' in prediction_keynames:
+            prediction_keynames.remove('efoldmine_execution_time')
+            execution_times.append('efoldmine_execution_time')
+
+        if 'agmata_execution_time' in prediction_keynames:
+            prediction_keynames.remove('agmata_execution_time')
+            execution_times.append('agmata_execution_time')
+
+        if 'psper_execution_time' in prediction_keynames:
+            prediction_keynames.remove('psper_execution_time')
+            execution_times.append('psper_execution_time')
+
+        if 'protein_score' in prediction_keynames:
+            prediction_keynames.remove('protein_score')
+            single_values.append('protein_score')
+
+        # self.predictionTypes = predictionTypes
+        self.prediction_keynames = prediction_keynames
+        self.allAlignedPredictions = {}
+
+        sequenceInfo = {}
+
+        for seq_id in self.allSeqIds:
+            current_aligned_residues = self.seqAlignments[seq_id]
+            current_prediction_values = self.allPredictions[seq_id]
+
+            sequenceInfo[seq_id] = []
+            self.allAlignedPredictions[seq_id] = {}
+
+            sequence_residue_index = 0
+            for current_aligned_residue in current_aligned_residues:
+                sequenceInfo[seq_id].append(current_aligned_residue)
+                residues_matching = current_aligned_residue != self.gapCode
+
+                for predictionType in prediction_keynames:
+                    if predictionType not in self.allAlignedPredictions[seq_id]:
+                        self.allAlignedPredictions[seq_id][predictionType] = []
+
+                    if not residues_matching:
+                        self.allAlignedPredictions[seq_id][predictionType].append(None)
+                    else:
+                        try:
+                            current_residue, current_prediction_value, *_other_values = current_prediction_values[predictionType][sequence_residue_index]
+
+                            assert current_residue == current_aligned_residue or current_residue == 'X', f"Amino acid code mismatch in aligned position {sequence_residue_index} (SingleSequence:AlignedSequence) {current_residue}:{current_aligned_residue}"
+
+                            self.allAlignedPredictions[seq_id][predictionType].append(current_prediction_value)
+                        except ValueError:
+                            import ipdb; ipdb.set_trace()
+                            from traceback import print_exc
+                            print_exc()
+
+                            raise ValueError(
+                                f"Predicted value of type '{predictionType}' not found for input sequence '{seq_id}'")
+                        except AssertionError as e:
+                            print(self.allAlignedPredictions[seq_id])
+                            raise AssertionError(f"{e} in sequence {seq_id}.\nCurrent aligned residues: {''.join(current_aligned_residues)}\nSingle sequence residues: {''.join([residue for residue, _ in current_prediction_values[predictionType]])}")
+
+                if residues_matching:
+                    sequence_residue_index += 1
+
+            for single_value in [*single_values, *execution_times]:
+                valueFloat = current_prediction_values[single_value]
+                self.allAlignedPredictions[seq_id][single_value] = valueFloat
+
+        # self.allAlignedPredictions['sequence'] = sequenceInfo
+        self.sequenceInfo = sequenceInfo
+
+    def filterByRefSeq(self, refSeqId):
+
+        assert refSeqId in self.allSeqIds,  'Reference sequence ID {} missing in current prediction information!'.format(
+            refSeqId)
+
+        # Here filter so that get back values in reference to the sequence ID that is given.
+
+    def getDistributions(self):
+        # Now generate the info for quartiles, ... based on the alignRefSeqID, first entry in alignment file
+        self.alignedPredictionDistribs = {}
+
+        # Loop over whole alignment
+        alignment_length = len(self.seqAlignments[self.allSeqIds[0]])
+
+        for aligned_residue_index in range(alignment_length):
+            for prediction_name in self.prediction_keynames:
+                if prediction_name == "viterbi":
+                    # Skip viterbi prediction
+                    continue
+
+                if prediction_name not in self.alignedPredictionDistribs:
+                    self.alignedPredictionDistribs[prediction_name] = {}
+
+                all_prediction_values = [aligned_predictions[prediction_name] for aligned_predictions in self.allAlignedPredictions.values()]
+                aligned_column_predicted_values = [prediction_values[aligned_residue_index] for prediction_values in all_prediction_values if prediction_values[aligned_residue_index] is not None]
+
+                # ADRIAN DIAZ: aligned_column_predicted_values can be empty!
+                # So, the distribution_info can be a tuple of None values
+                distribution_info = self.get_distributions_tuple(aligned_column_predicted_values)
+
+                for distribution_index, distribution_key in enumerate(DISTRIBUTION_KEYS):
+                    # import ipdb; ipdb.set_trace()
+                    if distribution_key not in self.alignedPredictionDistribs[prediction_name]:
+                        self.alignedPredictionDistribs[prediction_name][distribution_key] = []
+
+                    current_distribution_info = distribution_info[distribution_index]
+                    self.alignedPredictionDistribs[prediction_name][distribution_key].append(current_distribution_info)
+
+        self.jsonData = B2bIo.getAllPredictionsJson_msa(self, results=self.alignedPredictionDistribs)
+
+        return self.jsonData
+
+    def get_distributions_tuple(self, valueList, outlierConstant=1.5) -> tuple:
+        # JR: I put this try-except cause in some MSA we may have only one sequence
+        # so the distribution values cannot be calculated
+
+        if not valueList:
+            return (None, None, None, None, None)
+
+        try:
+            median = np.median(valueList)
+            upper_quartile = np.percentile(valueList, 75)
+            lower_quartile = np.percentile(valueList, 25)
+
+            IQR = (upper_quartile - lower_quartile) * outlierConstant
+
+            return (median, upper_quartile, lower_quartile, upper_quartile + IQR, lower_quartile - IQR)
+        except (IndexError, ValueError):
+            return (None, None, None, None, None)
+
+    def getGMMScores(self):
+        # predictor_names = [
+        #     *constants.DYNAMINE_PREDICTION_NAMES,
+        #     *constants.DISOMINE_PREDICTION_NAMES,
+        #     *constants.EFOLDMINE_PREDICTION_NAMES,
+        #     *constants.AGMATA_PREDICTION_NAMES,
+        # ]
+
+        # Collect all biophysical predictions for training using median values from distributions
+        training_data = []
+        alignment_length = len(
+            self.alignedPredictionDistribs[self.prediction_keynames[0]]['median']
+        )
+
+        for aln_pos in range(alignment_length):
+            # For each alined position
+            training_data_current_aligned_position = []
+            for pred_type in self.prediction_keynames:
+                # For each prediction value
+                if pred_type in self.prediction_keynames and pred_type in self.alignedPredictionDistribs:
+                    value = self.alignedPredictionDistribs[pred_type]['median'][aln_pos]
+
+                    if value is not None and not np.isnan(value):
+                        training_data_current_aligned_position.append(value)
+
+            if len(training_data_current_aligned_position) == len(self.prediction_keynames):
+                training_data.append(training_data_current_aligned_position)
+
+        # import ipdb; ipdb.set_trace()
+        # Stack the values for training
+        X_train = np.vstack(training_data)
+
+        # Initialize GMM classifier
+        gmm_classifier = mixture.GaussianMixture(n_components=1, covariance_type="full", verbose=3, verbose_interval=1)
+
+        # Fit GMM
+        gmm_classifier.fit(X_train)
+
+        # Calculate scores for each sequence
+        self.GMMScores = {}
+        for seq_id in self.allSeqIds:
+            sequence_gmm_scores = []
+
+            for aln_pos in range(alignment_length):
+                current_position_values = []
+                for pred_type in self.prediction_keynames:
+                    if pred_type in self.allAlignedPredictions[seq_id]:
+                        value = self.allAlignedPredictions[seq_id][pred_type][aln_pos]
+
+                        if value is not None and not np.isnan(value):
+                            current_position_values.append(value)
+
+                if current_position_values:
+                    # Reshape to match training data format (1, n_features)
+                    X = np.array(current_position_values).reshape(1, -1)
+                    scores = gmm_classifier.score_samples(X)
+                    sequence_gmm_scores.extend(scores.tolist())
+
+            self.GMMScores[seq_id] = sequence_gmm_scores
+
+        return self.GMMScores
+
+    def getCutoffResidues(self):
+        """
+        Identifies residues that are over the 95, 99 and 99.9 percentiles as estimated by the GMM using the median of the predictions.
+        Stores results in self.cutoffResidues dictionary.
+        """
+        if not hasattr(self, 'GMMScores'):
+            self.getGMMScores()
+
+        # Collect all scores to calculate percentiles
+        all_scores = []
+        for seq_id in self.GMMScores:
+            all_scores.extend(self.GMMScores[seq_id])
+
+        # Calculate percentile cutoffs
+        cutoff_95 = np.percentile(all_scores, 95)
+        cutoff_99 = np.percentile(all_scores, 99)
+        cutoff_99_9 = np.percentile(all_scores, 99.9)
+
+        # Store cutoff residues for each sequence
+        self.cutoffResidues = {}
+        for seq_id in self.GMMScores:
+            scores = self.GMMScores[seq_id]
+            residue_indexes_99_9 = [i for i, score in enumerate(scores) if score > cutoff_99_9]
+            residue_indexes_99 = [i for i, score in enumerate(scores) if score > cutoff_99 and i not in residue_indexes_99_9]
+            residue_indexes_95 = [i for i, score in enumerate(scores) if score > cutoff_95 and i not in residue_indexes_99 and i not in residue_indexes_99_9]
+
+            self.cutoffResidues[seq_id] = {
+                'res99_9': residue_indexes_99_9,
+                'res99': residue_indexes_99,
+                'res95': residue_indexes_95,
+            }
+
+        return self.cutoffResidues

{b2bTools-3.0.7b2 → b2bTools-3.0.8b3}/b2bTools/multipleSeq/msa_core.py

@@ -1,13 +1,15 @@
-import os, os.path
+import argparse
+import os
+import os.path
 import time
 import urllib.parse
 import urllib.request
-import argparse
+
 import pandas as pd
-from Bio import SeqIO
-from Bio.Blast import NCBIWWW, NCBIXML
 from b2bTools.general.Io import B2bIo
 from b2bTools.multipleSeq.Predictor import MineSuiteMSA
+from Bio import SeqIO
+from Bio.Blast import NCBIWWW, NCBIXML
 
 ###############################################################################
 ###############################################################################
@@ -413,15 +415,16 @@ class predManager:
         # Same but now mapped to reference sequence ID in MSA, gaps are None
         self.ms.predictAndMapSeqsFromMSA(msa_file, dataRead=True)
         self.allAlignedPredictions = self.ms.allAlignedPredictions
+        self.sequenceInfo = self.ms.sequenceInfo
 
         self.jsondata_list = []
 
-        try:
-            # Create the results folder if it's not there yet
-            if not os.path.exists("/results"):
-                os.mkdir("/results")
-        except BaseException:
-            pass
+        # try:
+        #     # Create the results folder if it's not there yet
+        #     if not os.path.exists("/results"):
+        #         os.mkdir("/results")
+        # except BaseException:
+        #     pass
 
         # When we work with an alignment of MSAs
         if msa_map != None:
@@ -449,6 +452,7 @@ class predManager:
         # Same but now mapped to full MSA, gaps are None
         self.ms.predictAndMapSeqsFromMSA(msa_file, dataRead=True)
         self.allAlignedPredictions = self.ms.allAlignedPredictions
+        self.sequenceInfo = self.ms.sequenceInfo
 
 ###############################################################################
 ###############################################################################