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

biotite/sequence/io/genbank/sequence.py

@@ -8,16 +8,19 @@ Functions for converting a sequence from/to a GenBank file.
 
 __name__ = "biotite.sequence.io.genbank"
 __author__ = "Patrick Kunzmann"
-__all__ = ["get_raw_sequence", "get_sequence", "get_annotated_sequence",
-           "set_sequence", "set_annotated_sequence"]
+__all__ = [
+    "get_raw_sequence",
+    "get_sequence",
+    "get_annotated_sequence",
+    "set_sequence",
+    "set_annotated_sequence",
+]
 
 import re
-from ....file import InvalidFileError
-from ...seqtypes import ProteinSequence, NucleotideSequence
-from ...annotation import AnnotatedSequence
-from .file import GenBankFile
-from .annotation import get_annotation, set_annotation
-
+from biotite.file import InvalidFileError
+from biotite.sequence.annotation import AnnotatedSequence
+from biotite.sequence.io.genbank.annotation import get_annotation, set_annotation
+from biotite.sequence.seqtypes import NucleotideSequence, ProteinSequence
 
 _SYMBOLS_PER_CHUNK = 10
 _SEQ_CHUNKS_PER_LINE = 6
@@ -112,7 +115,7 @@ def _convert_seq_str(seq_str, format):
     if len(seq_str) == 0:
         raise InvalidFileError("The file's 'ORIGIN' field is empty")
     if format == "gb":
-        return NucleotideSequence(seq_str.replace("U","T").replace("X","N"))
+        return NucleotideSequence(seq_str.replace("U", "T").replace("X", "N"))
     elif format == "gp":
         return ProteinSequence(seq_str.replace("U", "C").replace("O", "K"))
     else:
@@ -125,8 +128,6 @@ def _get_seq_start(origin_content):
     return int(origin_content[0].split()[0])
 
 
-
-
 def set_sequence(gb_file, sequence, sequence_start=1):
     """
     Set the *ORIGIN* field of a GenBank file with a sequence.
@@ -167,6 +168,4 @@ def set_annotated_sequence(gb_file, annot_sequence):
         The annotated sequence that is put into the GenBank file.
     """
     set_annotation(gb_file, annot_sequence.annotation)
-    set_sequence(
-        gb_file, annot_sequence.sequence, annot_sequence.sequence_start
-    )
+    set_sequence(gb_file, annot_sequence.sequence, annot_sequence.sequence_start)

biotite/sequence/io/general.py

@@ -9,31 +9,27 @@ general sequence files.
 
 __name__ = "biotite.sequence.io"
 __author__ = "Patrick Kunzmann"
-__all__ = ["load_sequence", "save_sequence",
-           "load_sequences", "save_sequences"]
+__all__ = ["load_sequence", "save_sequence", "load_sequences", "save_sequences"]
 
-import itertools
 import os.path
-import io
 from collections import OrderedDict
 import numpy as np
-from ..seqtypes import NucleotideSequence, ProteinSequence
-from ..alphabet import Alphabet
+from biotite.sequence.seqtypes import NucleotideSequence
 
 
 def load_sequence(file_path):
     """
     Load a sequence from a sequence file without the need
     to manually instantiate a :class:`File` object.
-    
+
     Internally this function uses a :class:`File` object, based on the
     file extension.
-    
+
     Parameters
     ----------
     file_path : str
         The path to the sequence file.
-    
+
     Returns
     -------
     sequence : Sequence
@@ -42,11 +38,13 @@ def load_sequence(file_path):
     # We only need the suffix here
     filename, suffix = os.path.splitext(file_path)
     if suffix in [".fasta", ".fa", ".mpfa", ".fna", ".fsa"]:
-        from .fasta import FastaFile, get_sequence
+        from biotite.sequence.io.fasta import FastaFile, get_sequence
+
         file = FastaFile.read(file_path)
         return get_sequence(file)
     elif suffix in [".fastq", ".fq"]:
-        from .fastq import FastqFile
+        from biotite.sequence.io.fastq import FastqFile
+
         # Quality scores are irrelevant for this function
         # -> Offset is irrelevant
         file = FastqFile.read(file_path, offset="Sanger")
@@ -56,7 +54,8 @@ def load_sequence(file_path):
             break
         return sequence
     elif suffix in [".gb", ".gbk", ".gp"]:
-        from .genbank import GenBankFile, get_sequence
+        from biotite.sequence.io.genbank import GenBankFile, get_sequence
+
         format = "gp" if suffix == ".gp" else "gb"
         file = GenBankFile.read(file_path)
         return get_sequence(file, format)
@@ -68,10 +67,10 @@ def save_sequence(file_path, sequence):
     """
     Save a sequence into a sequence file without the need
     to manually instantiate a :class:`File` object.
-    
+
     Internally this function uses a :class:`File` object, based on the
     given file extension.
-    
+
     Parameters
     ----------
     file_path : str
@@ -82,12 +81,14 @@ def save_sequence(file_path, sequence):
     # We only need the suffix here
     filename, suffix = os.path.splitext(file_path)
     if suffix in [".fasta", ".fa", ".mpfa", ".fna", ".fsa"]:
-        from .fasta import FastaFile, set_sequence
+        from biotite.sequence.io.fasta import FastaFile, set_sequence
+
         file = FastaFile()
         set_sequence(file, sequence)
         file.write(file_path)
     elif suffix in [".fastq", ".fq"]:
-        from .fastq import FastqFile
+        from biotite.sequence.io.fastq import FastqFile
+
         # Quality scores are irrelevant for this function
         # -> Offset is irrelevant
         file = FastqFile(offset="Sanger")
@@ -96,7 +97,8 @@ def save_sequence(file_path, sequence):
         file["sequence"] = str(sequence), scores
         file.write(file_path)
     elif suffix in [".gb", ".gbk", ".gp"]:
-        from .genbank import GenBankFile, set_locus, set_sequence
+        from biotite.sequence.io.genbank import GenBankFile, set_locus, set_sequence
+
         file = GenBankFile()
         set_locus(file, "sequence", len(sequence))
         set_sequence(file, sequence)
@@ -109,37 +111,42 @@ def load_sequences(file_path):
     """
     Load multiple sequences from a sequence file without the need
     to manually instantiate a :class:`File` object.
-    
+
     Internally this function uses a :class:`File` object, based on the
     file extension.
-    
+
     Parameters
     ----------
     file_path : str
         The path to the sequence file.
-    
+
     Returns
     -------
     sequences : dict of (str, Sequence)
         The sequences in the file.
         This dictionary maps each header name to
-        the respective sequence. 
+        the respective sequence.
     """
     # We only need the suffix here
     filename, suffix = os.path.splitext(file_path)
     if suffix in [".fasta", ".fa", ".mpfa", ".fna", ".fsa"]:
-        from .fasta import FastaFile, get_sequences
+        from biotite.sequence.io.fasta import FastaFile, get_sequences
+
         file = FastaFile.read(file_path)
         return get_sequences(file)
     elif suffix in [".fastq", ".fq"]:
-        from .fastq import FastqFile
+        from biotite.sequence.io.fastq import FastqFile
+
         # Quality scores are irrelevant for this function
         # -> Offset is irrelevant
         file = FastqFile.read(file_path, offset="Sanger")
-        return {identifier : NucleotideSequence(seq_str)
-                for identifier, (seq_str, scores) in file.items()}
+        return {
+            identifier: NucleotideSequence(seq_str)
+            for identifier, (seq_str, scores) in file.items()
+        }
     elif suffix in [".gb", ".gbk", ".gp"]:
-        from .genbank import MultiFile, get_definition, get_sequence
+        from biotite.sequence.io.genbank import MultiFile, get_definition, get_sequence
+
         file = MultiFile.read(file_path)
         format = "gp" if suffix == ".gp" else "gb"
         sequences = OrderedDict()
@@ -154,10 +161,10 @@ def save_sequences(file_path, sequences):
     """
     Save multiple sequences into a sequence file without the need
     to manually instantiate a :class:`File` object.
-    
+
     Internally this function uses a :class:`File` object, based on the
     given file extension.
-    
+
     Parameters
     ----------
     file_path : str
@@ -169,12 +176,14 @@ def save_sequences(file_path, sequences):
     # We only need the suffix here
     filename, suffix = os.path.splitext(file_path)
     if suffix in [".fasta", ".fa", ".mpfa", ".fna", ".fsa"]:
-        from .fasta import FastaFile, set_sequences
+        from biotite.sequence.io.fasta import FastaFile, set_sequences
+
         file = FastaFile()
         set_sequences(file, sequences)
         file.write(file_path)
     elif suffix in [".fastq", ".fq"]:
-        from .fastq import FastqFile
+        from biotite.sequence.io.fastq import FastqFile
+
         # Quality scores are irrelevant for this function
         # -> Offset is irrelevant
         file = FastqFile(offset="Sanger")

biotite/sequence/io/gff/__init__.py

@@ -14,7 +14,7 @@ interface to this format, and high-level functions for extracting
    GFF 3 files. This means, that you cannot directly access the the
    parent or child of a feature.
    However, the ``Id`` and ``Name`` attributes are stored in the
-   qualifiers of the created :class:`Feature` objects. 
+   qualifiers of the created :class:`Feature` objects.
    Hence, it is possible to implement such a data structure from this
    information.
 """
@@ -22,5 +22,5 @@ interface to this format, and high-level functions for extracting
 __name__ = "biotite.sequence.io.gff"
 __author__ = "Patrick Kunzmann"
 
+from .convert import *
 from .file import *
-from .convert import *

biotite/sequence/io/gff/convert.py

@@ -6,7 +6,7 @@ __name__ = "biotite.sequence.io.gff"
 __author__ = "Patrick Kunzmann"
 __all__ = ["get_annotation", "set_annotation"]
 
-from ...annotation import Location, Feature, Annotation
+from biotite.sequence.annotation import Annotation, Feature, Location
 
 
 def get_annotation(gff_file):
@@ -22,12 +22,12 @@ def get_annotation(gff_file):
     Thus, for entries with the same ``ID``, the *type* and *attributes*
     are only parsed once and the locations are aggregated from each
     entry.
-    
+
     Parameters
     ----------
     gff_file : GFFFile
         The file tro extract the :class:`Annotation` object from.
-    
+
     Returns
     -------
     annotation : Annotation
@@ -45,9 +45,7 @@ def get_annotation(gff_file):
             # (beginning of the file)
             if current_key is not None:
                 # Beginning of new feature -> Save previous feature
-                annot.add_feature(
-                    Feature(current_key, current_locs, current_qual)
-                )
+                annot.add_feature(Feature(current_key, current_locs, current_qual))
             # Track new feature
             current_key = type
             current_locs = [Location(start, end, strand)]
@@ -61,15 +59,14 @@ def get_annotation(gff_file):
     return annot
 
 
-def set_annotation(gff_file, annotation,
-                   seqid=None, source=None, is_stranded=True):
+def set_annotation(gff_file, annotation, seqid=None, source=None, is_stranded=True):
     """
     Write an :class:`Annotation` object into a GFF3 file.
 
     Each feature will get one entry for each location it has.
     :class:`Feature` objects with multiple locations require the ``ID``
     qualifier in its :attr:`Feature.qual` attribute.
-    
+
     Parameters
     ----------
     gff_file : GFFFile
@@ -87,14 +84,13 @@ def set_annotation(gff_file, annotation,
     for feature in sorted(annotation):
         if len(feature.locs) > 1 and "ID" not in feature.qual:
             raise ValueError(
-                "The 'Id' qualifier is required "
-                "for features with multiple locations"
+                "The 'Id' qualifier is required " "for features with multiple locations"
             )
         ## seqid ##
         if seqid is not None and " " in seqid:
             raise ValueError("The 'seqid' must not contain whitespaces")
         ## source ##
-        #Nothing to be done
+        # Nothing to be done
         ## type ##
         type = feature.key
         ## strand ##
@@ -128,6 +124,5 @@ def set_annotation(gff_file, annotation,
             else:
                 phase = None
             gff_file.append(
-                seqid, source, type, start, end,
-                score, strand, phase, attributes
-            )
+                seqid, source, type, start, end, score, strand, phase, attributes
+            )

biotite/sequence/io/gff/file.py

@@ -6,19 +6,17 @@ __name__ = "biotite.sequence.io.gff"
 __author__ = "Patrick Kunzmann"
 __all__ = ["GFFFile"]
 
-import copy
 import string
-from urllib.parse import quote, unquote
 import warnings
-from ....file import TextFile, InvalidFileError
-from ...annotation import Location
-
+from urllib.parse import quote, unquote
+from biotite.file import InvalidFileError, TextFile
+from biotite.sequence.annotation import Location
 
 # All punctuation characters except
 # percent, semicolon, equals, ampersand, comma
-_NOT_QUOTED = "".join(
-    [char for char in string.punctuation if char not in "%;=&,"]
-) + " "
+_NOT_QUOTED = (
+    "".join([char for char in string.punctuation if char not in "%;=&,"]) + " "
+)
 
 
 class GFFFile(TextFile):
@@ -61,7 +59,7 @@ class GFFFile(TextFile):
     The content after the ``##FASTA`` directive is simply ignored.
     Please provide the sequence via a separate file or read the FASTA
     data directly via the :attr:`lines` attribute:
-    
+
     >>> import os.path
     >>> from io import StringIO
     >>> gff_file = GFFFile.read(os.path.join(path_to_sequences, "indexing_test.gff3"))
@@ -121,7 +119,7 @@ class GFFFile(TextFile):
     ##Example directive param1 param2
     SomeSeqID   Biotite CDS     1       99      .       +       0       ID=FeatureID;product=A protein
     """
-    
+
     def __init__(self):
         super().__init__()
         # Maps entry indices to line indices
@@ -132,18 +130,18 @@ class GFFFile(TextFile):
         self._has_fasta = None
         self._index_entries()
         self.append_directive("gff-version", "3")
-    
+
     @classmethod
     def read(cls, file):
         """
         Read a GFF3 file.
-        
+
         Parameters
         ----------
         file : file-like object or str
             The file to be read.
             Alternatively a file path can be supplied.
-        
+
         Returns
         -------
         file_object : GFFFile
@@ -152,18 +150,29 @@ class GFFFile(TextFile):
         file = super().read(file)
         file._index_entries()
         return file
-    
-    def insert(self, index, seqid, source, type, start, end,
-               score, strand, phase, attributes=None):
+
+    def insert(
+        self,
+        index,
+        seqid,
+        source,
+        type,
+        start,
+        end,
+        score,
+        strand,
+        phase,
+        attributes=None,
+    ):
         """
         Insert an entry at the given index.
-        
+
         Parameters
         ----------
         index : int
             Index where the entry is inserted.
             If the index is equal to the length of the file, the entry
-            is appended at the end of the file. 
+            is appended at the end of the file.
         seqid : str
             The ID of the reference sequence.
         source : str
@@ -184,22 +193,23 @@ class GFFFile(TextFile):
             Additional properties of the feature.
         """
         if index == len(self):
-            self.append(seqid, source, type, start, end,
-                        score, strand, phase, attributes)
+            self.append(
+                seqid, source, type, start, end, score, strand, phase, attributes
+            )
         else:
             line_index = self._entries[index]
             line = GFFFile._create_line(
-                seqid, source, type, start, end,
-                score, strand, phase, attributes
+                seqid, source, type, start, end, score, strand, phase, attributes
             )
             self.lines.insert(line_index, line)
             self._index_entries()
-    
-    def append(self, seqid, source, type, start, end,
-               score, strand, phase, attributes=None):
+
+    def append(
+        self, seqid, source, type, start, end, score, strand, phase, attributes=None
+    ):
         """
         Append an entry to the end of the file.
-        
+
         Parameters
         ----------
         seqid : str
@@ -232,11 +242,11 @@ class GFFFile(TextFile):
         self.lines.append(line)
         # Fast update of entry index by adding last line
         self._entries.append(len(self.lines) - 1)
-    
+
     def append_directive(self, directive, *args):
         """
         Append a directive line to the end of the file.
-        
+
         Parameters
         ----------
         directive : str
@@ -245,13 +255,13 @@ class GFFFile(TextFile):
             Optional parameters for the directive.
             Each argument is simply appended to the directive, separated
             by a single space character.
-        
+
         Raises
         ------
         NotImplementedError
             If the ``##FASTA`` directive is used, which is not
             supported.
-        
+
         Examples
         --------
 
@@ -262,17 +272,15 @@ class GFFFile(TextFile):
         ##Example directive param1 param2
         """
         if directive.startswith("FASTA"):
-            raise NotImplementedError(
-                "Adding FASTA information is not supported"
-            )
+            raise NotImplementedError("Adding FASTA information is not supported")
         directive_line = "##" + directive + " " + " ".join(args)
         self._directives.append((directive_line[2:], len(self.lines)))
         self.lines.append(directive_line)
-    
+
     def directives(self):
         """
         Get the directives in the file.
-        
+
         Returns
         -------
         directives : list of tuple(str, int)
@@ -283,7 +291,7 @@ class GFFFile(TextFile):
         """
         # Sort in line order
         return sorted(self._directives, key=lambda directive: directive[1])
-        
+
     def __setitem__(self, index, item):
         seqid, source, type, start, end, score, strand, phase, attrib = item
         line = GFFFile._create_line(
@@ -292,15 +300,13 @@ class GFFFile(TextFile):
         line_index = self._entries[index]
         self.lines[line_index] = line
 
-    
     def __getitem__(self, index):
-        if (index >= 0 and  index >= len(self)) or \
-           (index <  0 and -index >  len(self)):
-                raise IndexError(
-                    f"Index {index} is out of range for GFFFile with "
-                    f"{len(self)} entries"
-                )
-        
+        if (index >= 0 and index >= len(self)) or (index < 0 and -index > len(self)):
+            raise IndexError(
+                f"Index {index} is out of range for GFFFile with "
+                f"{len(self)} entries"
+            )
+
         line_index = self._entries[index]
         # Columns are tab separated
         s = self.lines[line_index].strip().split("\t")
@@ -324,15 +330,15 @@ class GFFFile(TextFile):
         attrib = GFFFile._parse_attributes(attrib)
 
         return seqid, source, type, start, end, score, strand, phase, attrib
-    
+
     def __delitem__(self, index):
         line_index = self._entries[index]
         del self.lines[line_index]
         self._index_entries()
-    
+
     def __len__(self):
         return len(self._entries)
-    
+
     def _index_entries(self):
         """
         Parse the file for comment and directive lines.
@@ -374,15 +380,12 @@ class GFFFile(TextFile):
         self._entries = self._entries[:entry_counter]
 
     @staticmethod
-    def _create_line(seqid, source, type, start, end,
-                     score, strand, phase, attributes):
+    def _create_line(seqid, source, type, start, end, score, strand, phase, attributes):
         """
         Create a line for a newly created entry.
         """
-        seqid = quote(seqid.strip(), safe=_NOT_QUOTED) \
-                if seqid is not None else "."
-        source = quote(source.strip(), safe=_NOT_QUOTED) \
-                 if source is not None else "."
+        seqid = quote(seqid.strip(), safe=_NOT_QUOTED) if seqid is not None else "."
+        source = quote(source.strip(), safe=_NOT_QUOTED) if source is not None else "."
         type = type.strip()
 
         # Perform checks
@@ -394,7 +397,7 @@ class GFFFile(TextFile):
             raise ValueError("'type' must not be empty")
         if seqid[0] == ">":
             raise ValueError("'seqid' must not start with '>'")
-        
+
         score = str(score) if score is not None else "."
         if strand == Location.Strand.FORWARD:
             strand = "+"
@@ -403,16 +406,31 @@ class GFFFile(TextFile):
         else:
             strand = "."
         phase = str(phase) if phase is not None else "."
-        attributes = ";".join(
-            [quote(key, safe=_NOT_QUOTED) + "=" + quote(val, safe=_NOT_QUOTED)
-             for key, val in attributes.items()]
-        ) if attributes is not None and len(attributes) > 0 else "."
+        attributes = (
+            ";".join(
+                [
+                    quote(key, safe=_NOT_QUOTED) + "=" + quote(val, safe=_NOT_QUOTED)
+                    for key, val in attributes.items()
+                ]
+            )
+            if attributes is not None and len(attributes) > 0
+            else "."
+        )
 
         return "\t".join(
-            [seqid, source, type, str(start), str(end),
-             str(score), strand, phase, attributes]
+            [
+                seqid,
+                source,
+                type,
+                str(start),
+                str(end),
+                str(score),
+                strand,
+                phase,
+                attributes,
+            ]
         )
-    
+
     @staticmethod
     def _parse_attributes(attributes):
         """
@@ -426,9 +444,7 @@ class GFFFile(TextFile):
         for entry in attrib_entries:
             compounds = entry.split("=")
             if len(compounds) != 2:
-                raise InvalidFileError(
-                    f"Attribute entry '{entry}' is invalid"
-                )
+                raise InvalidFileError(f"Attribute entry '{entry}' is invalid")
             key, val = compounds
             attrib_dict[unquote(key)] = unquote(val)
-        return attrib_dict
+        return attrib_dict

biotite/sequence/phylo/__init__.py

@@ -31,6 +31,6 @@ popular *UPGMA* (:func:`upgma()`) and *Neighbor-Joining*
 __name__ = "biotite.sequence.phylo"
 __author__ = "Patrick Kunzmann"
 
+from .nj import *
 from .tree import *
 from .upgma import *
-from .nj import *