pydna 5.5.4__py3-none-any.whl → 5.5.6__py3-none-any.whl

pydna/readers.py

@@ -6,8 +6,8 @@
 # as part of this package.
 
 """Provides two functions, read and read_primer."""
-from pydna.parsers import parse as _parse
-from pydna.primer import Primer as _Primer
+from pydna.parsers import parse
+from pydna.primer import Primer
 
 
 def read(data, ds=True):
@@ -39,13 +39,18 @@ def read(data, ds=True):
     """
 
     try:
-        (result,) = _parse(data, ds)
+        (result,) = parse(data, ds)
     except ValueError as err:
-        if "too many" in str(err):
-            print(f"More than one sequence found in data:\n({str(data)[:79]})")
-        elif "not enough" in str(err):
-            print(f"No sequence found in data:\n({str(data)[:79]})")
-        raise
+        msg = str(err)
+
+        if "too many" in msg:
+            raise ValueError(
+                f"More than one sequence found in data ({str(data)[:79]})"
+            ) from err
+        elif "not enough" in msg:
+            raise ValueError(f"No sequence found in data ({str(data)[:79]})") from err
+        else:  # pragma: no cover
+            raise err  # re-raises the same ValueError with original traceback
     return result
 
 
@@ -53,4 +58,4 @@ def read_primer(data):
     """Use this function to read a primer sequence from a string or a local file.
     The usage is similar to the :func:`parse_primer` function."""
 
-    return _Primer(read(data, ds=False))
+    return Primer(read(data, ds=False))

pydna/seq.py

@@ -2,56 +2,144 @@
 # -*- coding: utf-8 -*-
 
 """
-A subclass of the Biopython SeqRecord class.
+A subclass of Biopython Bio.Seq.Seq
 
 Has a number of extra methods and uses
 the :class:`pydna._pretty_str.pretty_str` class instread of str for a
 nicer output in the IPython shell.
 """
 
-# from pydna.codon import weights as _weights
 from Bio.SeqUtils.ProtParam import ProteinAnalysis
-from pydna.codon import rare_codons as _rare_codons
+from pydna.codon import rare_codons
 from pydna.codon import start as _start
 from pydna.codon import stop as _stop
 from pydna.codon import n_end as _n_end
-from seguid import lsseguid as _lsseguid
-from pydna.utils import rc as _rc
+from seguid import lsseguid
+from pydna.utils import rc
 
-from Bio.SeqUtils import seq3 as _seq3
-from Bio.SeqUtils import gc_fraction as _GC
-import re as _re
+from Bio.SeqUtils import seq3
+from Bio.SeqUtils import gc_fraction
+import re
 from Bio.Seq import Seq as _Seq
-from pydna._pretty import PrettyTable as _PrettyTable
+from pydna._pretty import PrettyTable
 
-from typing import List as _List, Optional as _Optional, Tuple as _Tuple
-
-# import logging as _logging
-
-# _module_logger = _logging.getLogger("pydna." + __name__)
+from typing import List, Optional, Tuple
 
 
 class Seq(_Seq):
     """docstring."""
 
+    # @property
+    # def full_sequence(self):
+    #     return self
+
+    # def translate(
+    #     self,
+    #     *args,
+    #     stop_symbol: str = "*",
+    #     to_stop: bool = False,
+    #     cds: bool = False,
+    #     gap: str = "-",
+    #     **kwargs,
+    # ) -> "ProteinSeq":
+    #     """Translate.."""
+    #     p = super().translate(
+    #         *args, stop_symbol=stop_symbol, to_stop=to_stop, cds=cds, gap=gap, **kwargs
+    #     )
+    #     return ProteinSeq(p._data)
+
     def translate(
         self,
-        *args,
-        stop_symbol: str = "*",
+        table: [str, int] = "Standard",
+        stop_symbol: [str] = "*",
         to_stop: bool = False,
         cds: bool = False,
         gap: str = "-",
-        **kwargs,
-    ) -> "ProteinSeq":
-        """Translate.."""
-        p = super().translate(
-            *args, stop_symbol=stop_symbol, to_stop=to_stop, cds=cds, gap=gap, **kwargs
+    ) -> _Seq:
+
+        # TODO: is this method needed?
+        """
+        Translate into protein.
+
+        The table argument is the name of a codon table (string). These names
+        can be for example "Standard" or "Alternative Yeast Nuclear" for the
+        yeast CUG clade where the CUG codon is translated as serine instead
+        of the standard leucine.
+
+        Over forty translation tables are available from the BioPython
+        Bio.Data.CodonTable module. Look at the keys of the dictionary
+        ´CodonTable.ambiguous_generic_by_name´.
+        These are based on tables in this file provided by NCBI:
+
+        https://ftp.ncbi.nlm.nih.gov/entrez/misc/data/gc.prt
+
+        Standard table
+
+          |  T      |  C      |  A      |  G      |
+        --+---------+---------+---------+---------+--
+        T | TTT F   | TCT S   | TAT Y   | TGT C   | T
+        T | TTC F   | TCC S   | TAC Y   | TGC C   | C
+        T | TTA L   | TCA S   | TAA Stop| TGA Stop| A
+        T | TTG L(s)| TCG S   | TAG Stop| TGG W   | G
+        --+---------+---------+---------+---------+--
+        C | CTT L   | CCT P   | CAT H   | CGT R   | T
+        C | CTC L   | CCC P   | CAC H   | CGC R   | C
+        C | CTA L   | CCA P   | CAA Q   | CGA R   | A
+        C | CTG L(s)| CCG P   | CAG Q   | CGG R   | G
+        --+---------+---------+---------+---------+--
+        A | ATT I   | ACT T   | AAT N   | AGT S   | T
+        A | ATC I   | ACC T   | AAC N   | AGC S   | C
+        A | ATA I   | ACA T   | AAA K   | AGA R   | A
+        A | ATG M(s)| ACG T   | AAG K   | AGG R   | G
+        --+---------+---------+---------+---------+--
+        G | GTT V   | GCT A   | GAT D   | GGT G   | T
+        G | GTC V   | GCC A   | GAC D   | GGC G   | C
+        G | GTA V   | GCA A   | GAA E   | GGA G   | A
+        G | GTG V   | GCG A   | GAG E   | GGG G   | G
+        --+---------+---------+---------+---------+--
+
+
+        Parameters
+        ----------
+        table : [str, int], optional
+            The default is "Standard". Can be a table id integer, see here for table
+            numbering https://www.ncbi.nlm.nih.gov/Taxonomy/Utils/wprintgc.cgi
+        stop_symbol : [str], optional
+            The default is "*". Single character string to indicate translation stop.
+        to_stop : bool, optional
+            The default is False. True means that translation terminates at the first
+              in frame stop codon. False translates to the end.
+        cds : bool, optional
+            The default is False. If True, checks that the sequence starts with a
+            valid alternative start codon sequence length is a multiple of three, and
+            that there is a single in frame stop codon at the end. If these tests fail,
+            an exception is raised.
+        gap : str, optional
+            The default is "-".
+
+        Returns
+        -------
+        Bio.Seq.Seq
+            A Biopython Seq object with the translated amino acid code.
+
+        """
+
+        p = _Seq(self._data).translate(
+            stop_symbol=stop_symbol, to_stop=to_stop, cds=cds, gap=gap
         )
         return ProteinSeq(p._data)
 
+    def transcribe(self) -> _Seq:
+        """
+        Transcribe a DNA sequence into RNA and return the RNA sequence
+        as a new Seq object.
+
+        """
+        return Seq(_Seq(self._data).transcribe()._data)
+
     def gc(self) -> float:
         """Return GC content."""
-        return round(_GC(self._data.upper().decode("ASCII")), 3)
+        return round(gc_fraction(self._data.upper().decode("ASCII")), 3)
 
     def cai(self, organism: str = "sce") -> float:
         """docstring."""
@@ -59,11 +147,11 @@ class Seq(_Seq):
 
         return _cai(self._data.upper().decode("ASCII"), organism=organism)
 
-    def rarecodons(self, organism: str = "sce") -> _List[slice]:
+    def rarecodons(self, organism: str = "sce") -> List[slice]:
         """docstring."""
-        rare = _rare_codons[organism]
+        rare = rare_codons[organism]
         s = self._data.upper().decode("ASCII")
-        slices: _List[slice] = []
+        slices: List[slice] = []
         for i in range(0, len(self) // 3):
             x, y = i * 3, i * 3 + 3
             trip = s[x:y]
@@ -71,19 +159,19 @@ class Seq(_Seq):
                 slices.append(slice(x, y, 1))
         return slices
 
-    def startcodon(self, organism: str = "sce") -> _Optional[float]:
+    def startcodon(self, organism: str = "sce") -> Optional[float]:
         """docstring."""
         return _start[organism].get(self._data.upper().decode("ASCII")[:3])
 
-    def stopcodon(self, organism: str = "sce") -> _Optional[float]:
+    def stopcodon(self, organism: str = "sce") -> Optional[float]:
         """docstring."""
         return _stop[organism].get(self._data.upper().decode("ASCII")[-3:])
 
-    def express(self, organism: str = "sce") -> _PrettyTable:
+    def express(self, organism: str = "sce") -> PrettyTable:
         """docstring."""
-        x = _PrettyTable(
+        x = PrettyTable(
             ["cds", "len", "cai", "gc", "sta", "stp", "n-end"]
-            + _rare_codons[organism]
+            + rare_codons[organism]
             + ["rare"]
         )
         val = []
@@ -98,12 +186,12 @@ class Seq(_Seq):
         val.append(self.startcodon())
         val.append(self.stopcodon())
         val.append(
-            _n_end[organism].get(_seq3(self[3:6].translate())),
+            _n_end[organism].get(seq3(self[3:6].translate())),
         )
         s = self._data.upper().decode("ASCII")
         trps = [s[i * 3 : i * 3 + 3] for i in range(0, len(s) // 3)]
         tot = 0
-        for cdn in _rare_codons[organism]:
+        for cdn in rare_codons[organism]:
             cnt = trps.count(cdn)
             tot += cnt
             val.append(cnt)
@@ -111,13 +199,13 @@ class Seq(_Seq):
         x.add_row(val)
         return x
 
-    def orfs2(self, minsize: int = 30) -> _List[str]:
+    def orfs2(self, minsize: int = 30) -> List[str]:
         """docstring."""
-        orf = _re.compile(
-            f"ATG(?:...){{{minsize},}}?(?:TAG|TAA|TGA)", flags=_re.IGNORECASE
+        orf = re.compile(
+            f"ATG(?:...){{{minsize},}}?(?:TAG|TAA|TGA)", flags=re.IGNORECASE
         )
         start = 0
-        matches: _List[slice] = []
+        matches: List[slice] = []
         s = self._data.decode("ASCII")
 
         while True:
@@ -129,7 +217,7 @@ class Seq(_Seq):
                 break
         return sorted([self[sl] for sl in matches], key=len, reverse=True)
 
-    def orfs(self, minsize: int = 100) -> _List[_Tuple[int, int]]:
+    def orfs(self, minsize: int = 100) -> List[Tuple[int, int]]:
         dna = self._data.decode("ASCII")
         from pydna.utils import three_frame_orfs
 
@@ -154,18 +242,20 @@ class Seq(_Seq):
         ----------
         .. [#] http://wiki.christophchamp.com/index.php/SEGUID
         """
-        return _lsseguid(self._data.decode("utf8").upper(), alphabet="{DNA-extended}")
+        return lsseguid(
+            self._data.decode("ascii").upper(), alphabet="{DNA-extended},AU"
+        )
 
-    def __getitem__(self, key):
-        result = super().__getitem__(key)
-        try:
-            result.__class__ = self.__class__
-        except TypeError:
-            pass
-        return result
+    # def __getitem__(self, key):
+    #     result = super().__getitem__(key)
+    #     try:
+    #         result.__class__ = self.__class__
+    #     except TypeError:
+    #         pass
+    #     return result
 
     def reverse_complement(self):
-        return self.__class__(_rc(self._data))
+        return self.__class__(rc(self._data))
 
     rc = reverse_complement
 
@@ -215,7 +305,7 @@ class ProteinSeq(_Seq):
         ----------
         .. [#] http://wiki.christophchamp.com/index.php/SEGUID
         """
-        return _lsseguid(
+        return lsseguid(
             self._data.decode("utf8").upper(), alphabet="{protein-extended}"
         )
 

pydna/seqrecord.py

@@ -14,34 +14,30 @@ the :class:`pydna._pretty_str.pretty_str` class instread of str for a
 nicer output in the IPython shell.
 """
 
+from Bio.SeqFeature import SeqFeature
+from pydna._pretty import pretty_str as ps
 
-from Bio.SeqFeature import SeqFeature as _SeqFeature
-from pydna._pretty import pretty_str as _pretty_str
+from pydna.seq import ProteinSeq
+from pydna.common_sub_strings import common_sub_strings
 
-from pydna.seq import ProteinSeq as _ProteinSeq
-from pydna.common_sub_strings import common_sub_strings as _common_sub_strings
+from Bio.Data.CodonTable import TranslationError
+from Bio.SeqRecord import SeqRecord
+from Bio.SeqFeature import SimpleLocation
+from Bio.SeqFeature import CompoundLocation
+from pydna.seq import Seq
+from pydna._pretty import PrettyTable
 
-from Bio.Data.CodonTable import TranslationError as _TranslationError
-from Bio.SeqRecord import SeqRecord as _SeqRecord
-from Bio.SeqFeature import SimpleLocation as _SimpleLocation
-from Bio.SeqFeature import CompoundLocation as _CompoundLocation
-from pydna.seq import Seq as _Seq
-from pydna._pretty import PrettyTable as _PrettyTable
-
-import re as _re
-import pickle as _pickle
-from copy import copy as _copy
+import re
+import pickle
+from copy import copy
 
 from pydna import _PydnaWarning
-from warnings import warn as _warn
+from warnings import warn
 
-# import logging as _logging
 import datetime
 
-# _module_logger = _logging.getLogger("pydna." + __name__)
-
 
-class SeqRecord(_SeqRecord):
+class SeqRecord(SeqRecord):
     """
     A subclass of the Biopython SeqRecord class.
 
@@ -62,7 +58,7 @@ class SeqRecord(_SeqRecord):
         letter_annotations=None,
     ):
         if isinstance(seq, str):
-            seq = _Seq(seq)
+            seq = Seq(seq)
         super().__init__(
             seq,
             id=id,
@@ -76,23 +72,21 @@ class SeqRecord(_SeqRecord):
         self._fix_attributes()
 
     def _fix_attributes(self):
-        self.id = _pretty_str(self.id)
-        self.name = _pretty_str(self.name)
-        self.description = _pretty_str(self.description)
+        self.id = ps(self.id)
+        self.name = ps(self.name)
+        self.description = ps(self.description)
 
         self.annotations.update({"molecule_type": "DNA"})
         self.map_target = None
 
         if not hasattr(self.seq, "transcribe"):
-            self.seq = _Seq(self.seq)
+            self.seq = Seq(self.seq)
 
         self.seq._data = b"".join(self.seq._data.split())  # remove whitespaces
-        self.annotations = {
-            _pretty_str(k): _pretty_str(v) for k, v in self.annotations.items()
-        }
+        self.annotations = {ps(k): ps(v) for k, v in self.annotations.items()}
 
     @classmethod
-    def from_Bio_SeqRecord(clc, sr: _SeqRecord):
+    def from_Bio_SeqRecord(clc, sr: SeqRecord):
         """Creates a pydnaSeqRecord from a Biopython SeqRecord."""
         # https://stackoverflow.com/questions/15404256/changing-the-\
         # class-of-a-python-object-casting
@@ -110,7 +104,7 @@ class SeqRecord(_SeqRecord):
         """Alias for name property."""
         if len(value) > 16:
             shortvalue = value[:16]
-            _warn(
+            warn(
                 ("locus property {} truncated" "to 16 chars {}").format(
                     value, shortvalue
                 ),
@@ -189,7 +183,7 @@ class SeqRecord(_SeqRecord):
         """
         try:
             self.seq.translate(table=table, cds=True)
-        except _TranslationError:
+        except TranslationError:
             return False
         else:
             return True
@@ -197,7 +191,7 @@ class SeqRecord(_SeqRecord):
     def translate(self):
         """docstring."""
         p = super().translate()
-        return ProteinSeqRecord(_ProteinSeq(p.seq))
+        return ProteinSeqRecord(ProteinSeq(p.seq))
 
     def add_colors_to_features_for_ape(self):
         """Assign colors to features.
@@ -296,19 +290,19 @@ class SeqRecord(_SeqRecord):
                 qualifiers["label"] = ["orf{}".format(y - x)]
 
         try:
-            location = _SimpleLocation(x, y, strand=strand)
+            location = SimpleLocation(x, y, strand=strand)
         except ValueError as err:
             if self.circular:
-                location = _CompoundLocation(
+                location = CompoundLocation(
                     (
-                        _SimpleLocation(x, self.seq.length, strand=strand),
-                        _SimpleLocation(0, y, strand=strand),
+                        SimpleLocation(x, len(self.seq), strand=strand),
+                        SimpleLocation(0, y, strand=strand),
                     )
                 )
             else:
                 raise err
 
-        sf = _SeqFeature(location, type=type_, qualifiers=qualifiers)
+        sf = SeqFeature(location, type=type_, qualifiers=qualifiers)
 
         self.features.append(sf)
 
@@ -333,7 +327,7 @@ class SeqRecord(_SeqRecord):
         |   0 | L:ft2         | --> | 2   | 4   |   2 | misc |  no  |
         +-----+---------------+-----+-----+-----+-----+------+------+
         """
-        x = _PrettyTable(
+        x = PrettyTable(
             ["Ft#", "Label or Note", "Dir", "Sta", "End", "Len", "type", "orf?"]
         )
         x.align["Ft#"] = "r"  # Left align
@@ -444,7 +438,7 @@ class SeqRecord(_SeqRecord):
         result = self.annotations.get("comment", "")
         if newcomment:
             self.annotations["comment"] = (result + "\n" + newcomment).strip()
-            result = _pretty_str(self.annotations["comment"])
+            result = ps(self.annotations["comment"])
         return result
 
     def datefunction():
@@ -481,18 +475,18 @@ class SeqRecord(_SeqRecord):
         """
         chksum = self.seq.seguid()
         oldcomment = self.annotations.get("comment", "")
-        oldstamp = _re.findall(r"..seguid=\S{27}", oldcomment)
+        oldstamp = re.findall(r"..seguid=\S{27}", oldcomment)
         if oldstamp and oldstamp[0] == chksum:
-            return _pretty_str(oldstamp[0])
+            return ps(oldstamp[0])
         elif oldstamp:
-            _warn(
+            warn(
                 f"Stamp change.\nNew: {chksum}\nOld: {oldstamp[0]}",
                 _PydnaWarning,
             )
         self.annotations["comment"] = (
             f"{oldcomment}\n" f"{tool} {chksum} {now()} {comment}"
         ).strip()
-        return _pretty_str(chksum)
+        return ps(chksum)
 
     def lcs(self, other, *args, limit=25, **kwargs):
         """Return the longest common substring between the sequence.
@@ -533,16 +527,16 @@ class SeqRecord(_SeqRecord):
         else:
             r = str(other.lower())
 
-        olaps = _common_sub_strings(str(self.seq).lower(), r, limit=limit or 25)
+        olaps = common_sub_strings(str(self.seq).lower(), r, limit=limit or 25)
 
         try:
             start_in_self, start_in_other, length = olaps.pop(0)
         except IndexError:
-            result = _SeqFeature()
+            result = SeqFeature()
         else:
             label = "sequence" if not hasattr(other, "name") else other.name
-            result = _SeqFeature(
-                _SimpleLocation(start_in_self, start_in_self + length, strand=1),
+            result = SeqFeature(
+                SimpleLocation(start_in_self, start_in_self + length, strand=1),
                 type=kwargs.get("type") or "read",
                 qualifiers={
                     "label": [kwargs.get("label") or label],
@@ -566,8 +560,8 @@ class SeqRecord(_SeqRecord):
         for slc in self.seq.rarecodons(organism):
             cdn = self.seq._data[slc].decode("ASCII")
             sfs.append(
-                _SeqFeature(
-                    _SimpleLocation(slc.start, slc.stop),
+                SeqFeature(
+                    SimpleLocation(slc.start, slc.stop),
                     type=f"rare_codon_{organism}",
                     qualifiers={"label": [cdn]},
                 )
@@ -588,7 +582,7 @@ class SeqRecord(_SeqRecord):
 
     def copy(self):
         """docstring."""
-        return _copy(self)
+        return copy(self)
 
     def __lt__(self, other):
         """docstring."""
@@ -625,11 +619,11 @@ class SeqRecord(_SeqRecord):
 
     def __str__(self):
         """docstring."""
-        return _pretty_str(super().__str__())
+        return ps(super().__str__())
 
     def __repr__(self):
         """docstring."""
-        return _pretty_str(super().__repr__())
+        return ps(super().__repr__())
 
     def __format__(self, format):
         """docstring."""
@@ -641,14 +635,14 @@ class SeqRecord(_SeqRecord):
             return text
 
         if format == "pydnafasta":
-            return _pretty_str(
+            return ps(
                 f">{self.id} {len(self)} bp {dict(((True, 'circular'), (False, 'linear')))[self.seq.circular]}\n{str(self.seq)}\n"
             )
         if format == "primer":
-            return _pretty_str(
+            return ps(
                 f">{self.id} {len(self)}-mer{removeprefix(self.description, self.name).strip()}\n{str(self.seq)}\n"
             )
-        return _pretty_str(super().__format__(format))
+        return ps(super().__format__(format))
 
     def __add__(self, other):
         """docstring."""
@@ -664,9 +658,7 @@ class SeqRecord(_SeqRecord):
 
     def __getitem__(self, index):
         """docstring."""
-        from pydna.utils import (
-            identifier_from_string as _identifier_from_string,
-        )  # TODO: clean this up
+        from pydna.utils import identifier_from_string
 
         answer = super().__getitem__(index)
         if len(answer) < 2:
@@ -678,8 +670,8 @@ class SeqRecord(_SeqRecord):
                 identifier = " ".join(sf.qualifiers["label"])
             elif "note" in sf.qualifiers:
                 identifier = " ".join(sf.qualifiers["note"])
-        answer.id = _identifier_from_string(identifier)[:16]
-        answer.name = _identifier_from_string(f"part_{self.name}")[:16]
+        answer.id = identifier_from_string(identifier)[:16]
+        answer.name = identifier_from_string(f"part_{self.name}")[:16]
         return answer
 
     def __bool__(self):
@@ -705,8 +697,8 @@ class SeqRecord(_SeqRecord):
         if not pth.suffix:
             pth = pth.with_suffix(".pickle")
         with open(pth, "wb") as f:
-            _pickle.dump(self, f, protocol=protocol)
-        return _pretty_str(pth)
+            pickle.dump(self, f, protocol=protocol)
+        return ps(pth)
 
 
 class ProteinSeqRecord(SeqRecord):
@@ -739,4 +731,4 @@ class ProteinSeqRecord(SeqRecord):
 
     def __format__(self, format):
         """docstring."""
-        return _pretty_str(_SeqRecord.__format__(self, format))
+        return ps(SeqRecord.__format__(self, format))

pydna/sequence_picker.py

@@ -6,16 +6,13 @@
 # as part of this package.
 
 from pydna.dseqrecord import Dseqrecord
-import os as _os
+import os
 
-# import logging as _logging
 from Bio.Blast import NCBIWWW
 from Bio.Blast import NCBIXML
 
-# _module_logger = _logging.getLogger("pydna." + __name__)
 
-
-email = _os.getenv("pydna_email")
+email = os.getenv("pydna_email")
 tool = "pydna"
 
 

pydna/sequence_regex.py

@@ -1,11 +1,11 @@
 # -*- coding: utf-8 -*-
-from pydna.dseqrecord import Dseqrecord as _Dseqrecord
+from pydna.dseqrecord import Dseqrecord
 import re
-from Bio.Data.IUPACData import ambiguous_dna_values as _ambiguous_dna_values
+from Bio.Data.IUPACData import ambiguous_dna_values
 
-ambiguous_only_dna_values = {**_ambiguous_dna_values}
+custom_ambiguous_only_dna_values = {**ambiguous_dna_values}
 for normal_base in "ACGT":
-    del ambiguous_only_dna_values[normal_base]
+    del custom_ambiguous_only_dna_values[normal_base]
 
 
 def compute_regex_site(site: str) -> str:
@@ -19,7 +19,7 @@ def compute_regex_site(site: str) -> str:
         The regex pattern.
     """
     upper_site = site.upper()
-    for k, v in ambiguous_only_dna_values.items():
+    for k, v in custom_ambiguous_only_dna_values.items():
         if len(v) > 1:
             upper_site = upper_site.replace(k, f"[{''.join(v)}]")
 
@@ -28,7 +28,7 @@ def compute_regex_site(site: str) -> str:
     return upper_site
 
 
-def dseqrecord_finditer(pattern: str, seq: _Dseqrecord) -> list[re.Match]:
+def dseqrecord_finditer(pattern: str, seq: Dseqrecord) -> list[re.Match]:
     """
     Finds all matches of a regex pattern in a Dseqrecord.