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

biotite/application/msaapp.py

@@ -7,22 +7,22 @@ __author__ = "Patrick Kunzmann"
 __all__ = ["MSAApp"]
 
 import abc
-from tempfile import NamedTemporaryFile
 from collections import OrderedDict
+from tempfile import NamedTemporaryFile
 import numpy as np
-from .localapp import LocalApp, cleanup_tempfile
-from .application import AppState, requires_state
-from ..sequence.seqtypes import NucleotideSequence, ProteinSequence
-from ..sequence.io.fasta.file import FastaFile
-from ..sequence.align.alignment import Alignment
-from .util import map_sequence, map_matrix
+from biotite.application.application import AppState, requires_state
+from biotite.application.localapp import LocalApp, cleanup_tempfile
+from biotite.application.util import map_matrix, map_sequence
+from biotite.sequence.align.alignment import Alignment
+from biotite.sequence.io.fasta.file import FastaFile
+from biotite.sequence.seqtypes import NucleotideSequence, ProteinSequence
 
 
 class MSAApp(LocalApp, metaclass=abc.ABCMeta):
     """
     This is an abstract base class for multiple sequence alignment
     software.
-    
+
     It handles conversion of :class:`Sequence` objects to FASTA input
     and FASTA output to an :class:`Alignment` object.
     Inheriting subclasses only need to incorporate the file path
@@ -41,10 +41,10 @@ class MSAApp(LocalApp, metaclass=abc.ABCMeta):
     sequences are mapped back into the original sequence types.
     The mapping does not work, when the alphabet of the exotic
     sequences is larger than the amino acid alphabet.
-    
+
     Internally this creates a :class:`Popen` instance, which handles
     the execution.
-    
+
     Parameters
     ----------
     sequences : iterable object of Sequence
@@ -54,10 +54,10 @@ class MSAApp(LocalApp, metaclass=abc.ABCMeta):
     matrix : SubstitutionMatrix, optional
         A custom substitution matrix.
     """
-    
+
     def __init__(self, sequences, bin_path, matrix=None):
         super().__init__(bin_path)
-        
+
         if len(sequences) < 2:
             raise ValueError("At least two sequences are required")
         # Check if all sequences share the same alphabet
@@ -68,40 +68,39 @@ class MSAApp(LocalApp, metaclass=abc.ABCMeta):
         # Check matrix symmetry
         if matrix is not None and not matrix.is_symmetric():
             raise ValueError(
-                "A symmetric matrix is required for "
-                "multiple sequence alignments"
+                "A symmetric matrix is required for " "multiple sequence alignments"
             )
 
-        
         # Check whether the program supports the alignment for the given
         # sequence type
-        if ProteinSequence.alphabet.extends(alphabet) \
-            and self.supports_protein():
-                self._is_mapped = False
-                self._seqtype = "protein"
-                if matrix is not None:
-                    if not self.supports_custom_protein_matrix():
-                        raise TypeError(
-                            "The software does not support custom "
-                            "substitution matrices for protein sequences"
-                        )
-                    self._matrix = matrix
-                else:
-                    self._matrix = None
-
-        elif NucleotideSequence.alphabet_amb.extends(alphabet) \
-            and self.supports_nucleotide():
-                self._is_mapped = False
-                self._seqtype = "nucleotide"
-                if matrix is not None:
-                    if not self.supports_custom_nucleotide_matrix():
-                        raise TypeError(
-                            "The software does not support custom "
-                            "substitution matrices for nucleotide sequences"
-                        )
-                    self._matrix = matrix
-                else:
-                    self._matrix = None
+        if ProteinSequence.alphabet.extends(alphabet) and self.supports_protein():
+            self._is_mapped = False
+            self._seqtype = "protein"
+            if matrix is not None:
+                if not self.supports_custom_protein_matrix():
+                    raise TypeError(
+                        "The software does not support custom "
+                        "substitution matrices for protein sequences"
+                    )
+                self._matrix = matrix
+            else:
+                self._matrix = None
+
+        elif (
+            NucleotideSequence.alphabet_amb.extends(alphabet)
+            and self.supports_nucleotide()
+        ):
+            self._is_mapped = False
+            self._seqtype = "nucleotide"
+            if matrix is not None:
+                if not self.supports_custom_nucleotide_matrix():
+                    raise TypeError(
+                        "The software does not support custom "
+                        "substitution matrices for nucleotide sequences"
+                    )
+                self._matrix = matrix
+            else:
+                self._matrix = None
 
         else:
             # For all other sequence types, try to map the sequence into
@@ -126,26 +125,16 @@ class MSAApp(LocalApp, metaclass=abc.ABCMeta):
             self._sequences = sequences
             # Sequence masquerades as protein
             self._seqtype = "protein"
-            self._mapped_sequences = [
-                map_sequence(sequence) for sequence in sequences
-            ]
+            self._mapped_sequences = [map_sequence(sequence) for sequence in sequences]
             self._matrix = map_matrix(matrix)
 
-
         self._sequences = sequences
-        self._in_file = NamedTemporaryFile(
-            "w", suffix=".fa", delete=False
-        )
-        self._out_file = NamedTemporaryFile(
-            "r", suffix=".fa", delete=False
-        )
-        self._matrix_file = NamedTemporaryFile(
-            "w", suffix=".mat", delete=False
-        )
+        self._in_file = NamedTemporaryFile("w", suffix=".fa", delete=False)
+        self._out_file = NamedTemporaryFile("r", suffix=".fa", delete=False)
+        self._matrix_file = NamedTemporaryFile("w", suffix=".mat", delete=False)
 
     def run(self):
-        sequences = self._sequences if not self._is_mapped \
-                    else self._mapped_sequences
+        sequences = self._sequences if not self._is_mapped else self._mapped_sequences
         sequences_file = FastaFile()
         for i, seq in enumerate(sequences):
             sequences_file[str(i)] = str(seq)
@@ -155,7 +144,7 @@ class MSAApp(LocalApp, metaclass=abc.ABCMeta):
             self._matrix_file.write(str(self._matrix))
             self._matrix_file.flush()
         super().run()
-    
+
     def evaluate(self):
         super().evaluate()
         alignment_file = FastaFile.read(self._out_file)
@@ -169,26 +158,26 @@ class MSAApp(LocalApp, metaclass=abc.ABCMeta):
         # Also obtain original order
         self._order = np.zeros(len(seq_dict), dtype=int)
         for i, seq_index in enumerate(seq_dict):
-             self._order[i] = int(seq_index)
-    
+            self._order[i] = int(seq_index)
+
     def clean_up(self):
         super().clean_up()
         cleanup_tempfile(self._in_file)
         cleanup_tempfile(self._out_file)
         cleanup_tempfile(self._matrix_file)
-    
+
     @requires_state(AppState.JOINED)
     def get_alignment(self):
         """
         Get the resulting multiple sequence alignment.
-        
+
         Returns
         -------
         alignment : Alignment
             The global multiple sequence alignment.
         """
         return self._alignment
-    
+
     @requires_state(AppState.JOINED)
     def get_alignment_order(self):
         """
@@ -202,12 +191,12 @@ class MSAApp(LocalApp, metaclass=abc.ABCMeta):
         order.
         This method returns the order of the sequences intended by the
         MSA software.
-        
+
         Returns
         -------
         order : ndarray, dtype=int
             The sequence order intended by the MSA software.
-        
+
         Examples
         --------
         Align sequences and restore the original order:
@@ -220,39 +209,39 @@ class MSAApp(LocalApp, metaclass=abc.ABCMeta):
         alignment = alignment[:, order]
         """
         return self._order
-    
+
     def get_input_file_path(self):
         """
         Get input file path (FASTA format).
-        
+
         PROTECTED: Do not call from outside.
-        
+
         Returns
         -------
         path : str
             Path of input file.
         """
         return self._in_file.name
-    
+
     def get_output_file_path(self):
         """
         Get output file path (FASTA format).
-        
+
         PROTECTED: Do not call from outside.
-        
+
         Returns
         -------
         path : str
             Path of output file.
         """
         return self._out_file.name
-    
+
     def get_matrix_file_path(self):
         """
         Get file path for custom substitution matrix.
-        
+
         PROTECTED: Do not call from outside.
-        
+
         Returns
         -------
         path : str or None
@@ -260,7 +249,7 @@ class MSAApp(LocalApp, metaclass=abc.ABCMeta):
             None if no matrix was given.
         """
         return self._matrix_file.name if self._matrix is not None else None
-    
+
     def get_seqtype(self):
         """
         Get the type of aligned sequences.
@@ -268,16 +257,16 @@ class MSAApp(LocalApp, metaclass=abc.ABCMeta):
         When a custom sequence type (neither nucleotide nor protein)
         is mapped onto a protein sequence, the return value is also
         ``'protein'``.
-        
+
         PROTECTED: Do not call from outside.
-        
+
         Returns
         -------
         seqtype : {'nucleotide', 'protein'}
             Type of sequences to be aligned.
         """
         return self._seqtype
-    
+
     @staticmethod
     @abc.abstractmethod
     def supports_nucleotide():
@@ -289,11 +278,11 @@ class MSAApp(LocalApp, metaclass=abc.ABCMeta):
         -------
         support : bool
             True, if the class has support, false otherwise.
-        
+
         PROTECTED: Override when inheriting.
         """
         pass
-    
+
     @staticmethod
     @abc.abstractmethod
     def supports_protein():
@@ -305,11 +294,11 @@ class MSAApp(LocalApp, metaclass=abc.ABCMeta):
         -------
         support : bool
             True, if the class has support, false otherwise.
-        
+
         PROTECTED: Override when inheriting.
         """
         pass
-    
+
     @staticmethod
     @abc.abstractmethod
     def supports_custom_nucleotide_matrix():
@@ -321,11 +310,11 @@ class MSAApp(LocalApp, metaclass=abc.ABCMeta):
         -------
         support : bool
             True, if the class has support, false otherwise.
-        
+
         PROTECTED: Override when inheriting.
         """
         pass
-    
+
     @staticmethod
     @abc.abstractmethod
     def supports_custom_protein_matrix():
@@ -337,19 +326,19 @@ class MSAApp(LocalApp, metaclass=abc.ABCMeta):
         -------
         support : bool
             True, if the class has support, false otherwise.
-        
+
         PROTECTED: Override when inheriting.
         """
         pass
-    
+
     @classmethod
     def align(cls, sequences, bin_path=None, matrix=None):
         """
         Perform a multiple sequence alignment.
-        
+
         This is a convenience function, that wraps the :class:`MSAApp`
         execution.
-        
+
         Parameters
         ----------
         sequences : iterable object of Sequence
@@ -359,7 +348,7 @@ class MSAApp(LocalApp, metaclass=abc.ABCMeta):
             path will be used.
         matrix : SubstitutionMatrix, optional
             A custom substitution matrix.
-        
+
         Returns
         -------
         alignment : Alignment

biotite/application/muscle/__init__.py

@@ -10,4 +10,4 @@ __name__ = "biotite.application.muscle"
 __author__ = "Patrick Kunzmann"
 
 from .app3 import *
-from .app5 import *
+from .app5 import *

biotite/application/muscle/app3.py

@@ -6,25 +6,22 @@ __name__ = "biotite.application.muscle"
 __author__ = "Patrick Kunzmann"
 __all__ = ["MuscleApp"]
 
-import re
 import numbers
-import warnings
+import re
 import subprocess
+import warnings
+from collections.abc import Sequence
 from tempfile import NamedTemporaryFile
-from ..localapp import cleanup_tempfile
-from ..msaapp import MSAApp
-from ..application import AppState, VersionError, requires_state
-from ...sequence.sequence import Sequence
-from ...sequence.seqtypes import NucleotideSequence, ProteinSequence
-from ...sequence.align.matrix import SubstitutionMatrix
-from ...sequence.align.alignment import Alignment
-from ...sequence.phylo.tree import Tree
+from biotite.application.application import AppState, VersionError, requires_state
+from biotite.application.localapp import cleanup_tempfile
+from biotite.application.msaapp import MSAApp
+from biotite.sequence.phylo.tree import Tree
 
 
 class MuscleApp(MSAApp):
     """
     Perform a multiple sequence alignment using MUSCLE version 3.
-    
+
     Parameters
     ----------
     sequences : list of Sequence
@@ -33,11 +30,11 @@ class MuscleApp(MSAApp):
         Path of the MUSCLE binary.
     matrix : SubstitutionMatrix, optional
         A custom substitution matrix.
-    
+
     See also
     --------
     Muscle5App
-    
+
     Examples
     --------
 
@@ -55,34 +52,32 @@ class MuscleApp(MSAApp):
     BISM-ITE
     -IQL-ITE
     """
-    
+
     def __init__(self, sequences, bin_path="muscle", matrix=None):
         major_version = get_version(bin_path)[0]
         if major_version != 3:
-            raise VersionError(
-                f"Muscle 3 is required, got version {major_version}"
-            )
-        
+            raise VersionError(f"Muscle 3 is required, got version {major_version}")
+
         super().__init__(sequences, bin_path, matrix)
         self._gap_open = None
         self._gap_ext = None
         self._terminal_penalty = None
         self._tree1 = None
         self._tree2 = None
-        self._out_tree1_file = NamedTemporaryFile(
-            "r", suffix=".tree", delete=False
-        )
-        self._out_tree2_file = NamedTemporaryFile(
-            "r", suffix=".tree", delete=False
-        )
-    
+        self._out_tree1_file = NamedTemporaryFile("r", suffix=".tree", delete=False)
+        self._out_tree2_file = NamedTemporaryFile("r", suffix=".tree", delete=False)
+
     def run(self):
         args = [
             "-quiet",
-            "-in", self.get_input_file_path(),
-            "-out", self.get_output_file_path(),
-            "-tree1", self._out_tree1_file.name,
-            "-tree2", self._out_tree2_file.name,
+            "-in",
+            self.get_input_file_path(),
+            "-out",
+            self.get_output_file_path(),
+            "-tree1",
+            self._out_tree1_file.name,
+            "-tree2",
+            self._out_tree2_file.name,
         ]
         if self.get_seqtype() == "protein":
             args += ["-seqtype", "protein"]
@@ -91,7 +86,7 @@ class MuscleApp(MSAApp):
         if self.get_matrix_file_path() is not None:
             args += ["-matrix", self.get_matrix_file_path()]
         if self._gap_open is not None and self._gap_ext is not None:
-            args += ["-gapopen",   f"{self._gap_open:.1f}"]
+            args += ["-gapopen", f"{self._gap_open:.1f}"]
             args += ["-gapextend", f"{self._gap_ext:.1f}"]
             # When the gap penalty is set,
             # use the penalty also for hydrophobic regions
@@ -100,7 +95,7 @@ class MuscleApp(MSAApp):
             args += ["-center", "0.0"]
         self.set_arguments(args)
         super().run()
-    
+
     def evaluate(self):
         super().evaluate()
 
@@ -108,23 +103,19 @@ class MuscleApp(MSAApp):
         if len(newick) > 0:
             self._tree1 = Tree.from_newick(newick)
         else:
-            warnings.warn(
-                "MUSCLE did not write a tree file from the first iteration"
-            )
-        
+            warnings.warn("MUSCLE did not write a tree file from the first iteration")
+
         newick = self._out_tree2_file.read().replace("\n", "")
         if len(newick) > 0:
             self._tree2 = Tree.from_newick(newick)
         else:
-            warnings.warn(
-                "MUSCLE did not write a tree file from the second iteration"
-            )
-    
+            warnings.warn("MUSCLE did not write a tree file from the second iteration")
+
     def clean_up(self):
         super().clean_up()
         cleanup_tempfile(self._out_tree1_file)
         cleanup_tempfile(self._out_tree2_file)
-    
+
     @requires_state(AppState.CREATED)
     def set_gap_penalty(self, gap_penalty):
         """
@@ -145,20 +136,20 @@ class MuscleApp(MSAApp):
             if gap_penalty > 0:
                 raise ValueError("Gap penalty must be negative")
             self._gap_open = gap_penalty
-            self._gap_ext= gap_penalty
-        elif type(gap_penalty) == tuple:
+            self._gap_ext = gap_penalty
+        elif isinstance(gap_penalty, Sequence):
             if gap_penalty[0] > 0 or gap_penalty[1] > 0:
-                    raise ValueError("Gap penalty must be negative")
+                raise ValueError("Gap penalty must be negative")
             self._gap_open = gap_penalty[0]
             self._gap_ext = gap_penalty[1]
         else:
             raise TypeError("Gap penalty must be either float or tuple")
-    
+
     @requires_state(AppState.JOINED)
     def get_guide_tree(self, iteration="identity"):
         """
         Get the guide tree created for the progressive alignment.
-        
+
         Parameters
         ----------
         iteration : {'kmer', 'identity'}
@@ -168,7 +159,7 @@ class MuscleApp(MSAApp):
             If 'identity' the second iteration tree is returned.
             This tree uses distances based on the pairwise sequence
             identity after the first progressive alignment iteration.
-        
+
         Returns
         -------
         tree : Tree
@@ -180,32 +171,31 @@ class MuscleApp(MSAApp):
             return self._tree2
         else:
             raise ValueError("Iteration must be 'kmer' or 'identity'")
-    
+
     @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 True
-    
+
     @classmethod
-    def align(cls, sequences, bin_path=None, matrix=None,
-              gap_penalty=None):
+    def align(cls, sequences, bin_path=None, matrix=None, gap_penalty=None):
         """
         Perform a multiple sequence alignment.
-        
+
         This is a convenience function, that wraps the :class:`MuscleApp`
         execution.
-        
+
         Parameters
         ----------
         sequences : iterable object of Sequence
@@ -222,7 +212,7 @@ class MuscleApp(MSAApp):
             The first value in the tuple is the gap opening penalty,
             the second value is the gap extension penalty.
             The values need to be negative.
-        
+
         Returns
         -------
         alignment : Alignment
@@ -240,15 +230,11 @@ class MuscleApp(MSAApp):
 
 
 def get_version(bin_path="muscle"):
-    output = subprocess.run(
-        [bin_path, "-version"], capture_output=True, text=True
-    )
+    output = subprocess.run([bin_path, "-version"], capture_output=True, text=True)
     # Find matches for version string containing major and minor version
-    match = re.search("\d+\.\d+", output.stdout)
+    match = re.search(r"\d+\.\d+", output.stdout)
     if match is None:
-        raise subprocess.SubprocessError(
-            "Could not determine Muscle version"
-        )
+        raise subprocess.SubprocessError("Could not determine Muscle version")
     version_string = match.group(0)
     splitted = version_string.split(".")
-    return int(splitted[0]), int(splitted[1])
+    return int(splitted[0]), int(splitted[1])