biotite 0.41.2__cp311-cp311-win_amd64.whl → 1.0.0__cp311-cp311-win_amd64.whl

biotite/application/blast/webapp.py

@@ -6,26 +6,26 @@ __name__ = "biotite.application.blast"
 __author__ = "Patrick Kunzmann"
 __all__ = ["BlastWebApp"]
 
-from .alignment import BlastAlignment
-from ..application import Application, requires_state, AppState
-from ..webapp import WebApp, RuleViolationError
-from ...sequence.sequence import Sequence
-from ...sequence.seqtypes import NucleotideSequence, ProteinSequence
-from ...sequence.io.fasta.file import FastaFile
-from ...sequence.io.fasta.convert import get_sequence
-from ...sequence.align.alignment import Alignment
 import time
-import requests
 from xml.etree import ElementTree
-
+import requests
+from biotite.application.application import AppState, requires_state
+from biotite.application.blast.alignment import BlastAlignment
+from biotite.application.webapp import WebApp
+from biotite.sequence.align.alignment import Alignment
+from biotite.sequence.io.fasta.convert import get_sequence
+from biotite.sequence.io.fasta.file import FastaFile
+from biotite.sequence.seqtypes import NucleotideSequence, ProteinSequence
+from biotite.sequence.sequence import Sequence
 
 _ncbi_url = "https://blast.ncbi.nlm.nih.gov/Blast.cgi"
 
+
 class BlastWebApp(WebApp):
     """
     Perform a local alignment against a large sequence database using
     using the web-based BLAST application (by default NCBI BLAST).
-    
+
     Parameters
     ----------
     program : str
@@ -35,7 +35,7 @@ class BlastWebApp(WebApp):
         The query sequence. If a string is provided, it is interpreted
         as path to a FASTA file, if the string contains a valid FASTA
         file extension, otherwise it is interpreted as a single letter
-        string representation of a sequence. 
+        string representation of a sequence.
     database : str, optional
         The NCBI sequence database to blast against. By default it
         contains all sequences (`database`='nr'`).
@@ -52,68 +52,71 @@ class BlastWebApp(WebApp):
         HTTP request. This allows the NCBI to contact you in case
         your application sends too many requests.
     """
-    
+
     _last_contact = 0
     _last_request = 0
     _contact_delay = 3
     _request_delay = 60
-    
-    def __init__(self, program, query, database="nr",
-                 app_url=_ncbi_url, obey_rules=True,
-                 mail="padix.key@gmail.com"):
+
+    def __init__(
+        self,
+        program,
+        query,
+        database="nr",
+        app_url=_ncbi_url,
+        obey_rules=True,
+        mail="padix.key@gmail.com",
+    ):
         super().__init__(app_url, obey_rules)
-        
+
         # 'megablast' is somehow not working
         # When entering the corresponding HTTPS request into a browser
         # you are redirected onto the blast mainpage
-        if program not in ["blastn", "blastp",
-                           "blastx", "tblastn", "tblastx"]:
+        if program not in ["blastn", "blastp", "blastx", "tblastn", "tblastx"]:
             raise ValueError(f"'{program}' is not a valid BLAST program")
         self._program = program
-        
-        requires_protein = (program in ["blastp", "tblastn"])
-        if isinstance(query, str) and query.endswith((".fa",".fst",".fasta")):
+
+        requires_protein = program in ["blastp", "tblastn"]
+        if isinstance(query, str) and query.endswith((".fa", ".fst", ".fasta")):
             # If string has a file extension, it is interpreted as
             # FASTA file from which the sequence is taken
             file = FastaFile.read(query)
             # Get first entry in file and take the sequence
-            # (rather than header) 
+            # (rather than header)
             self._query = str(get_sequence(file))
         elif isinstance(query, Sequence):
             self._query = str(query)
         else:
             self._query = query
-        
+
         # Check for unsuitable symbols in query string
         if requires_protein:
             ref_alphabet = ProteinSequence.alphabet
         else:
             ref_alphabet = NucleotideSequence.alphabet_amb
         for symbol in self._query:
-            if not symbol.upper() in ref_alphabet:
-                raise ValueError(
-                    f"Query sequence contains unsuitable symbol {symbol}"
-                )
-        
+            if symbol.upper() not in ref_alphabet:
+                raise ValueError(f"Query sequence contains unsuitable symbol {symbol}")
+
         self._database = database
-        
+
         self._gap_openining = None
         self._gap_extension = None
         self._word_size = None
-        
+
         self._expect_value = None
         self._max_results = None
         self._entrez_query = None
-        
+
         self._reward = None
         self._penalty = None
-        
+
         self._matrix = None
         self._threshold = None
-        
-        self._mail=mail
+
+        self._mail = mail
         self._rid = None
-    
+
     @requires_state(AppState.CREATED)
     def set_entrez_query(self, query):
         """
@@ -126,7 +129,7 @@ class BlastWebApp(WebApp):
             An NCBI Entrez query.
         """
         self._entrez_query = str(query)
-    
+
     @requires_state(AppState.CREATED)
     def set_max_results(self, number):
         """
@@ -138,30 +141,30 @@ class BlastWebApp(WebApp):
             The maximum number of results.
         """
         self._max_results = number
-    
+
     @requires_state(AppState.CREATED)
     def set_max_expect_value(self, value):
         """
         Set the threshold expectation value (E-value).
         No alignments with an E-value above this threshold will be
         considered.
-        
+
         The E-Value is the expectation value for the number of random
         sequences of a similar sized database getting an equal or higher
         score by change when aligned with the query sequence.
-        
+
         Parameters
         ----------
         value : float
             The threshold E-value.
         """
         self._expect_value = value
-    
+
     @requires_state(AppState.CREATED)
     def set_gap_penalty(self, opening, extension):
         """
         Set the affine gap penalty for the alignment.
-        
+
         Parameters
         ----------
         opening : float
@@ -171,75 +174,75 @@ class BlastWebApp(WebApp):
         """
         self._gap_openining = opening
         self._gap_extension = extension
-    
+
     @requires_state(AppState.CREATED)
     def set_word_size(self, size):
         """
         Set the word size for alignment seeds.
-        
+
         Parameters
         ----------
         size : int
             Word size.
         """
         self._word_size = size
-    
+
     @requires_state(AppState.CREATED)
     def set_match_reward(self, reward):
         """
         Set the score of a symbol match in the alignment.
-        
+
         Used only in 'blastn' and 'megablast'.
-        
+
         Parameters
         ----------
         reward : int
             Match reward. Must be positive.
         """
         self._reward = reward
-    
+
     @requires_state(AppState.CREATED)
     def set_mismatch_penalty(self, penalty):
         """
         Set the penalty of a symbol mismatch in the alignment.
-        
+
         Used only in 'blastn' and 'megablast'.
-        
+
         Parameters
         ----------
         penalty : int
             Mismatch penalty. Must be negative.
         """
         self._penalty = penalty
-    
+
     @requires_state(AppState.CREATED)
     def set_substitution_matrix(self, matrix_name):
         """
         Set the penalty of a symbol mismatch in the alignment.
-        
+
         Used only in 'blastp', "blastx', 'tblastn' and 'tblastx'.
-        
+
         Parameters
         ----------
         matrix_name : str
             Name of the substitution matrix. Default is 'BLOSUM62'.
         """
         self._matrix = matrix_name.upper()
-    
+
     @requires_state(AppState.CREATED)
     def set_threshold(self, threshold):
         """
         Set the threshold neighboring score for initial words.
-        
+
         Used only in 'blastp', "blastx', 'tblastn' and 'tblastx'.
-        
+
         Parameters
         ----------
         threshold : int
             Threshold value. Must be positve.
         """
         self._threshold = threshold
-    
+
     def run(self):
         param_dict = {}
         param_dict["tool"] = "Biotite"
@@ -255,23 +258,24 @@ class BlastWebApp(WebApp):
         if self._expect_value is not None:
             param_dict["EXPECT"] = self._expect_value
         if self._gap_openining is not None and self._gap_extension is not None:
-            param_dict["GAPCOSTS"] = "{:d} {:d}".format(self._gap_openining,
-                                                      self._gap_extension)
+            param_dict["GAPCOSTS"] = "{:d} {:d}".format(
+                self._gap_openining, self._gap_extension
+            )
         if self._word_size is not None:
             param_dict["WORD_SIZE"] = self._word_size
-        
+
         if self._program in ["blastn", "megablast"]:
             if self._reward is not None:
                 param_dict["NUCL_REWARD"] = self._reward
             if self._penalty is not None:
                 param_dict["NUCL_PENALTY"] = self._penalty
-        
+
         if self._program in ["blastp", "blastx", "tblastn", "tblastx"]:
             if self._matrix is not None:
                 param_dict["MATRIX"] = self._matrix
             if self._threshold is not None:
                 param_dict["THRESHOLD"] = self._threshold
-        
+
         request = requests.get(self.app_url(), params=param_dict)
         if "Submitted URI too large" in request.text:
             raise ValueError("The URI is too large, try a shorter sequence")
@@ -279,11 +283,9 @@ class BlastWebApp(WebApp):
         self._request()
         info_dict = BlastWebApp._get_info(request.text)
         self._rid = info_dict["RID"]
-    
+
     def is_finished(self):
-        data_dict = {"FORMAT_OBJECT" : "SearchInfo",
-                     "RID"           : self._rid,
-                     "CMD"           : "Get"}
+        data_dict = {"FORMAT_OBJECT": "SearchInfo", "RID": self._rid, "CMD": "Get"}
         request = requests.get(self.app_url(), params=data_dict)
         self._contact()
         info_dict = BlastWebApp._get_info(request.text)
@@ -294,17 +296,17 @@ class BlastWebApp(WebApp):
                 "(Server responsed status 'UNKNOWN')"
             )
         return info_dict["Status"] == "READY"
-        
+
     def wait_interval(self):
         # NCBI requires a 3 second delay between server contacts
         return BlastWebApp._contact_delay
-    
+
     def clean_up(self):
         param_dict = {}
         param_dict["CMD"] = "Delete"
         param_dict["RID"] = self._rid
-        request = requests.get(self.app_url(), params=param_dict)
-    
+        requests.get(self.app_url(), params=param_dict)
+
     def evaluate(self):
         param_dict = {}
         param_dict["tool"] = "BiotiteClient"
@@ -316,7 +318,7 @@ class BlastWebApp(WebApp):
         param_dict["NCBI_GI"] = "T"
         request = requests.get(self.app_url(), params=param_dict)
         self._contact()
-        
+
         self._alignments = []
         self._xml_response = request.text
         root = ElementTree.fromstring(self._xml_response)
@@ -333,15 +335,14 @@ class BlastWebApp(WebApp):
             query_end = int(hsp.find("Hsp_query-to").text)
             hit_begin = int(hsp.find("Hsp_hit-from").text)
             hit_end = int(hsp.find("Hsp_hit-to").text)
-            
+
             seq1_str = hsp.find("Hsp_qseq").text
             seq2_str = hsp.find("Hsp_hseq").text
             if self._program in ["blastn", "megablast"]:
                 # NucleotideSequence/ProteinSequence do ignore gaps
                 # Gaps are represented by the trace
                 seq1, seq2 = [
-                    NucleotideSequence(s.replace("-", ""))
-                    for s in (seq1_str, seq2_str)
+                    NucleotideSequence(s.replace("-", "")) for s in (seq1_str, seq2_str)
                 ]
             else:
                 seq1, seq2 = [
@@ -349,18 +350,24 @@ class BlastWebApp(WebApp):
                     for s in (seq1_str, seq2_str)
                 ]
             trace = Alignment.trace_from_strings([seq1_str, seq2_str])
-            
-            alignment = BlastAlignment( [seq1 ,seq2], trace, score, e_value,
-                                        (query_begin, query_end),
-                                        (hit_begin, hit_end),
-                                        hit_id, hit_definition )
+
+            alignment = BlastAlignment(
+                [seq1, seq2],
+                trace,
+                score,
+                e_value,
+                (query_begin, query_end),
+                (hit_begin, hit_end),
+                hit_id,
+                hit_definition,
+            )
             self._alignments.append(alignment)
 
     @requires_state(AppState.JOINED)
     def get_xml_response(self):
         """
         Get the raw XML response.
-        
+
         Returns
         -------
         response : str
@@ -372,14 +379,14 @@ class BlastWebApp(WebApp):
     def get_alignments(self):
         """
         Get the resulting local sequence alignments.
-        
+
         Returns
         -------
         alignment : list of BlastAlignment
             The local sequence alignments.
         """
         return self._alignments
-    
+
     @staticmethod
     def _get_info(text):
         """
@@ -399,7 +406,7 @@ class BlastWebApp(WebApp):
                 pair = line.split("=")
                 info_dict[pair[0].strip()] = pair[1].strip()
         return info_dict
-    
+
     def _contact(self):
         """
         Resets the time since the last server contact. Used for
@@ -409,7 +416,7 @@ class BlastWebApp(WebApp):
         if (contact - BlastWebApp._last_contact) < BlastWebApp._contact_delay:
             self.violate_rule("The server was contacted too often")
         BlastWebApp._last_contact = contact
-    
+
     def _request(self):
         """
         Resets the time since the last new alignment request. Used for

biotite/application/clustalo/__init__.py

@@ -9,4 +9,4 @@ A subpackage for multiple sequence alignments using Clustal-Omega.
 __name__ = "biotite.application.clustalo"
 __author__ = "Patrick Kunzmann"
 
-from .app import *
+from .app import *

biotite/application/clustalo/app.py

@@ -8,20 +8,16 @@ __all__ = ["ClustalOmegaApp"]
 
 from tempfile import NamedTemporaryFile
 import numpy as np
-from ...sequence.sequence import Sequence
-from ...sequence.seqtypes import NucleotideSequence, ProteinSequence
-from ...sequence.io.fasta.file import FastaFile
-from ...sequence.align.alignment import Alignment
-from ...sequence.phylo.tree import Tree
-from ..localapp import cleanup_tempfile
-from ..msaapp import MSAApp
-from ..application import AppState, requires_state
+from biotite.application.application import AppState, requires_state
+from biotite.application.localapp import cleanup_tempfile
+from biotite.application.msaapp import MSAApp
+from biotite.sequence.phylo.tree import Tree
 
 
 class ClustalOmegaApp(MSAApp):
     """
     Perform a multiple sequence alignment using Clustal-Omega.
-    
+
     Parameters
     ----------
     sequences : list of ProteinSequence or NucleotideSequence
@@ -30,7 +26,7 @@ class ClustalOmegaApp(MSAApp):
         Path of the Custal-Omega binary.
     matrix : None
         This parameter is used for compatibility reasons and is ignored.
-    
+
     Examples
     --------
 
@@ -48,34 +44,30 @@ class ClustalOmegaApp(MSAApp):
     -BISMITE
     --IQLITE
     """
-    
+
     def __init__(self, sequences, bin_path="clustalo", matrix=None):
         super().__init__(sequences, bin_path, None)
         self._seq_count = len(sequences)
         self._mbed = True
         self._dist_matrix = None
         self._tree = None
-        self._in_dist_matrix_file = NamedTemporaryFile(
-            "w", suffix=".mat", delete=False
-        )
+        self._in_dist_matrix_file = NamedTemporaryFile("w", suffix=".mat", delete=False)
         self._out_dist_matrix_file = NamedTemporaryFile(
             "r", suffix=".mat", delete=False
         )
-        self._in_tree_file = NamedTemporaryFile(
-            "w", suffix=".tree", delete=False
-        )
-        self._out_tree_file = NamedTemporaryFile(
-            "r", suffix=".tree", delete=False
-        )
-    
+        self._in_tree_file = NamedTemporaryFile("w", suffix=".tree", delete=False)
+        self._out_tree_file = NamedTemporaryFile("r", suffix=".tree", delete=False)
+
     def run(self):
         args = [
-            "--in", self.get_input_file_path(),
-            "--out", self.get_output_file_path(),
+            "--in",
+            self.get_input_file_path(),
+            "--out",
+            self.get_output_file_path(),
             # The temporary files are already created
             # -> tell Clustal to overwrite these empty files
             "--force",
-            # Tree order for get_alignment_order() to work properly 
+            # Tree order for get_alignment_order() to work properly
             "--output-order=tree-order",
         ]
         if self.get_seqtype() == "protein":
@@ -87,28 +79,24 @@ class ClustalOmegaApp(MSAApp):
             # as input and output#
             # -> Only request tree output when not tree is input
             args += [
-                "--guidetree-out", self._out_tree_file.name,
+                "--guidetree-out",
+                self._out_tree_file.name,
             ]
         if not self._mbed:
-            args += [
-                "--full",
-                "--distmat-out", self._out_dist_matrix_file.name
-            ]
+            args += ["--full", "--distmat-out", self._out_dist_matrix_file.name]
         if self._dist_matrix is not None:
             # Add the sequence names (0, 1, 2, 3 ...) as first column
             dist_matrix_with_index = np.concatenate(
-                (
-                    np.arange(self._seq_count)[:, np.newaxis],
-                    self._dist_matrix
-                ), axis=1
+                (np.arange(self._seq_count)[:, np.newaxis], self._dist_matrix), axis=1
             )
             np.savetxt(
-                self._in_dist_matrix_file.name, dist_matrix_with_index,
+                self._in_dist_matrix_file.name,
+                dist_matrix_with_index,
                 # The first line contains the amount of sequences
-                comments = "",
-                header = str(self._seq_count),
+                comments="",
+                header=str(self._seq_count),
                 # The sequence indices are integers, the rest are floats
-                fmt = ["%d"] + ["%.5f"] * self._seq_count
+                fmt=["%d"] + ["%.5f"] * self._seq_count,
             )
             args += ["--distmat-in", self._in_dist_matrix_file.name]
         if self._tree is not None:
@@ -117,15 +105,15 @@ class ClustalOmegaApp(MSAApp):
             args += ["--guidetree-in", self._in_tree_file.name]
         self.set_arguments(args)
         super().run()
-    
+
     def evaluate(self):
         super().evaluate()
         if not self._mbed:
             self._dist_matrix = np.loadtxt(
                 self._out_dist_matrix_file.name,
                 # The first row only contains the number of sequences
-                skiprows = 1,
-                dtype = float
+                skiprows=1,
+                dtype=float,
             )
             # The first column contains only the name of the
             # sequences, in this case 0, 1, 2, 3 ...
@@ -133,17 +121,15 @@ class ClustalOmegaApp(MSAApp):
             self._dist_matrix = self._dist_matrix[:, 1:]
         # Only read output tree if no tree was input
         if self._tree is None:
-            self._tree = Tree.from_newick(
-                self._out_tree_file.read().replace("\n", "")
-            )
-    
+            self._tree = Tree.from_newick(self._out_tree_file.read().replace("\n", ""))
+
     def clean_up(self):
         super().clean_up()
         cleanup_tempfile(self._in_dist_matrix_file)
         cleanup_tempfile(self._out_dist_matrix_file)
         cleanup_tempfile(self._in_tree_file)
         cleanup_tempfile(self._out_tree_file)
-    
+
     @requires_state(AppState.CREATED)
     def full_matrix_calculation(self):
         """
@@ -154,13 +140,13 @@ class ClustalOmegaApp(MSAApp):
         default *mBed* heuristic.
         """
         self._mbed = False
-    
+
     @requires_state(AppState.CREATED)
     def set_distance_matrix(self, matrix):
         """
         Set the pairwise sequence distances, the program should use to
-        calculate the guide tree. 
-        
+        calculate the guide tree.
+
         Parameters
         ----------
         matrix : ndarray, shape=(n,n), dtype=float
@@ -172,13 +158,13 @@ class ClustalOmegaApp(MSAApp):
                 f"{self._seq_count} sequences"
             )
         self._dist_matrix = matrix.astype(float, copy=False)
-    
+
     @requires_state(AppState.JOINED)
     def get_distance_matrix(self):
         """
         Get the pairwise sequence distances the program used to
-        calculate the guide tree. 
-        
+        calculate the guide tree.
+
         Returns
         -------
         matrix : ndarray, shape=(n,n), dtype=float
@@ -186,17 +172,16 @@ class ClustalOmegaApp(MSAApp):
         """
         if self._mbed:
             raise ValueError(
-                "Getting the distance matrix requires "
-                "'full_matrix_calculation()'"
+                "Getting the distance matrix requires " "'full_matrix_calculation()'"
             )
         return self._dist_matrix
-    
+
     @requires_state(AppState.CREATED)
     def set_guide_tree(self, tree):
         """
         Set the guide tree, the program should use for the
         progressive alignment.
-        
+
         Parameters
         ----------
         tree : Tree
@@ -208,31 +193,31 @@ class ClustalOmegaApp(MSAApp):
                 "{self._seq_count} sequences, must be equal"
             )
         self._tree = tree
-    
+
     @requires_state(AppState.JOINED)
     def get_guide_tree(self):
         """
         Get the guide tree created for the progressive alignment.
-        
+
         Returns
         -------
         tree : Tree
             The guide tree.
         """
         return self._tree
-    
+
     @staticmethod
     def supports_nucleotide():
         return True
-    
+
     @staticmethod
     def supports_protein():
         return True
-    
+
     @staticmethod
     def supports_custom_nucleotide_matrix():
         return False
-    
+
     @staticmethod
     def supports_custom_protein_matrix():
         return False