biotite 0.41.2__cp310-cp310-macosx_11_0_arm64.whl → 1.0.1__cp310-cp310-macosx_11_0_arm64.whl

biotite/application/muscle/app5.py

@@ -6,31 +6,22 @@ __name__ = "biotite.application.muscle"
 __author__ = "Patrick Kunzmann"
 __all__ = ["Muscle5App"]
 
-import numbers
-import warnings
-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 .app3 import get_version
+from biotite.application.application import AppState, VersionError, requires_state
+from biotite.application.msaapp import MSAApp
+from biotite.application.muscle.app3 import get_version
 
 
 class Muscle5App(MSAApp):
     """
     Perform a multiple sequence alignment using MUSCLE version 5.
-    
+
     Parameters
     ----------
     sequences : list of Sequence
         The sequences to be aligned.
     bin_path : str, optional
         Path of the MUSCLE binary.
-    
+
     See also
     --------
     MuscleApp
@@ -38,7 +29,7 @@ class Muscle5App(MSAApp):
     Notes
     -----
     Alignment ensemble generation is not supported, yet.
-    
+
     Examples
     --------
 
@@ -56,14 +47,14 @@ class Muscle5App(MSAApp):
     BI-SMITE
     -I-QLITE
     """
-    
+
     def __init__(self, sequences, bin_path="muscle"):
         major_version = get_version(bin_path)[0]
         if major_version < 5:
             raise VersionError(
                 f"At least Muscle 5 is required, got version {major_version}"
             )
-        
+
         super().__init__(sequences, bin_path)
         self._mode = "align"
         self._consiters = None
@@ -86,7 +77,7 @@ class Muscle5App(MSAApp):
             self._consiters = consistency
         if refinement is not None:
             self._refineiters = refinement
-    
+
     @requires_state(AppState.CREATED)
     def set_thread_number(self, number):
         """
@@ -110,48 +101,49 @@ class Muscle5App(MSAApp):
         args = [
             f"-{self._mode}",
             self.get_input_file_path(),
-            "-output", self.get_output_file_path(),
+            "-output",
+            self.get_output_file_path(),
         ]
         if self.get_seqtype() == "protein":
             args += ["-amino"]
         else:
             args += ["-nt"]
         if self._n_threads is not None:
-             args += ["-threads", str(self._n_threads)]
+            args += ["-threads", str(self._n_threads)]
         if self._consiters is not None:
-             args += ["-consiters", str(self._consiters)]
+            args += ["-consiters", str(self._consiters)]
         if self._refineiters is not None:
-             args += ["-refineiters", str(self._refineiters)]
+            args += ["-refineiters", str(self._refineiters)]
         self.set_arguments(args)
         super().run()
-    
+
     def clean_up(self):
         super().clean_up()
-    
+
     @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
-    
+
     @classmethod
     def align(cls, sequences, bin_path="muscle"):
         """
         Perform a multiple sequence alignment.
-        
+
         This is a convenience function, that wraps the :class:`Muscle5App`
         execution.
-        
+
         Parameters
         ----------
         sequences : iterable object of Sequence
@@ -159,7 +151,7 @@ class Muscle5App(MSAApp):
         bin_path : str, optional
             Path of the MSA software binary. By default, the default path
             will be used.
-        
+
         Returns
         -------
         alignment : Alignment

biotite/application/sra/__init__.py

@@ -15,4 +15,4 @@ writes sequence reads into FASTA format.
 __name__ = "biotite.application.sra"
 __author__ = "Patrick Kunzmann"
 
-from .app import *
+from .app import *

biotite/application/sra/app.py

@@ -7,17 +7,21 @@ __author__ = "Patrick Kunzmann"
 __all__ = ["FastaDumpApp", "FastqDumpApp"]
 
 import abc
-from os.path import join
-from subprocess import Popen, SubprocessError, PIPE, TimeoutExpired
 import glob
+from os.path import join
+from subprocess import PIPE, Popen, SubprocessError, TimeoutExpired
 from tempfile import TemporaryDirectory
-from ..application import Application, AppState, AppStateError, \
-                          requires_state
-from ...sequence.seqtypes import NucleotideSequence
-from ...sequence.io.fastq.file import FastqFile
-from ...sequence.io.fasta.file import FastaFile
-from ...sequence.io.fastq.convert import get_sequences as get_sequences_and_scores
-from ...sequence.io.fasta.convert import get_sequences
+from biotite.application.application import (
+    Application,
+    AppState,
+    AppStateError,
+    requires_state,
+)
+from biotite.sequence.io.fasta.convert import get_sequences
+from biotite.sequence.io.fasta.file import FastaFile
+from biotite.sequence.io.fastq.convert import get_sequences as get_sequences_and_scores
+from biotite.sequence.io.fastq.file import FastqFile
+from biotite.sequence.seqtypes import NucleotideSequence
 
 
 # Do not use LocalApp, as two programs are executed
@@ -48,8 +52,13 @@ class _DumpApp(Application, metaclass=abc.ABCMeta):
         the score format.
     """
 
-    def __init__(self, uid, output_path_prefix=None,
-                 prefetch_path="prefetch", fasterq_dump_path="fasterq-dump"):
+    def __init__(
+        self,
+        uid,
+        output_path_prefix=None,
+        prefetch_path="prefetch",
+        fasterq_dump_path="fasterq-dump",
+    ):
         super().__init__()
         self._prefetch_path = prefetch_path
         self._fasterq_dump_path = fasterq_dump_path
@@ -62,21 +71,16 @@ class _DumpApp(Application, metaclass=abc.ABCMeta):
         self._prefetch_process = None
         self._fasterq_dump_process = None
 
-
     @requires_state(AppState.RUNNING | AppState.FINISHED)
     def join(self, timeout=None):
         # Override method as repetitive calls of 'is_finished()'
         # are not necessary as 'communicate()' already waits for the
         # finished application
         try:
-            _, self._stderr = self._process.communicate(
-                timeout=timeout
-            )
+            _, self._stderr = self._process.communicate(timeout=timeout)
         except TimeoutExpired:
             self.cancel()
-            raise TimeoutError(
-                f"The application expired its timeout ({timeout:.1f} s)"
-            )
+            raise TimeoutError(f"The application expired its timeout ({timeout:.1f} s)")
         self._state = AppState.FINISHED
 
         try:
@@ -90,7 +94,6 @@ class _DumpApp(Application, metaclass=abc.ABCMeta):
             self._state = AppState.JOINED
         self.clean_up()
 
-
     def run(self):
         # Prefetch into a temp directory with file name equaling UID
         # This ensures that the ID in the header is not the temp prefix
@@ -105,16 +108,14 @@ class _DumpApp(Application, metaclass=abc.ABCMeta):
             command, stdout=PIPE, stderr=PIPE, shell=True, encoding="UTF-8"
         )
 
-
     def is_finished(self):
         code = self._process.poll()
-        if code == None:
+        if code is None:
             return False
         else:
-            _,  self._stderr = self._process.communicate()
+            _, self._stderr = self._process.communicate()
             return True
 
-
     def evaluate(self):
         super().evaluate()
         # Check if applicaion terminated correctly
@@ -128,26 +129,24 @@ class _DumpApp(Application, metaclass=abc.ABCMeta):
 
         self._file_names = (
             # For entries with one read per spot
-            glob.glob(self._prefix +   ".fastq") +
+            glob.glob(self._prefix + ".fastq")
+            +
             # For entries with multiple reads per spot
             glob.glob(self._prefix + "_*.fastq")
         )
         # Only load FASTQ files into memory when needed
         self._fastq_files = None
 
-
     def wait_interval(self):
         # Not used in this implementation of 'join()'
         raise NotImplementedError()
 
-
     def clean_up(self):
         if self.get_app_state() == AppState.CANCELLED:
             self._process.kill()
         # Directory with temp files does not need to be deleted,
         # as temp dir is automatically deleted upon object destruction
 
-
     @requires_state(AppState.CREATED)
     def get_prefetch_options(self):
         """
@@ -176,7 +175,6 @@ class _DumpApp(Application, metaclass=abc.ABCMeta):
         """
         return ""
 
-
     @requires_state(AppState.JOINED)
     def get_file_paths(self):
         """
@@ -189,7 +187,6 @@ class _DumpApp(Application, metaclass=abc.ABCMeta):
         """
         return self._file_names
 
-
     @requires_state(AppState.JOINED)
     @abc.abstractmethod
     def get_sequences(self):
@@ -236,15 +233,18 @@ class FastqDumpApp(_DumpApp):
         the score format.
     """
 
-    def __init__(self, uid, output_path_prefix=None, prefetch_path="prefetch",
-                 fasterq_dump_path="fasterq-dump", offset="Sanger"):
-        super().__init__(
-            uid, output_path_prefix, prefetch_path, fasterq_dump_path
-        )
+    def __init__(
+        self,
+        uid,
+        output_path_prefix=None,
+        prefetch_path="prefetch",
+        fasterq_dump_path="fasterq-dump",
+        offset="Sanger",
+    ):
+        super().__init__(uid, output_path_prefix, prefetch_path, fasterq_dump_path)
         self._offset = offset
         self._fastq_files = None
 
-
     @requires_state(AppState.JOINED)
     def get_fastq(self):
         """
@@ -265,20 +265,16 @@ class FastqDumpApp(_DumpApp):
             ]
         return self._fastq_files
 
-
     @requires_state(AppState.JOINED)
     def get_sequences(self):
         return [
             {
-                header: NucleotideSequence(
-                    seq_str.replace("U","T").replace("X","N")
-                )
+                header: NucleotideSequence(seq_str.replace("U", "T").replace("X", "N"))
                 for header, (seq_str, _) in fastq_file.items()
             }
             for fastq_file in self.get_fastq()
         ]
 
-
     @requires_state(AppState.JOINED)
     def get_sequences_and_scores(self):
         """
@@ -294,15 +290,17 @@ class FastqDumpApp(_DumpApp):
             Each item in the list is a dictionary mapping identifiers to its
             corresponding sequence and score values.
         """
-        return [
-            get_sequences_and_scores(fastq_file)
-            for fastq_file in self.get_fastq()
-        ]
-
+        return [get_sequences_and_scores(fastq_file) for fastq_file in self.get_fastq()]
 
     @classmethod
-    def fetch(cls, uid, output_path_prefix=None, prefetch_path="prefetch",
-              fasterq_dump_path="fasterq-dump", offset="Sanger"):
+    def fetch(
+        cls,
+        uid,
+        output_path_prefix=None,
+        prefetch_path="prefetch",
+        fasterq_dump_path="fasterq-dump",
+        offset="Sanger",
+    ):
         """
         Get the sequences belonging to the UID from the
         *NCBI sequence read archive* (SRA).
@@ -338,9 +336,7 @@ class FastqDumpApp(_DumpApp):
             Each item in the list is a dictionary mapping identifiers to its
             corresponding sequence.
         """
-        app = cls(
-            uid, output_path_prefix, prefetch_path, fasterq_dump_path, offset
-        )
+        app = cls(uid, output_path_prefix, prefetch_path, fasterq_dump_path, offset)
         app.start()
         app.join()
         return app.get_sequences()
@@ -368,14 +364,16 @@ class FastaDumpApp(_DumpApp):
         respectively.
     """
 
-    def __init__(self, uid, output_path_prefix=None, prefetch_path="prefetch",
-                 fasterq_dump_path="fasterq-dump"):
-        super().__init__(
-            uid, output_path_prefix, prefetch_path, fasterq_dump_path
-        )
+    def __init__(
+        self,
+        uid,
+        output_path_prefix=None,
+        prefetch_path="prefetch",
+        fasterq_dump_path="fasterq-dump",
+    ):
+        super().__init__(uid, output_path_prefix, prefetch_path, fasterq_dump_path)
         self._fasta_files = None
 
-
     @requires_state(AppState.CREATED)
     def get_prefetch_options(self):
         return
@@ -383,12 +381,10 @@ class FastaDumpApp(_DumpApp):
         # when https://github.com/ncbi/sra-tools/issues/883 is resolved
         # return "--eliminate-quals"
 
-
     @requires_state(AppState.CREATED)
     def get_fastq_dump_options(self):
         return "--fasta"
 
-
     @requires_state(AppState.JOINED)
     def get_fasta(self):
         """
@@ -404,20 +400,22 @@ class FastaDumpApp(_DumpApp):
         """
         if self._fasta_files is None:
             self._fasta_files = [
-                FastaFile.read(file_name)
-                for file_name in self.get_file_paths()
+                FastaFile.read(file_name) for file_name in self.get_file_paths()
             ]
         return self._fasta_files
 
-
     @requires_state(AppState.JOINED)
     def get_sequences(self):
         return [get_sequences(fasta_file) for fasta_file in self.get_fasta()]
 
-
     @classmethod
-    def fetch(cls, uid, output_path_prefix=None, prefetch_path="prefetch",
-              fasterq_dump_path="fasterq-dump"):
+    def fetch(
+        cls,
+        uid,
+        output_path_prefix=None,
+        prefetch_path="prefetch",
+        fasterq_dump_path="fasterq-dump",
+    ):
         """
         Get the sequences belonging to the UID from the
         *NCBI sequence read archive* (SRA).
@@ -448,9 +446,7 @@ class FastaDumpApp(_DumpApp):
             Each item in the list is a dictionary mapping identifiers to its
             corresponding sequence.
         """
-        app = cls(
-            uid, output_path_prefix, prefetch_path, fasterq_dump_path
-        )
+        app = cls(uid, output_path_prefix, prefetch_path, fasterq_dump_path)
         app.start()
         app.join()
-        return app.get_sequences()
+        return app.get_sequences()

biotite/application/tantan/__init__.py

@@ -9,4 +9,4 @@ A subpackage for masking sequence regions using the *tantan* software.
 __name__ = "biotite.application.tantan"
 __author__ = "Patrick Kunzmann"
 
-from .app import *
+from .app import *

biotite/application/tantan/app.py

@@ -6,17 +6,15 @@ __name__ = "biotite.application.tantan"
 __author__ = "Patrick Kunzmann"
 __all__ = ["TantanApp"]
 
-from collections.abc import Sequence as SequenceABC
 import io
+from collections.abc import Sequence as SequenceABC
 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.alphabet import common_alphabet
-from ...sequence.io.fasta.file import FastaFile
-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.sequence.alphabet import common_alphabet
+from biotite.sequence.io.fasta.file import FastaFile
+from biotite.sequence.seqtypes import NucleotideSequence, ProteinSequence
 
 MASKING_LETTER = "!"
 
@@ -43,7 +41,7 @@ class TantanApp(LocalApp):
 
     References
     ----------
-    
+
     .. footbibliography::
 
     Examples
@@ -59,10 +57,10 @@ class TantanApp(LocalApp):
       True  True  True  True  True  True  True  True False False False False
      False]
     >>> print(sequence, "\n" + "".join(["^" if e else " " for e in repeat_mask]))
-    GGCATCGATATATATATATAGTCAA 
-             ^^^^^^^^^^^         
+    GGCATCGATATATATATATAGTCAA
+             ^^^^^^^^^^^
     """
-    
+
     def __init__(self, sequence, matrix=None, bin_path="tantan"):
         super().__init__(bin_path)
 
@@ -93,59 +91,43 @@ class TantanApp(LocalApp):
                     )
                 self._is_protein = True
             else:
-                raise TypeError(
-                    "A NucleotideSequence or ProteinSequence is required"
-                )
-        
+                raise TypeError("A NucleotideSequence or ProteinSequence is required")
+
         if matrix is None:
             self._matrix_file = None
         else:
-            common_alph = common_alphabet(
-                (seq.alphabet for seq in self._sequences)
-            )
+            common_alph = common_alphabet((seq.alphabet for seq in self._sequences))
             if common_alph is None:
-                raise ValueError(
-                    "There is no common alphabet within the sequences"
-                )
+                raise ValueError("There is no common alphabet within the sequences")
             if not matrix.get_alphabet1().extends(common_alph):
                 raise ValueError(
                     "The alphabet of the sequence(s) do not fit the matrix"
                 )
             if not matrix.is_symmetric():
                 raise ValueError("A symmetric matrix is required")
-            self._matrix_file = NamedTemporaryFile(
-                "w", suffix=".mat", delete=False
-            )
+            self._matrix_file = NamedTemporaryFile("w", suffix=".mat", delete=False)
         self._matrix = matrix
-        
-        self._in_file = NamedTemporaryFile("w", suffix=".fa", delete=False)
 
+        self._in_file = NamedTemporaryFile("w", suffix=".fa", delete=False)
 
     def run(self):
         FastaFile.write_iter(
             self._in_file,
-            (
-                (f"sequence_{i:d}", str(seq))
-                for i, seq in enumerate(self._sequences)
-            )
+            ((f"sequence_{i:d}", str(seq)) for i, seq in enumerate(self._sequences)),
         )
         self._in_file.flush()
         if self._matrix is not None:
             self._matrix_file.write(str(self._matrix))
             self._matrix_file.flush()
-        
+
         args = []
         if self._matrix is not None:
             args += ["-m", self._matrix_file.name]
         if self._is_protein:
-             args += ["-p"]
-        args += [
-            "-x", MASKING_LETTER,
-            self._in_file.name
-        ]
+            args += ["-p"]
+        args += ["-x", MASKING_LETTER, self._in_file.name]
         self.set_arguments(args)
         super().run()
-    
 
     def evaluate(self):
         super().evaluate()
@@ -154,18 +136,14 @@ class TantanApp(LocalApp):
         self._masks = []
         encoded_masking_letter = MASKING_LETTER.encode("ASCII")[0]
         for _, masked_seq_string in FastaFile.read_iter(out_file):
-            array = np.frombuffer(
-                masked_seq_string.encode("ASCII"), dtype=np.ubyte
-            )
+            array = np.frombuffer(masked_seq_string.encode("ASCII"), dtype=np.ubyte)
             self._masks.append(array == encoded_masking_letter)
-    
 
     def clean_up(self):
         super().clean_up()
         cleanup_tempfile(self._in_file)
         if self._matrix_file is not None:
             cleanup_tempfile(self._matrix_file)
-    
 
     @requires_state(AppState.JOINED)
     def get_mask(self):
@@ -186,7 +164,6 @@ class TantanApp(LocalApp):
         else:
             return self._masks[0]
 
-
     @staticmethod
     def mask_repeats(sequence, matrix=None, bin_path="tantan"):
         """
@@ -219,4 +196,4 @@ class TantanApp(LocalApp):
         app = TantanApp(sequence, matrix, bin_path)
         app.start()
         app.join()
-        return app.get_mask()
+        return app.get_mask()

biotite/application/util.py

@@ -8,15 +8,15 @@ __all__ = ["map_sequence", "map_matrix"]
 
 
 import numpy as np
-from ..sequence.seqtypes import ProteinSequence
-from ..sequence.align.matrix import SubstitutionMatrix
+from biotite.sequence.align.matrix import SubstitutionMatrix
+from biotite.sequence.seqtypes import ProteinSequence
 
 
 def map_sequence(sequence):
     """
     Map a sequence with an arbitrary alphabet into a
     :class:`ProteinSequence`, in order to support arbitrary sequence
-    types in software that can handle protein sequences. 
+    types in software that can handle protein sequences.
     """
     if len(sequence.alphabet) > len(ProteinSequence.alphabet):
         # Cannot map into a protein sequence if the alphabet
@@ -39,12 +39,11 @@ def map_matrix(matrix):
     Map a :class:`SubstitutionMatrix` with an arbitrary alphabet into a
     class:`SubstitutionMatrix` for protein sequences, in order to support
     arbitrary sequence types in software that can handle protein
-    sequences. 
+    sequences.
     """
     if matrix is None:
         raise TypeError(
-            "A substitution matrix must be provided for custom "
-            "sequence types"
+            "A substitution matrix must be provided for custom " "sequence types"
         )
     # Create a protein substitution matrix with the values taken
     # from the original matrix
@@ -54,6 +53,5 @@ def map_matrix(matrix):
     new_score_matrix = np.zeros((new_length, new_length))
     new_score_matrix[:old_length, :old_length] = matrix.score_matrix()
     return SubstitutionMatrix(
-        ProteinSequence.alphabet, ProteinSequence.alphabet,
-        new_score_matrix
-    )
+        ProteinSequence.alphabet, ProteinSequence.alphabet, new_score_matrix
+    )