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

biotite/sequence/io/fasta/__init__.py

@@ -18,5 +18,5 @@ getting/setting directly :class:`Sequence` objects, rather than strings.
 __name__ = "biotite.sequence.io.fasta"
 __author__ = "Patrick Kunzmann"
 
+from .convert import *
 from .file import *
-from .convert import *

biotite/sequence/io/fasta/convert.py

@@ -7,13 +7,18 @@ __author__ = "Patrick Kunzmann"
 
 import warnings
 from collections import OrderedDict
-from ...sequence import Sequence
-from ...alphabet import AlphabetError, LetterAlphabet
-from ...seqtypes import NucleotideSequence, ProteinSequence
-from ...align.alignment import Alignment
+from biotite.sequence.align.alignment import Alignment
+from biotite.sequence.alphabet import AlphabetError, LetterAlphabet
+from biotite.sequence.seqtypes import NucleotideSequence, ProteinSequence
 
-__all__ = ["get_sequence", "get_sequences", "set_sequence", "set_sequences",
-           "get_alignment", "set_alignment"]
+__all__ = [
+    "get_sequence",
+    "get_sequences",
+    "set_sequence",
+    "set_sequences",
+    "get_alignment",
+    "set_alignment",
+]
 
 
 def get_sequence(fasta_file, header=None, seq_type=None):
@@ -180,8 +185,10 @@ def get_alignment(fasta_file, additional_gap_chars=("_",), seq_type=None):
         for i, seq_str in enumerate(seq_strings):
             seq_strings[i] = seq_str.replace(char, "-")
     # Remove gaps for creation of sequences
-    sequences = [_convert_to_sequence(seq_str.replace("-",""), seq_type)
-                 for seq_str in seq_strings]
+    sequences = [
+        _convert_to_sequence(seq_str.replace("-", ""), seq_type)
+        for seq_str in seq_strings
+    ]
     trace = Alignment.trace_from_strings(seq_strings)
     return Alignment(sequences, trace, score=None)
 
@@ -212,44 +219,29 @@ def set_alignment(fasta_file, alignment, seq_names):
 
 
 def _convert_to_sequence(seq_str, seq_type=None):
-
-    # Define preprocessing of preimplemented sequence types
-
-    # Replace selenocysteine with cysteine
-    # and pyrrolysine with lysine
-    process_protein_sequence = (
-        lambda x : x.upper().replace("U", "C").replace("O", "K")
-    )
-    # For nucleotides uracil is represented by thymine and there is only
-    # one letter for completely unknown nucleotides
-    process_nucleotide_sequence = (
-        lambda x : x.upper().replace("U","T").replace("X","N")
-    )
-
     # Set manually selected sequence type
-
     if seq_type is not None:
         # Do preprocessing as done without manual selection
         if seq_type == NucleotideSequence:
-            seq_str = process_nucleotide_sequence(seq_str)
+            seq_str = _process_nucleotide_sequence(seq_str)
         elif seq_type == ProteinSequence:
             if "U" in seq_str:
                 warnings.warn(
                     "ProteinSequence objects do not support selenocysteine "
                     "(U), occurrences were substituted by cysteine (C)"
                 )
-            seq_str = process_protein_sequence(seq_str)
+            seq_str = _process_protein_sequence(seq_str)
         # Return the converted sequence
         return seq_type(seq_str)
 
     # Attempt to automatically determine sequence type
 
     try:
-        return NucleotideSequence(process_nucleotide_sequence(seq_str))
+        return NucleotideSequence(_process_nucleotide_sequence(seq_str))
     except AlphabetError:
         pass
     try:
-        prot_seq = ProteinSequence(process_protein_sequence(seq_str))
+        prot_seq = ProteinSequence(_process_protein_sequence(seq_str))
         # Raise Warning after conversion into 'ProteinSequence'
         # to wait for potential 'AlphabetError'
         if "U" in seq_str:
@@ -259,15 +251,34 @@ def _convert_to_sequence(seq_str, seq_type=None):
             )
         return prot_seq
     except AlphabetError:
-        raise ValueError("FASTA data cannot be converted either to "
-                         "'NucleotideSequence' nor to 'ProteinSequence'")
+        raise ValueError(
+            "FASTA data cannot be converted either to "
+            "'NucleotideSequence' nor to 'ProteinSequence'"
+        )
+
+
+def _process_protein_sequence(x):
+    """
+    Replace selenocysteine with cysteine and pyrrolysine with lysine.
+    """
+    return x.upper().replace("U", "C").replace("O", "K")
+
+
+def _process_nucleotide_sequence(x):
+    """
+    For nucleotides uracil is represented by thymine and there is only
+    one letter for completely unknown nucleotides
+    """
+    return x.upper().replace("U", "T").replace("X", "N")
 
 
 def _convert_to_string(sequence, as_rna):
     if not isinstance(sequence.get_alphabet(), LetterAlphabet):
-        raise ValueError("Only sequences using single letter alphabets "
-                         "can be stored in a FASTA file")
+        raise ValueError(
+            "Only sequences using single letter alphabets "
+            "can be stored in a FASTA file"
+        )
     if isinstance(sequence, NucleotideSequence) and as_rna:
-        return(str(sequence).replace("T", "U"))
+        return str(sequence).replace("T", "U")
     else:
-        return(str(sequence))
+        return str(sequence)

biotite/sequence/io/fasta/file.py

@@ -6,21 +6,21 @@ __name__ = "biotite.sequence.io.fasta"
 __author__ = "Patrick Kunzmann"
 __all__ = ["FastaFile"]
 
-from ....file import TextFile, InvalidFileError, wrap_string
 from collections import OrderedDict
 from collections.abc import MutableMapping
+from biotite.file import InvalidFileError, TextFile, wrap_string
 
 
 class FastaFile(TextFile, MutableMapping):
     """
     This class represents a file in FASTA format.
-    
+
     A FASTA file contains so called *header* lines, beginning with
     ``>``, that describe following sequence.
     The corresponding sequence starts at the line after the header line
     and ends at the next header line or at the end of file.
     The header along with its sequence forms an entry.
-    
+
     This class is used in a dictionary like manner, implementing the
     :class:`MutableMapping` interface:
     Headers (without the leading ``>``) are used as keys,
@@ -35,10 +35,10 @@ class FastaFile(TextFile, MutableMapping):
         after which a line break is inserted.
         Only relevant, when adding sequences to a file.
         Default is 80.
-    
+
     Examples
     --------
-    
+
     >>> import os.path
     >>> file = FastaFile()
     >>> file["seq1"] = "ATACT"
@@ -61,17 +61,17 @@ class FastaFile(TextFile, MutableMapping):
     {'seq2': 'AAAATT'}
     >>> file.write(os.path.join(path_to_directory, "test.fasta"))
     """
-    
+
     def __init__(self, chars_per_line=80):
         super().__init__()
         self._chars_per_line = chars_per_line
         self._entries = OrderedDict()
-    
+
     @classmethod
     def read(cls, file, chars_per_line=80):
         """
         Read a FASTA file.
-        
+
         Parameters
         ----------
         file : file-like object or str
@@ -82,7 +82,7 @@ class FastaFile(TextFile, MutableMapping):
             after which a line break is inserted.
             Only relevant, when adding sequences to a file.
             Default is 80.
-        
+
         Returns
         -------
         file_object : FastaFile
@@ -90,24 +90,23 @@ class FastaFile(TextFile, MutableMapping):
         """
         file = super().read(file, chars_per_line)
         # Filter out empty and comment lines
-        file.lines = [line for line in file.lines
-                      if len(line.strip()) != 0 and line[0] != ";"]
+        file.lines = [
+            line for line in file.lines if len(line.strip()) != 0 and line[0] != ";"
+        ]
         if len(file.lines) == 0:
             raise InvalidFileError("File is empty or contains only comments")
         file._find_entries()
         return file
-        
+
     def __setitem__(self, header, seq_str):
         if not isinstance(header, str):
-            raise IndexError(
-                "'FastaFile' only supports header strings as keys"
-            )
+            raise IndexError("'FastaFile' only supports header strings as keys")
         if not isinstance(seq_str, str):
-            raise TypeError("'FastaFile' only supports sequence strings "
-                             "as values")
+            raise TypeError("'FastaFile' only supports sequence strings " "as values")
         # Create lines for new header and sequence (with line breaks)
-        new_lines = [">" + header.replace("\n","").strip()] + \
-                    wrap_string(seq_str, width=self._chars_per_line)
+        new_lines = [">" + header.replace("\n", "").strip()] + wrap_string(
+            seq_str, width=self._chars_per_line
+        )
         if header in self:
             # Delete lines of entry corresponding to the header,
             # if existing
@@ -118,83 +117,75 @@ class FastaFile(TextFile, MutableMapping):
             # Simply append lines
             # Add entry in a more efficient way than '_find_entries()'
             # for this simple case
-            self._entries[header] = (
-                len(self.lines),
-                len(self.lines) + len(new_lines)
-            )
+            self._entries[header] = (len(self.lines), len(self.lines) + len(new_lines))
             self.lines += new_lines
-    
+
     def __getitem__(self, header):
         if not isinstance(header, str):
-            raise IndexError(
-                "'FastaFile' only supports header strings as keys"
-            )
+            raise IndexError("'FastaFile' only supports header strings as keys")
         start, stop = self._entries[header]
         # Concatenate sequence string from following lines
-        seq_string = "".join(
-            [line.strip() for line in self.lines[start+1 : stop]]
-        )
+        seq_string = "".join([line.strip() for line in self.lines[start + 1 : stop]])
         return seq_string
-    
+
     def __delitem__(self, header):
         start, stop = self._entries[header]
         del self.lines[start:stop]
         del self._entries[header]
         self._find_entries()
-    
+
     def __len__(self):
         return len(self._entries)
-    
+
     def __iter__(self):
         return self._entries.__iter__()
-    
+
     def __contains__(self, identifer):
         return identifer in self._entries
-    
+
     def _find_entries(self):
         if len(self.lines) > 0 and self.lines[0][0] != ">":
             raise InvalidFileError(
                 f"File starts with '{self.lines[0][0]}' instead of '>'"
             )
-        
+
         header_i = []
         for i, line in enumerate(self.lines):
             if line[0] == ">":
                 header_i.append(i)
-        
+
         self._entries = OrderedDict()
         for j in range(len(header_i)):
             # Remove leading '>' from header
             header = self.lines[header_i[j]].strip()[1:]
             start = header_i[j]
-            if j < len(header_i) -1:
+            if j < len(header_i) - 1:
                 # Header in mid or start of file
                 # -> stop is start of next header
-                stop = header_i[j+1]
+                stop = header_i[j + 1]
             else:
                 # Last header -> entry stops at end of file
                 stop = len(self.lines)
             self._entries[header] = (start, stop)
 
-
     @staticmethod
     def read_iter(file):
         """
         Create an iterator over each sequence of the given FASTA file.
-        
+
         Parameters
         ----------
         file : file-like object or str
             The file to be read.
             Alternatively a file path can be supplied.
-        
+
         Yields
         ------
         header : str
             The header of the current sequence.
         seq_str : str
             The current sequence as string.
-        
+
         Notes
         -----
         This approach gives the same results as
@@ -221,7 +212,6 @@ class FastaFile(TextFile, MutableMapping):
         # Yield final entry
         if header is not None:
             yield header, "".join(seq_str_list)
-    
 
     @staticmethod
     def write_iter(file, items, chars_per_line=80):
@@ -235,7 +225,7 @@ class FastaFile(TextFile, MutableMapping):
         Hence, this static method may save a large amount of memory if
         a large file should be written, especially if the `items`
         are provided as generator.
-        
+
         Parameters
         ----------
         file : file-like object or str
@@ -256,23 +246,20 @@ class FastaFile(TextFile, MutableMapping):
         This method does not test, whether the given identifiers are
         unambiguous.
         """
+
         def line_generator():
             for item in items:
                 header, seq_str = item
                 if not isinstance(header, str):
-                    raise IndexError(
-                        "'FastaFile' only supports header strings"
-                    )
+                    raise IndexError("'FastaFile' only supports header strings")
                 if not isinstance(seq_str, str):
-                    raise TypeError(
-                        "'FastaFile' only supports sequence strings"
-                    )
-                
+                    raise TypeError("'FastaFile' only supports sequence strings")
+
                 # Yield header line
-                yield ">" + header.replace("\n","").strip()
+                yield ">" + header.replace("\n", "").strip()
 
                 # Yield sequence line(s)
                 for line in wrap_string(seq_str, width=chars_per_line):
                     yield line
-    
-        TextFile.write_iter(file, line_generator())
+
+        TextFile.write_iter(file, line_generator())

biotite/sequence/io/fastq/__init__.py

@@ -15,5 +15,5 @@ values.
 __name__ = "biotite.sequence.io.fastq"
 __author__ = "Patrick Kunzmann"
 
+from .convert import *
 from .file import *
-from .convert import *

biotite/sequence/io/fastq/convert.py

@@ -6,10 +6,7 @@ __name__ = "biotite.sequence.io.fastq"
 __author__ = "Patrick Kunzmann"
 
 from collections import OrderedDict
-from ...sequence import Sequence
-from ...alphabet import AlphabetError, LetterAlphabet
-from ...seqtypes import NucleotideSequence
-from ...align.alignment import Alignment
+from biotite.sequence.seqtypes import NucleotideSequence
 
 __all__ = ["get_sequence", "get_sequences", "set_sequence", "set_sequences"]
 
@@ -17,7 +14,7 @@ __all__ = ["get_sequence", "get_sequences", "set_sequence", "set_sequences"]
 def get_sequence(fastq_file, header=None):
     """
     Get a sequence and quality scores from a `FastqFile` instance.
-    
+
     Parameters
     ----------
     fastq_file : FastqFile
@@ -25,7 +22,7 @@ def get_sequence(fastq_file, header=None):
     header : str, optional
         The identifier to get the sequence and scores from.
         By default, the first sequence of the file is returned.
-    
+
     Returns
     -------
     sequence : NucleotideSequence
@@ -43,7 +40,7 @@ def get_sequence(fastq_file, header=None):
             break
         if seq_str is None:
             raise ValueError("File does not contain any sequences")
-    processed_seq_str = seq_str.replace("U","T").replace("X","N")
+    processed_seq_str = seq_str.replace("U", "T").replace("X", "N")
     return NucleotideSequence(processed_seq_str), scores
 
 
@@ -51,12 +48,12 @@ def get_sequences(fastq_file):
     """
     Get a dictionary from a `FastqFile` instance,
     where identifiers are keys and sequence-score-tuples are values.
-    
+
     Parameters
     ----------
     fastq_file : FastqFile
         The `Fastqile` to be accessed.
-    
+
     Returns
     -------
     seq_dict : dict
@@ -65,7 +62,7 @@ def get_sequences(fastq_file):
     """
     seq_dict = OrderedDict()
     for header, (seq_str, scores) in fastq_file.items():
-        processed_seq_str = seq_str.replace("U","T").replace("X","N")
+        processed_seq_str = seq_str.replace("U", "T").replace("X", "N")
         seq_dict[header] = NucleotideSequence(processed_seq_str), scores
     return seq_dict
 
@@ -73,7 +70,7 @@ def get_sequences(fastq_file):
 def set_sequence(fastq_file, sequence, scores, header=None, as_rna=False):
     """
     Set a sequence and a quality score array in a `FastqFile` instance.
-    
+
     Parameters
     ----------
     fastq_file : FastqFile
@@ -96,7 +93,7 @@ def set_sequence(fastq_file, sequence, scores, header=None, as_rna=False):
 def set_sequences(fastq_file, sequence_dict, as_rna=False):
     """
     Set sequences in a `FastqFile` instance from a dictionary.
-    
+
     Parameters
     ----------
     fastq_file : FastqFile
@@ -115,6 +112,6 @@ def set_sequences(fastq_file, sequence_dict, as_rna=False):
 
 def _convert_to_string(sequence, as_rna):
     if as_rna:
-        return(str(sequence).replace("T", "U"))
+        return str(sequence).replace("T", "U")
     else:
-        return(str(sequence))
+        return str(sequence)