Reset repository and upload final project (part 6)

.gitattributes

@@ -63,3 +63,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 .venv_haddock/bin/python3.12 filter=lfs diff=lfs merge=lfs -text
 .venv_haddock/lib/python3.12/site-packages/Bio/Align/_pairwisealigner.cpython-312-darwin.so filter=lfs diff=lfs merge=lfs -text
 .venv_haddock/lib/python3.12/site-packages/Bio/Cluster/_cluster.cpython-312-darwin.so filter=lfs diff=lfs merge=lfs -text
+.venv_haddock/lib/python3.12/site-packages/freesasa.cpython-312-darwin.so filter=lfs diff=lfs merge=lfs -text
+.venv_haddock/lib/python3.12/site-packages/haddock/bin/haddock-restraints filter=lfs diff=lfs merge=lfs -text

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/HmmerIO/_base.py

@@ -0,0 +1,45 @@
+# Copyright 2012 by Wibowo Arindrarto.  All rights reserved.
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+"""Bio.SearchIO base classes for HMMER-related code."""
+
+from Bio.SearchIO._index import SearchIndexer
+
+
+class _BaseHmmerTextIndexer(SearchIndexer):
+    """Base indexer class for HMMER plain text output."""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self._preamble = b""
+
+    def get_raw(self, offset):
+        """Return the raw record from the file as a bytes string."""
+        handle = self._handle
+        qresult_raw = b""
+
+        # read header first
+        if not self._preamble:
+            handle.seek(0)
+            while True:
+                line = handle.readline()
+                if line.startswith(self.qresult_start):
+                    break
+                qresult_raw += line
+        else:
+            qresult_raw += self._preamble
+
+        # and read the qresult raw string
+        handle.seek(offset)
+        while True:
+            # preserve whitespace, don't use read_forward
+            line = handle.readline()
+            qresult_raw += line
+
+            # break when we've reached qresult end
+            if line.startswith(self.qresult_end) or not line:
+                break
+
+        return qresult_raw

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/HmmerIO/hmmer2_text.py

@@ -0,0 +1,377 @@
+# Copyright 2012 by Kai Blin.  All rights reserved.
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+"""Bio.SearchIO parser for HMMER 2 text output."""
+
+import re
+
+from Bio.SearchIO._model import Hit
+from Bio.SearchIO._model import HSP
+from Bio.SearchIO._model import HSPFragment
+from Bio.SearchIO._model import QueryResult
+from Bio.SearchIO._utils import read_forward
+
+from ._base import _BaseHmmerTextIndexer
+
+__all__ = ("Hmmer2TextParser", "Hmmer2TextIndexer")
+
+
+_HSP_ALIGN_LINE = re.compile(r"(\S+):\s+domain (\d+) of (\d+)")
+
+
+class _HitPlaceholder:
+    def createHit(self, hsp_list):
+        hit = Hit(hsp_list)
+        hit.id_ = self.id_
+        hit.evalue = self.evalue
+        hit.bitscore = self.bitscore
+        if self.description:
+            hit.description = self.description
+        hit.domain_obs_num = self.domain_obs_num
+        return hit
+
+
+class Hmmer2TextParser:
+    """Iterator for the HMMER 2.0 text output."""
+
+    def __init__(self, handle):
+        """Initialize the class."""
+        self.handle = handle
+        self.buf = []
+        self._meta = self.parse_preamble()
+
+    def __iter__(self):
+        """Iterate over Hmmer2TextParser, yields query results."""
+        for qresult in self.parse_qresult():
+            qresult.program = self._meta.get("program")
+            qresult.target = self._meta.get("target")
+            qresult.version = self._meta.get("version")
+            yield qresult
+
+    def read_next(self, rstrip=True):
+        """Return the next non-empty line, trailing whitespace removed."""
+        if len(self.buf) > 0:
+            return self.buf.pop()
+        self.line = self.handle.readline()
+        while self.line and rstrip and not self.line.strip():
+            self.line = self.handle.readline()
+        if self.line:
+            if rstrip:
+                self.line = self.line.rstrip()
+        return self.line
+
+    def push_back(self, line):
+        """Un-read a line that should not be parsed yet."""
+        self.buf.append(line)
+
+    def parse_key_value(self):
+        """Parse key-value pair separated by colon."""
+        key, value = self.line.split(":", 1)
+        return key.strip(), value.strip()
+
+    def parse_preamble(self):
+        """Parse HMMER2 preamble."""
+        meta = {}
+        state = "GENERIC"
+        while self.read_next():
+            if state == "GENERIC":
+                if self.line.startswith("hmm"):
+                    meta["program"] = self.line.split("-")[0].strip()
+                elif self.line.startswith("HMMER is"):
+                    continue
+                elif self.line.startswith("HMMER"):
+                    meta["version"] = self.line.split()[1]
+                elif self.line.count("-") == 36:
+                    state = "OPTIONS"
+                continue
+
+            assert state == "OPTIONS"
+            assert "program" in meta
+
+            if self.line.count("-") == 32:
+                break
+
+            key, value = self.parse_key_value()
+            if meta["program"] == "hmmsearch":
+                if key == "Sequence database":
+                    meta["target"] = value
+                    continue
+            elif meta["program"] == "hmmpfam":
+                if key == "HMM file":
+                    meta["target"] = value
+                    continue
+            meta[key] = value
+
+        return meta
+
+    def parse_qresult(self):
+        """Parse a HMMER2 query block."""
+        while self.read_next():
+            if not self.line.startswith("Query"):
+                return
+            _, id_ = self.parse_key_value()
+            self.qresult = QueryResult(id=id_)
+
+            description = None
+
+            while self.read_next() and not self.line.startswith("Scores"):
+                if self.line.startswith("Accession"):
+                    self.qresult.accession = self.parse_key_value()[1]
+                if self.line.startswith("Description"):
+                    description = self.parse_key_value()[1]
+
+            hit_placeholders = self.parse_hits()
+            if len(hit_placeholders) > 0:
+                self.parse_hsps(hit_placeholders)
+                self.parse_hsp_alignments()
+
+            while not self.line.startswith("Query"):
+                self.read_next()
+                if not self.line:
+                    break
+            self.buf.append(self.line)
+
+            if description is not None:
+                self.qresult.description = description
+            yield self.qresult
+
+    def parse_hits(self):
+        """Parse a HMMER2 hit block, beginning with the hit table."""
+        hit_placeholders = []
+        while self.read_next():
+            if self.line.startswith("Parsed"):
+                break
+            if self.line.find("no hits") > -1:
+                break
+
+            if (
+                self.line.startswith("Sequence")
+                or self.line.startswith("Model")
+                or self.line.startswith("-------- ")
+            ):
+                continue
+
+            fields = self.line.split()
+            id_ = fields.pop(0)
+            domain_obs_num = int(fields.pop())
+            evalue = float(fields.pop())
+            bitscore = float(fields.pop())
+            description = " ".join(fields).strip()
+
+            hit = _HitPlaceholder()
+            hit.id_ = id_
+            hit.evalue = evalue
+            hit.bitscore = bitscore
+            hit.description = description
+            hit.domain_obs_num = domain_obs_num
+            hit_placeholders.append(hit)
+
+        return hit_placeholders
+
+    def parse_hsps(self, hit_placeholders):
+        """Parse a HMMER2 hsp block, beginning with the hsp table."""
+        # HSPs may occur in different order than the hits
+        # so store Hit objects separately first
+        unordered_hits = {}
+        while self.read_next():
+            if (
+                self.line.startswith("Alignments")
+                or self.line.startswith("Histogram")
+                or self.line == "//"
+            ):
+                break
+            if (
+                self.line.startswith("Model")
+                or self.line.startswith("Sequence")
+                or self.line.startswith("--------")
+            ):
+                continue
+
+            (
+                id_,
+                domain,
+                seq_f,
+                seq_t,
+                seq_compl,
+                hmm_f,
+                hmm_t,
+                hmm_compl,
+                score,
+                evalue,
+            ) = self.line.split()
+
+            frag = HSPFragment(id_, self.qresult.id)
+            frag.molecule_type = "protein"
+            if self._meta["program"] == "hmmpfam":
+                frag.hit_start = int(hmm_f) - 1
+                frag.hit_end = int(hmm_t)
+                frag.query_start = int(seq_f) - 1
+                frag.query_end = int(seq_t)
+            elif self._meta["program"] == "hmmsearch":
+                frag.query_start = int(hmm_f) - 1
+                frag.query_end = int(hmm_t)
+                frag.hit_start = int(seq_f) - 1
+                frag.hit_end = int(seq_t)
+
+            hsp = HSP([frag])
+            hsp.evalue = float(evalue)
+            hsp.bitscore = float(score)
+            hsp.domain_index = int(domain.split("/")[0])
+            if self._meta["program"] == "hmmpfam":
+                hsp.hit_endtype = hmm_compl
+                hsp.query_endtype = seq_compl
+            elif self._meta["program"] == "hmmsearch":
+                hsp.query_endtype = hmm_compl
+                hsp.hit_endtype = seq_compl
+
+            if id_ not in unordered_hits:
+                placeholder = [p for p in hit_placeholders if p.id_ == id_][0]
+                hit = placeholder.createHit([hsp])
+                unordered_hits[id_] = hit
+            else:
+                hit = unordered_hits[id_]
+                hsp.hit_description = hit.description
+                hit.append(hsp)
+
+        # The placeholder list is in the correct order, so use that order for
+        # the Hit objects in the qresult
+        for p in hit_placeholders:
+            self.qresult.append(unordered_hits[p.id_])
+
+    def parse_hsp_alignments(self):
+        """Parse a HMMER2 HSP alignment block."""
+        if not self.line.startswith("Alignments"):
+            return
+
+        while self.read_next():
+            if self.line == "//" or self.line.startswith("Histogram"):
+                break
+
+            match = re.search(_HSP_ALIGN_LINE, self.line)
+            if match is None:
+                continue
+
+            id_ = match.group(1)
+            idx = int(match.group(2))
+            num = int(match.group(3))
+
+            hit = self.qresult[id_]
+            if hit.domain_obs_num != num:
+                continue
+
+            frag = hit[idx - 1][0]
+
+            hmmseq = ""
+            consensus = ""
+            otherseq = ""
+            structureseq = ""
+            pad = 0
+            while self.read_next() and self.line.startswith(" "):
+                # if there's structure information, parse that
+                if self.line[16:18] == "CS":
+                    structureseq += self.line[19:].strip()
+
+                    if not self.read_next():
+                        break
+
+                # skip the *-> start marker if it exists
+                if self.line[19:22] == "*->":
+                    seq = self.line[22:]
+                    pad = 3
+                else:
+                    seq = self.line[19:]
+                    pad = 0
+
+                hmmseq += seq
+                line_len = len(seq)
+                if not self.read_next(rstrip=False):
+                    break
+                consensus += self.line[19 + pad : 19 + pad + line_len]
+                # If there's no consensus sequence, hmmer2 doesn't
+                # bother to put spaces here, so add extra padding
+                extra_padding = len(hmmseq) - len(consensus)
+                consensus += " " * extra_padding
+
+                if not self.read_next():
+                    break
+
+                # if we have a line break in the end marker, we get a
+                # whitespace-only otherseq line, making split()[0] return
+                # the end coordinate. That'll be a -, which is a valid character
+                # in the sequence, meaning we can't just strip it.
+                parts = self.line[19:].split()
+                if len(parts) == 2:
+                    otherseq += self.line[19:].split()[0].strip()
+
+            self.push_back(self.line)
+
+            # get rid of the end marker
+            if hmmseq.endswith("<-*"):
+                hmmseq = hmmseq[:-3]
+                consensus = consensus[:-3]
+
+            # add similarity sequence to annotation
+            frag.aln_annotation["similarity"] = consensus
+
+            # if there's structure information, add it to the fragment
+            if structureseq:
+                frag.aln_annotation["CS"] = structureseq
+
+            if self._meta["program"] == "hmmpfam":
+                frag.hit = hmmseq
+                frag.query = otherseq
+            else:
+                frag.hit = otherseq
+                frag.query = hmmseq
+
+
+class Hmmer2TextIndexer(_BaseHmmerTextIndexer):
+    """Indexer for hmmer2-text format."""
+
+    _parser = Hmmer2TextParser
+    qresult_start = b"Query"
+    # qresults_ends for hmmpfam and hmmsearch
+    # need to anticipate both since hmmsearch have different query end mark
+    qresult_end = b"//"
+
+    def __iter__(self):
+        """Iterate over Hmmer2TextIndexer; yields query results' key, offsets, 0."""
+        handle = self._handle
+        handle.seek(0)
+        start_offset = handle.tell()
+        regex_id = re.compile(rb"Query\s*(?:sequence|HMM)?:\s*(.*)")
+
+        # determine flag for hmmsearch
+        is_hmmsearch = False
+        line = read_forward(handle)
+        if line.startswith(b"hmmsearch"):
+            is_hmmsearch = True
+
+        while True:
+            end_offset = handle.tell()
+
+            if line.startswith(self.qresult_start):
+                regx = re.search(regex_id, line)
+                qresult_key = regx.group(1).strip()
+                # qresult start offset is the offset of this line
+                # (starts with the start mark)
+                start_offset = end_offset - len(line)
+            elif line.startswith(self.qresult_end):
+                yield qresult_key.decode(), start_offset, 0
+                start_offset = end_offset
+            elif not line:
+                # HACK: since hmmsearch can only have one query result
+                if is_hmmsearch:
+                    yield qresult_key.decode(), start_offset, 0
+                break
+
+            line = read_forward(handle)
+
+
+# if not used as a module, run the doctest
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/HmmerIO/hmmer3_domtab.py

@@ -0,0 +1,378 @@
+# Copyright 2012 by Wibowo Arindrarto.  All rights reserved.
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+"""Bio.SearchIO parser for HMMER domain table output format."""
+
+from itertools import chain
+
+from Bio.SearchIO._model import Hit
+from Bio.SearchIO._model import HSP
+from Bio.SearchIO._model import HSPFragment
+from Bio.SearchIO._model import QueryResult
+
+from .hmmer3_tab import Hmmer3TabIndexer
+from .hmmer3_tab import Hmmer3TabParser
+
+__all__ = (
+    "Hmmer3DomtabHmmhitParser",
+    "Hmmer3DomtabHmmqueryParser",
+    "Hmmer3DomtabHmmhitIndexer",
+    "Hmmer3DomtabHmmqueryIndexer",
+    "Hmmer3DomtabHmmhitWriter",
+    "Hmmer3DomtabHmmqueryWriter",
+)
+
+
+class Hmmer3DomtabParser(Hmmer3TabParser):
+    """Base hmmer3-domtab iterator."""
+
+    def _parse_row(self):
+        """Return a dictionary of parsed row values (PRIVATE)."""
+        assert self.line
+        cols = [x for x in self.line.strip().split(" ") if x]
+        # if len(cols) > 23, we have extra description columns
+        # combine them all into one string in the 19th column
+        if len(cols) > 23:
+            cols[22] = " ".join(cols[22:])
+        elif len(cols) < 23:
+            cols.append("")
+            assert len(cols) == 23
+
+        # assign parsed column data into qresult, hit, and hsp dicts
+        qresult = {}
+        qresult["id"] = cols[3]  # query name
+        qresult["accession"] = cols[4]  # query accession
+        qresult["seq_len"] = int(cols[5])  # qlen
+        hit = {}
+        hit["id"] = cols[0]  # target name
+        hit["accession"] = cols[1]  # target accession
+        hit["seq_len"] = int(cols[2])  # tlen
+        hit["evalue"] = float(cols[6])  # evalue
+        hit["bitscore"] = float(cols[7])  # score
+        hit["bias"] = float(cols[8])  # bias
+        hit["description"] = cols[22]  # description of target
+        hsp = {}
+        hsp["domain_index"] = int(cols[9])  # # (domain number)
+        # not parsing cols[10] since it's basically len(hit)
+        hsp["evalue_cond"] = float(cols[11])  # c-evalue
+        hsp["evalue"] = float(cols[12])  # i-evalue
+        hsp["bitscore"] = float(cols[13])  # score
+        hsp["bias"] = float(cols[14])  # bias
+        hsp["env_start"] = int(cols[19]) - 1  # env from
+        hsp["env_end"] = int(cols[20])  # env to
+        hsp["acc_avg"] = float(cols[21])  # acc
+        frag = {}
+        # strand is always 0, since HMMER now only handles protein
+        frag["hit_strand"] = frag["query_strand"] = 0
+        frag["hit_start"] = int(cols[15]) - 1  # hmm from
+        frag["hit_end"] = int(cols[16])  # hmm to
+        frag["query_start"] = int(cols[17]) - 1  # ali from
+        frag["query_end"] = int(cols[18])  # ali to
+        # HMMER results are always protein
+        frag["molecule_type"] = "protein"
+
+        # switch hmm<-->ali coordinates if hmm is not hit
+        if not self.hmm_as_hit:
+            frag["hit_end"], frag["query_end"] = (frag["query_end"], frag["hit_end"])
+            frag["hit_start"], frag["query_start"] = (
+                frag["query_start"],
+                frag["hit_start"],
+            )
+
+        return {"qresult": qresult, "hit": hit, "hsp": hsp, "frag": frag}
+
+    def _parse_qresult(self):
+        """Return QueryResult objects (PRIVATE)."""
+        # state values, determines what to do for each line
+        state_EOF = 0
+        state_QRES_NEW = 1
+        state_QRES_SAME = 3
+        state_HIT_NEW = 2
+        state_HIT_SAME = 4
+        # dummies for initial states
+        qres_state = None
+        hit_state = None
+        file_state = None
+        # dummies for initial id caches
+        prev_qid = None
+        prev_hid = None
+        # dummies for initial parsed value containers
+        cur, prev = None, None
+        hit_list, hsp_list = [], []
+        cur_qid = None
+        cur_hid = None
+        while True:
+            # store previous line's parsed values, for every line after the 1st
+            if cur is not None:
+                prev = cur
+                prev_qid = cur_qid
+                prev_hid = cur_hid
+            # only parse the line if it's not EOF
+            if self.line and not self.line.startswith("#"):
+                cur = self._parse_row()
+                cur_qid = cur["qresult"]["id"]
+                cur_hid = cur["hit"]["id"]
+            else:
+                file_state = state_EOF
+                # mock ID values since the line is empty
+                cur_qid, cur_hid = None, None
+
+            # get the state of hit and qresult
+            if prev_qid != cur_qid:
+                qres_state = state_QRES_NEW
+            else:
+                qres_state = state_QRES_SAME
+            # new hits are hits with different ids or hits in a new qresult
+            if prev_hid != cur_hid or qres_state == state_QRES_NEW:
+                hit_state = state_HIT_NEW
+            else:
+                hit_state = state_HIT_SAME
+
+            # start creating objects after the first line (i.e. prev is filled)
+            if prev is not None:
+                # each line is basically an HSP with one HSPFragment
+                frag = HSPFragment(prev_hid, prev_qid)
+                for attr, value in prev["frag"].items():
+                    setattr(frag, attr, value)
+                hsp = HSP([frag])
+                for attr, value in prev["hsp"].items():
+                    setattr(hsp, attr, value)
+                hsp_list.append(hsp)
+
+                # create hit object when we've finished parsing all its hsps
+                # i.e. when hit state is state_HIT_NEW
+                if hit_state == state_HIT_NEW:
+                    hit = Hit(hsp_list)
+                    for attr, value in prev["hit"].items():
+                        setattr(hit, attr, value)
+                    hit_list.append(hit)
+                    hsp_list = []
+
+                # create qresult and yield if we're at a new qresult or EOF
+                if qres_state == state_QRES_NEW or file_state == state_EOF:
+                    qresult = QueryResult(hit_list, prev_qid)
+                    for attr, value in prev["qresult"].items():
+                        setattr(qresult, attr, value)
+                    yield qresult
+                    # if current line is EOF, break
+                    if file_state == state_EOF:
+                        break
+                    hit_list = []
+
+            self.line = self.handle.readline()
+
+
+class Hmmer3DomtabHmmhitParser(Hmmer3DomtabParser):
+    """HMMER domain table parser using hit coordinates.
+
+    Parser for the HMMER domain table format that assumes HMM profile
+    coordinates are hit coordinates.
+    """
+
+    hmm_as_hit = True
+
+
+class Hmmer3DomtabHmmqueryParser(Hmmer3DomtabParser):
+    """HMMER domain table parser using query coordinates.
+
+    Parser for the HMMER domain table format that assumes HMM profile
+    coordinates are query coordinates.
+    """
+
+    hmm_as_hit = False
+
+
+class Hmmer3DomtabHmmhitIndexer(Hmmer3TabIndexer):
+    """HMMER domain table indexer using hit coordinates.
+
+    Indexer class for HMMER domain table output that assumes HMM profile
+    coordinates are hit coordinates.
+    """
+
+    _parser = Hmmer3DomtabHmmhitParser
+    _query_id_idx = 3
+
+
+class Hmmer3DomtabHmmqueryIndexer(Hmmer3TabIndexer):
+    """HMMER domain table indexer using query coordinates.
+
+    Indexer class for HMMER domain table output that assumes HMM profile
+    coordinates are query coordinates.
+    """
+
+    _parser = Hmmer3DomtabHmmqueryParser
+    _query_id_idx = 3
+
+
+class Hmmer3DomtabHmmhitWriter:
+    """HMMER domain table writer using hit coordinates.
+
+    Writer for hmmer3-domtab output format which writes hit coordinates
+    as HMM profile coordinates.
+    """
+
+    hmm_as_hit = True
+
+    def __init__(self, handle):
+        """Initialize the class."""
+        self.handle = handle
+
+    def write_file(self, qresults):
+        """Write to the handle.
+
+        Returns a tuple of how many QueryResult, Hit, and HSP objects were written.
+
+        """
+        handle = self.handle
+        qresult_counter, hit_counter, hsp_counter, frag_counter = 0, 0, 0, 0
+
+        try:
+            first_qresult = next(qresults)
+        except StopIteration:
+            handle.write(self._build_header())
+        else:
+            # write header
+            handle.write(self._build_header(first_qresult))
+            # and then the qresults
+            for qresult in chain([first_qresult], qresults):
+                if qresult:
+                    handle.write(self._build_row(qresult))
+                    qresult_counter += 1
+                    hit_counter += len(qresult)
+                    hsp_counter += sum(len(hit) for hit in qresult)
+                    frag_counter += sum(len(hit.fragments) for hit in qresult)
+
+        return qresult_counter, hit_counter, hsp_counter, frag_counter
+
+    def _build_header(self, first_qresult=None):
+        """Return the header string of a domain HMMER table output (PRIVATE)."""
+        # calculate whitespace required
+        # adapted from HMMER's source: src/p7_tophits.c#L1157
+        if first_qresult:
+            # qnamew = max(20, len(first_qresult.id))
+            qnamew = 20
+            tnamew = max(20, len(first_qresult[0].id))
+            try:
+                qaccw = max(10, len(first_qresult.acc))
+                taccw = max(10, len(first_qresult[0].acc))
+            except AttributeError:
+                qaccw, taccw = 10, 10
+        else:
+            qnamew, tnamew, qaccw, taccw = 20, 20, 10, 10
+        # Turn black code style off
+        # fmt: off
+        header = ("#%*s %22s %40s %11s %11s %11s\n"
+                  % (tnamew + qnamew - 1 + 15 + taccw + qaccw, "", "--- full sequence ---",
+                     "-------------- this domain -------------", "hmm coord",
+                     "ali coord", "env coord"))
+        header += ("#%-*s %-*s %5s %-*s %-*s %5s %9s %6s %5s %3s %3s %9s "
+                   "%9s %6s %5s %5s %5s %5s %5s %5s %5s %4s %s\n"
+                   % (tnamew - 1,
+                      " target name", taccw, "accession", "tlen", qnamew,
+                      "query name", qaccw, "accession", "qlen", "E-value", "score",
+                      "bias", "#", "of", "c-Evalue", "i-Evalue", "score", "bias",
+                      "from", "to", "from", "to", "from", "to", "acc",
+                      "description of target"))
+        header += ("#%*s %*s %5s %*s %*s %5s %9s %6s %5s %3s %3s %9s %9s "
+                   "%6s %5s %5s %5s %5s %5s %5s %5s %4s %s\n"
+                   % (tnamew - 1,
+                      "-------------------", taccw, "----------", "-----",
+                      qnamew, "--------------------", qaccw, "----------",
+                      "-----", "---------", "------", "-----", "---", "---",
+                      "---------", "---------", "------", "-----", "-----", "-----",
+                      "-----", "-----", "-----", "-----", "----",
+                      "---------------------"))
+        # Turn black code style on
+        # fmt: on
+        return header
+
+    def _build_row(self, qresult):
+        """Return a string or one row or more of the QueryResult object (PRIVATE)."""
+        rows = ""
+
+        # calculate whitespace required
+        # adapted from HMMER's source: src/p7_tophits.c#L1083
+        qnamew = max(20, len(qresult.id))
+        tnamew = max(20, len(qresult[0].id))
+        try:
+            qaccw = max(10, len(qresult.accession))
+            taccw = max(10, len(qresult[0].accession))
+            qresult_acc = qresult.accession
+        except AttributeError:
+            qaccw, taccw = 10, 10
+            qresult_acc = "-"
+
+        for hit in qresult:
+            # try to get hit accession
+            try:
+                hit_acc = hit.accession
+            except AttributeError:
+                hit_acc = "-"
+
+            for hsp in hit.hsps:
+                if self.hmm_as_hit:
+                    hmm_to = hsp.hit_end
+                    hmm_from = hsp.hit_start + 1
+                    ali_to = hsp.query_end
+                    ali_from = hsp.query_start + 1
+                else:
+                    hmm_to = hsp.query_end
+                    hmm_from = hsp.query_start + 1
+                    ali_to = hsp.hit_end
+                    ali_from = hsp.hit_start + 1
+
+                rows += (
+                    "%-*s %-*s %5d %-*s %-*s %5d %9.2g %6.1f %5.1f %3d"
+                    " %3d %9.2g %9.2g %6.1f %5.1f %5d %5d %5ld %5ld"
+                    " %5d %5d %4.2f %s\n"
+                    % (
+                        tnamew,
+                        hit.id,
+                        taccw,
+                        hit_acc,
+                        hit.seq_len,
+                        qnamew,
+                        qresult.id,
+                        qaccw,
+                        qresult_acc,
+                        qresult.seq_len,
+                        hit.evalue,
+                        hit.bitscore,
+                        hit.bias,
+                        hsp.domain_index,
+                        len(hit.hsps),
+                        hsp.evalue_cond,
+                        hsp.evalue,
+                        hsp.bitscore,
+                        hsp.bias,
+                        hmm_from,
+                        hmm_to,
+                        ali_from,
+                        ali_to,
+                        hsp.env_start + 1,
+                        hsp.env_end,
+                        hsp.acc_avg,
+                        hit.description,
+                    )
+                )
+
+        return rows
+
+
+class Hmmer3DomtabHmmqueryWriter(Hmmer3DomtabHmmhitWriter):
+    """HMMER domain table writer using query coordinates.
+
+    Writer for hmmer3-domtab output format which writes query coordinates
+    as HMM profile coordinates.
+    """
+
+    hmm_as_hit = False
+
+
+# if not used as a module, run the doctest
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/HmmerIO/hmmer3_tab.py

@@ -0,0 +1,337 @@
+# Copyright 2012 by Wibowo Arindrarto.  All rights reserved.
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+"""Bio.SearchIO parser for HMMER table output format."""
+
+from itertools import chain
+
+from Bio.SearchIO._index import SearchIndexer
+from Bio.SearchIO._model import Hit
+from Bio.SearchIO._model import HSP
+from Bio.SearchIO._model import HSPFragment
+from Bio.SearchIO._model import QueryResult
+
+__all__ = ("Hmmer3TabParser", "Hmmer3TabIndexer", "Hmmer3TabWriter")
+
+
+class Hmmer3TabParser:
+    """Parser for the HMMER table format."""
+
+    def __init__(self, handle):
+        """Initialize the class."""
+        self.handle = handle
+        self.line = self.handle.readline()
+
+    def __iter__(self):
+        """Iterate over Hmmer3TabParser, yields query results."""
+        header_mark = "#"
+        # read through the header if it exists
+        while self.line.startswith(header_mark):
+            self.line = self.handle.readline()
+        # if we have result rows, parse it
+        if self.line:
+            yield from self._parse_qresult()
+
+    def _parse_row(self):
+        """Return a dictionary of parsed row values (PRIVATE)."""
+        cols = [x for x in self.line.strip().split(" ") if x]
+        if len(cols) < 18:
+            raise ValueError("Less columns than expected, only %i" % len(cols))
+        # if len(cols) > 19, we have extra description columns
+        # combine them all into one string in the 19th column
+        cols[18] = " ".join(cols[18:])
+
+        # assign parsed column data into qresult, hit, and hsp dicts
+        qresult = {}
+        qresult["id"] = cols[2]  # query name
+        qresult["accession"] = cols[3]  # query accession
+        hit = {}
+        hit["id"] = cols[0]  # target name
+        hit["accession"] = cols[1]  # target accession
+        hit["evalue"] = float(cols[4])  # evalue (full sequence)
+        hit["bitscore"] = float(cols[5])  # score (full sequence)
+        hit["bias"] = float(cols[6])  # bias (full sequence)
+        hit["domain_exp_num"] = float(cols[10])  # exp
+        hit["region_num"] = int(cols[11])  # reg
+        hit["cluster_num"] = int(cols[12])  # clu
+        hit["overlap_num"] = int(cols[13])  # ov
+        hit["env_num"] = int(cols[14])  # env
+        hit["domain_obs_num"] = int(cols[15])  # dom
+        hit["domain_reported_num"] = int(cols[16])  # rep
+        hit["domain_included_num"] = int(cols[17])  # inc
+        hit["description"] = cols[18]  # description of target
+        hsp = {}
+        hsp["evalue"] = float(cols[7])  # evalue (best 1 domain)
+        hsp["bitscore"] = float(cols[8])  # score (best 1 domain)
+        hsp["bias"] = float(cols[9])  # bias (best 1 domain)
+        # strand is always 0, since HMMER now only handles protein
+        frag = {}
+        frag["hit_strand"] = frag["query_strand"] = 0
+        frag["molecule_type"] = "protein"
+
+        return {"qresult": qresult, "hit": hit, "hsp": hsp, "frag": frag}
+
+    def _parse_qresult(self):
+        """Return QueryResult objects (PRIVATE)."""
+        # state values, determines what to do for each line
+        state_EOF = 0
+        state_QRES_NEW = 1
+        state_QRES_SAME = 3
+        # initial value dummies
+        qres_state = None
+        file_state = None
+        prev_qid = None
+        cur, prev = None, None
+        # container for Hit objects, used to create QueryResult
+        hit_list = []
+        cur_qid = None
+        while True:
+            # store previous line's parsed values for all lines after the first
+            if cur is not None:
+                prev = cur
+                prev_qid = cur_qid
+            # only parse the result row if it's not EOF
+            # NOTE: we are not parsing the extra '#' lines appended to the end
+            # of hmmer31b1 tabular results since storing them in qresult
+            # objects means we can not do a single-pass parsing
+            if self.line and not self.line.startswith("#"):
+                cur = self._parse_row()
+                cur_qid = cur["qresult"]["id"]
+            else:
+                file_state = state_EOF
+                # mock value for cur_qid, since we have nothing to parse
+                cur_qid = None
+
+            if prev_qid != cur_qid:
+                qres_state = state_QRES_NEW
+            else:
+                qres_state = state_QRES_SAME
+
+            if prev is not None:
+                # since domain tab formats only have 1 Hit per line
+                # we always create HSPFragment, HSP, and Hit per line
+                prev_hid = prev["hit"]["id"]
+
+                # create fragment and HSP and set their attributes
+                frag = HSPFragment(prev_hid, prev_qid)
+                for attr, value in prev["frag"].items():
+                    setattr(frag, attr, value)
+                hsp = HSP([frag])
+                for attr, value in prev["hsp"].items():
+                    setattr(hsp, attr, value)
+
+                # create Hit and set its attributes
+                hit = Hit([hsp])
+                for attr, value in prev["hit"].items():
+                    setattr(hit, attr, value)
+                hit_list.append(hit)
+
+                # create qresult and yield if we're at a new qresult or at EOF
+                if qres_state == state_QRES_NEW or file_state == state_EOF:
+                    qresult = QueryResult(hit_list, prev_qid)
+                    for attr, value in prev["qresult"].items():
+                        setattr(qresult, attr, value)
+                    yield qresult
+                    # if we're at EOF, break
+                    if file_state == state_EOF:
+                        break
+                    hit_list = []
+
+            self.line = self.handle.readline()
+
+
+class Hmmer3TabIndexer(SearchIndexer):
+    """Indexer class for HMMER table output."""
+
+    _parser = Hmmer3TabParser
+    # denotes column location for query identifier
+    _query_id_idx = 2
+
+    def __iter__(self):
+        """Iterate over the file handle; yields key, start offset, and length."""
+        handle = self._handle
+        handle.seek(0)
+        query_id_idx = self._query_id_idx
+        qresult_key = None
+        header_mark = b"#"
+        split_mark = b" "
+        # set line with initial mock value, to emulate header
+        line = header_mark
+
+        # read through header
+        while line.startswith(header_mark):
+            start_offset = handle.tell()
+            line = handle.readline()
+
+        # and index the qresults
+        while True:
+            end_offset = handle.tell()
+
+            if not line:
+                break
+
+            cols = [x for x in line.strip().split(split_mark) if x]
+            if qresult_key is None:
+                qresult_key = cols[query_id_idx]
+            else:
+                curr_key = cols[query_id_idx]
+
+                if curr_key != qresult_key:
+                    adj_end = end_offset - len(line)
+                    yield (qresult_key.decode(), start_offset, adj_end - start_offset)
+                    qresult_key = curr_key
+                    start_offset = adj_end
+
+            line = handle.readline()
+            if not line:
+                yield (qresult_key.decode(), start_offset, end_offset - start_offset)
+                break
+
+    def get_raw(self, offset):
+        """Return the raw bytes string of a QueryResult object from the given offset."""
+        handle = self._handle
+        handle.seek(offset)
+        query_id_idx = self._query_id_idx
+        qresult_key = None
+        qresult_raw = b""
+        split_mark = b" "
+
+        while True:
+            line = handle.readline()
+            if not line:
+                break
+            cols = [x for x in line.strip().split(split_mark) if x]
+            if qresult_key is None:
+                qresult_key = cols[query_id_idx]
+            else:
+                curr_key = cols[query_id_idx]
+                if curr_key != qresult_key:
+                    break
+            qresult_raw += line
+
+        return qresult_raw
+
+
+class Hmmer3TabWriter:
+    """Writer for hmmer3-tab output format."""
+
+    def __init__(self, handle):
+        """Initialize the class."""
+        self.handle = handle
+
+    def write_file(self, qresults):
+        """Write to the handle.
+
+        Returns a tuple of how many QueryResult, Hit, and HSP objects were written.
+
+        """
+        handle = self.handle
+        qresult_counter, hit_counter, hsp_counter, frag_counter = 0, 0, 0, 0
+
+        try:
+            first_qresult = next(qresults)
+        except StopIteration:
+            handle.write(self._build_header())
+        else:
+            # write header
+            handle.write(self._build_header(first_qresult))
+            # and then the qresults
+            for qresult in chain([first_qresult], qresults):
+                if qresult:
+                    handle.write(self._build_row(qresult))
+                    qresult_counter += 1
+                    hit_counter += len(qresult)
+                    hsp_counter += sum(len(hit) for hit in qresult)
+                    frag_counter += sum(len(hit.fragments) for hit in qresult)
+
+        return qresult_counter, hit_counter, hsp_counter, frag_counter
+
+    def _build_header(self, first_qresult=None):
+        """Return the header string of a HMMER table output (PRIVATE)."""
+        # calculate whitespace required
+        # adapted from HMMER's source: src/p7_tophits.c#L1083
+        if first_qresult is not None:
+            # qnamew = max(20, len(first_qresult.id))
+            qnamew = 20  # why doesn't the above work?
+            tnamew = max(20, len(first_qresult[0].id))
+            qaccw = max(10, len(first_qresult.accession))
+            taccw = max(10, len(first_qresult[0].accession))
+        else:
+            qnamew, tnamew, qaccw, taccw = 20, 20, 10, 10
+        # Turn black code style off
+        # fmt: off
+        header = ("#%*s %22s %22s %33s\n"
+                  % (tnamew + qnamew + taccw + qaccw + 2, "",
+                     "--- full sequence ----", "--- best 1 domain ----",
+                     "--- domain number estimation ----"))
+        header += ("#%-*s %-*s %-*s %-*s %9s %6s %5s %9s %6s %5s %5s %3s "
+                   "%3s %3s %3s %3s %3s %3s %s\n"
+                   % (tnamew - 1, " target name",
+                      taccw, "accession", qnamew, "query name", qaccw,
+                      "accession", "  E-value", " score", " bias",
+                      "  E-value", " score", " bias", "exp",
+                      "reg", "clu", " ov", "env", "dom", "rep",
+                      "inc", "description of target"))
+        header += ("#%*s %*s %*s %*s %9s %6s %5s %9s %6s %5s %5s %3s %3s "
+                   "%3s %3s %3s %3s %3s %s\n"
+                   % (tnamew - 1, "-------------------",
+                      taccw, "----------", qnamew, "--------------------", qaccw,
+                      "----------", "---------", "------", "-----", "---------",
+                      "------", "-----", "---", "---", "---", "---", "---", "---",
+                      "---", "---", "---------------------"))
+        # Turn black code style on
+        # fmt: on
+        return header
+
+    def _build_row(self, qresult):
+        """Return a string or one row or more of the QueryResult object (PRIVATE)."""
+        rows = ""
+
+        # calculate whitespace required
+        # adapted from HMMER's source: src/p7_tophits.c#L1083
+        qnamew = max(20, len(qresult.id))
+        tnamew = max(20, len(qresult[0].id))
+        qaccw = max(10, len(qresult.accession))
+        taccw = max(10, len(qresult[0].accession))
+
+        for hit in qresult:
+            rows += (
+                "%-*s %-*s %-*s %-*s %9.2g %6.1f %5.1f %9.2g %6.1f"
+                " %5.1f %5.1f %3d %3d %3d %3d %3d %3d %3d %s\n"
+                % (
+                    tnamew,
+                    hit.id,
+                    taccw,
+                    hit.accession,
+                    qnamew,
+                    qresult.id,
+                    qaccw,
+                    qresult.accession,
+                    hit.evalue,
+                    hit.bitscore,
+                    hit.bias,
+                    hit.hsps[0].evalue,
+                    hit.hsps[0].bitscore,
+                    hit.hsps[0].bias,
+                    hit.domain_exp_num,
+                    hit.region_num,
+                    hit.cluster_num,
+                    hit.overlap_num,
+                    hit.env_num,
+                    hit.domain_obs_num,
+                    hit.domain_reported_num,
+                    hit.domain_included_num,
+                    hit.description,
+                )
+            )
+
+        return rows
+
+
+# if not used as a module, run the doctest
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/HmmerIO/hmmer3_text.py

@@ -0,0 +1,457 @@
+# Copyright 2012 by Wibowo Arindrarto.  All rights reserved.
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+"""Bio.SearchIO parser for HMMER plain text output format."""
+
+import re
+
+from Bio.SearchIO._model import Hit
+from Bio.SearchIO._model import HSP
+from Bio.SearchIO._model import HSPFragment
+from Bio.SearchIO._model import QueryResult
+from Bio.SearchIO._utils import read_forward
+
+from ._base import _BaseHmmerTextIndexer
+
+__all__ = ("Hmmer3TextParser", "Hmmer3TextIndexer")
+
+
+# precompile regex patterns for faster processing
+# regex for program name capture
+_RE_PROGRAM = re.compile(r"^# .*?(\w?hmm\w+) :: .*$")
+# regex for version string capture
+_RE_VERSION = re.compile(r"# \w+ ([\w+\.]+) .*; http.*$")
+# regex for option string capture
+_RE_OPT = re.compile(r"^# (.+):\s+(.+)$")
+# regex for parsing query id and length, for parsing
+_QRE_ID_LEN_PTN = r"^Query:\s*(.*)\s+\[\w=(\d+)\]"
+_QRE_ID_LEN = re.compile(_QRE_ID_LEN_PTN)
+# regex for hsp validation
+_HRE_VALIDATE = re.compile(r"score:\s(-?\d+\.?\d+)\sbits.*value:\s(.*)")
+# regexes for parsing hsp alignment blocks
+_HRE_ANNOT_LINE = re.compile(r"^(\s+)(.+)\s(\w+)")
+_HRE_ID_LINE = re.compile(r"^(\s+\S+\s+[0-9-]+ )(.+?)(\s+[0-9-]+)")
+
+
+class Hmmer3TextParser:
+    """Parser for the HMMER 3.0 text output."""
+
+    def __init__(self, handle):
+        """Initialize the class."""
+        self.handle = handle
+        self.line = read_forward(self.handle)
+        self._meta = self._parse_preamble()
+
+    def __iter__(self):
+        """Iterate over query results."""
+        yield from self._parse_qresult()
+
+    def _read_until(self, bool_func):
+        """Read the file handle until the given function returns True (PRIVATE)."""
+        while True:
+            if not self.line or bool_func(self.line):
+                return
+            else:
+                self.line = read_forward(self.handle)
+
+    def _parse_preamble(self):
+        """Parse HMMER preamble (lines beginning with '#') (PRIVATE)."""
+        meta = {}
+        # bool flag for storing state ~ whether we are parsing the option
+        # lines or not
+        has_opts = False
+        while True:
+            # no pound sign means we've left the preamble
+            if not self.line.startswith("#"):
+                break
+            # dashes could either mean we are entering or leaving the options
+            # section ~ so it's a switch for the has_opts flag
+            elif "- - -" in self.line:
+                if not has_opts:
+                    # if flag is false, that means we're entering opts
+                    # so switch the flag accordingly
+                    has_opts = True
+                else:
+                    # if flag is true, that means we've reached the end of opts
+                    # so we can break out of the function
+                    break
+            elif not has_opts:
+                # try parsing program
+                regx = re.search(_RE_PROGRAM, self.line)
+                if regx:
+                    meta["program"] = regx.group(1)
+                # try parsing version
+                regx = re.search(_RE_VERSION, self.line)
+                if regx:
+                    meta["version"] = regx.group(1)
+            elif has_opts:
+                regx = re.search(_RE_OPT, self.line)
+                # if target in regx.group(1), then we store the key as target
+                if "target" in regx.group(1):
+                    meta["target"] = regx.group(2).strip()
+                else:
+                    meta[regx.group(1)] = regx.group(2)
+
+            self.line = read_forward(self.handle)
+
+        return meta
+
+    def _parse_qresult(self):
+        """Parse a HMMER3 query block (PRIVATE)."""
+        self._read_until(lambda line: line.startswith("Query:"))
+
+        while self.line:
+            regx = re.search(_QRE_ID_LEN, self.line)
+
+            while not regx:
+                self.line = read_forward(self.handle)
+                regx = re.search(_QRE_ID_LEN, self.line)
+
+            # get query id and length
+            qid = regx.group(1).strip()
+            # store qresult attributes
+            qresult_attrs = {
+                "seq_len": int(regx.group(2)),
+                "program": self._meta.get("program"),
+                "version": self._meta.get("version"),
+                "target": self._meta.get("target"),
+            }
+
+            # get description and accession, if they exist
+            qdesc = "<unknown description>"  # placeholder
+            while not self.line.startswith("Scores for "):
+                self.line = read_forward(self.handle)
+
+                if self.line.startswith("Accession:"):
+                    acc = self.line.strip().split(" ", 1)[1]
+                    qresult_attrs["accession"] = acc.strip()
+                elif self.line.startswith("Description:"):
+                    qdesc = self.line.strip().split(" ", 1)[1].strip()
+                    qresult_attrs["description"] = qdesc
+
+            # parse the query hits
+            while self.line and "//" not in self.line:
+                hit_list = self._parse_hit(qid, qdesc)
+                # read through the statistics summary
+                # TODO: parse and store this information?
+                if self.line.startswith("Internal pipeline"):
+                    while self.line and "//" not in self.line:
+                        self.line = read_forward(self.handle)
+
+            # create qresult, set its attributes and yield
+            # not initializing hit_list directly to handle empty hits
+            # (i.e. need to set its query description manually)
+            qresult = QueryResult(id=qid, hits=hit_list)
+            for attr, value in qresult_attrs.items():
+                setattr(qresult, attr, value)
+            yield qresult
+            self.line = read_forward(self.handle)
+
+            # Skip line beginning with '# Alignment of', which are output
+            # when running phmmer with the '-A' flag.
+            if self.line.startswith("#"):
+                self.line = self.handle.readline()
+
+            # HMMER >= 3.1 outputs '[ok]' at the end of all results file,
+            # which means we can break the main loop when we see the line
+            if "[ok]" in self.line:
+                break
+
+    def _parse_hit(self, qid, qdesc):
+        """Parse a HMMER3 hit block, beginning with the hit table (PRIVATE)."""
+        # get to the end of the hit table delimiter and read one more line
+        self._read_until(lambda line: line.startswith("    ------- ------ -----"))
+        self.line = read_forward(self.handle)
+
+        # assume every hit is in inclusion threshold until the inclusion
+        # threshold line is encountered
+        is_included = True
+
+        # parse the hit table
+        hit_attr_list = []
+        while True:
+            if not self.line:
+                return []
+            elif self.line.startswith("  ------ inclusion"):
+                is_included = False
+                self.line = read_forward(self.handle)
+            # if there are no hits, then there are no hsps
+            # so we forward-read until 'Internal pipeline..'
+            elif self.line.startswith("   [No hits detected that satisfy reporting"):
+                while True:
+                    self.line = read_forward(self.handle)
+                    if self.line.startswith("Internal pipeline"):
+                        assert len(hit_attr_list) == 0
+                        return []
+            elif self.line.startswith("Domain annotation for each "):
+                hit_list = self._create_hits(hit_attr_list, qid, qdesc)
+                return hit_list
+            # entering hit results row
+            # parse the columns into a list
+            row = [x for x in self.line.strip().split(" ") if x]
+            # join the description words if it's >1 word
+            if len(row) > 10:
+                row[9] = " ".join(row[9:])
+            # if there's no description, set it to an empty string
+            elif len(row) < 10:
+                row.append("")
+                assert len(row) == 10
+            # create the hit object
+            hit_attrs = {
+                "id": row[8],
+                "query_id": qid,
+                "evalue": float(row[0]),
+                "bitscore": float(row[1]),
+                "bias": float(row[2]),
+                # row[3:6] is not parsed, since the info is available
+                # at the HSP level
+                "domain_exp_num": float(row[6]),
+                "domain_obs_num": int(row[7]),
+                "description": row[9],
+                "is_included": is_included,
+            }
+            hit_attr_list.append(hit_attrs)
+
+            self.line = read_forward(self.handle)
+
+    def _create_hits(self, hit_attrs, qid, qdesc):
+        """Parse a HMMER3 hsp block, beginning with the hsp table (PRIVATE)."""
+        # read through until the beginning of the hsp block
+        self._read_until(lambda line: line.startswith(("Internal pipeline", ">>")))
+
+        # start parsing the hsp block
+        hit_list = []
+        while True:
+            if self.line.startswith("Internal pipeline"):
+                # by this time we should've emptied the hit attr list
+                assert len(hit_attrs) == 0
+                return hit_list
+            assert self.line.startswith(">>")
+            hid, hdesc = self.line[len(">> ") :].split("  ", 1)
+            hdesc = hdesc.strip()
+
+            # read through the hsp table header and move one more line
+            self._read_until(
+                lambda line: line.startswith(
+                    (" ---   ------ ----- --------", "   [No individual domains")
+                )
+            )
+            self.line = read_forward(self.handle)
+
+            # parse the hsp table for the current hit
+            hsp_list = []
+            while True:
+                # break out of hsp parsing if there are no hits, it's the last hsp
+                # or it's the start of a new hit
+                if (
+                    self.line.startswith("   [No targets detected that satisfy")
+                    or self.line.startswith("   [No individual domains")
+                    or self.line.startswith("Internal pipeline statistics summary:")
+                    or self.line.startswith("  Alignments for each domain:")
+                    or self.line.startswith(">>")
+                ):
+                    hit_attr = hit_attrs.pop(0)
+                    hit = Hit(hsp_list)
+                    for attr, value in hit_attr.items():
+                        if attr == "description":
+                            cur_val = getattr(hit, attr)
+                            if cur_val and value and cur_val.startswith(value):
+                                continue
+                        setattr(hit, attr, value)
+                    if not hit:
+                        hit.query_description = qdesc
+                    hit_list.append(hit)
+                    break
+
+                parsed = [x for x in self.line.strip().split(" ") if x]
+                assert len(parsed) == 16
+                # parsed column order:
+                # index, is_included, bitscore, bias, evalue_cond, evalue
+                # hmmfrom, hmmto, query_ends, hit_ends, alifrom, alito,
+                # envfrom, envto, acc_avg
+                frag = HSPFragment(hid, qid)
+                # set query and hit descriptions if they are defined / nonempty string
+                if qdesc:
+                    frag.query_description = qdesc
+                if hdesc:
+                    frag.hit_description = hdesc
+                # HMMER3 results are always protein
+                frag.molecule_type = "protein"
+                # depending on whether the program is hmmsearch, hmmscan, or phmmer
+                # {hmm,ali}{from,to} can either be hit_{from,to} or query_{from,to}
+                # for hmmscan, hit is the hmm profile, query is the sequence
+                if self._meta.get("program") == "hmmscan":
+                    # adjust 'from' and 'to' coordinates to 0-based ones
+                    frag.hit_start = int(parsed[6]) - 1
+                    frag.hit_end = int(parsed[7])
+                    frag.query_start = int(parsed[9]) - 1
+                    frag.query_end = int(parsed[10])
+                elif self._meta.get("program") in ["hmmsearch", "phmmer"]:
+                    # adjust 'from' and 'to' coordinates to 0-based ones
+                    frag.hit_start = int(parsed[9]) - 1
+                    frag.hit_end = int(parsed[10])
+                    frag.query_start = int(parsed[6]) - 1
+                    frag.query_end = int(parsed[7])
+                # strand is always 0, since HMMER now only handles protein
+                frag.hit_strand = frag.query_strand = 0
+
+                hsp = HSP([frag])
+                hsp.domain_index = int(parsed[0])
+                hsp.is_included = parsed[1] == "!"
+                hsp.bitscore = float(parsed[2])
+                hsp.bias = float(parsed[3])
+                hsp.evalue_cond = float(parsed[4])
+                hsp.evalue = float(parsed[5])
+                if self._meta.get("program") == "hmmscan":
+                    # adjust 'from' and 'to' coordinates to 0-based ones
+                    hsp.hit_endtype = parsed[8]
+                    hsp.query_endtype = parsed[11]
+                elif self._meta.get("program") in ["hmmsearch", "phmmer"]:
+                    # adjust 'from' and 'to' coordinates to 0-based ones
+                    hsp.hit_endtype = parsed[11]
+                    hsp.query_endtype = parsed[8]
+                # adjust 'from' and 'to' coordinates to 0-based ones
+                hsp.env_start = int(parsed[12]) - 1
+                hsp.env_end = int(parsed[13])
+                hsp.env_endtype = parsed[14]
+                hsp.acc_avg = float(parsed[15])
+
+                hsp_list.append(hsp)
+                self.line = read_forward(self.handle)
+
+            # parse the hsp alignments
+            if self.line.startswith("  Alignments for each domain:"):
+                self._parse_aln_block(hid, hit.hsps)
+
+    def _parse_aln_block(self, hid, hsp_list):
+        """Parse a HMMER3 HSP alignment block (PRIVATE)."""
+        self.line = read_forward(self.handle)
+        dom_counter = 0
+        while True:
+            if self.line.startswith(">>") or self.line.startswith("Internal pipeline"):
+                return hsp_list
+            assert self.line.startswith("  == domain %i" % (dom_counter + 1))
+            # alias hsp to local var
+            # but note that we're still changing the attrs of the actual
+            # hsp inside the qresult as we're not creating a copy
+            frag = hsp_list[dom_counter][0]
+            # XXX: should we validate again here? regex is expensive..
+            # regx = re.search(_HRE_VALIDATE, self.line)
+            # assert hsp.bitscore == float(regx.group(1))
+            # assert hsp.evalue_cond == float(regx.group(2))
+            hmmseq = ""
+            aliseq = ""
+            annot = {}
+            aln_prefix_len = None
+            self.line = self.handle.readline()
+
+            # parse all the alignment blocks in the hsp
+            while True:
+                regx = None
+
+                # check for hit or query line
+                # we don't check for the hit or query id specifically
+                # to anticipate special cases where query id == hit id
+                regx = re.search(_HRE_ID_LINE, self.line)
+                if regx:
+                    # Try to capture the block prefix len, to parse the similarity
+                    # string later.
+                    if aln_prefix_len is None:
+                        aln_prefix_len = len(regx.group(1))
+                    else:
+                        assert aln_prefix_len == len(regx.group(1))
+                    # the first hit/query self.line we encounter is the hmmseq
+                    if len(hmmseq) == len(aliseq):
+                        hmmseq += regx.group(2)
+                    # and for subsequent self.lines, len(hmmseq) is either
+                    # > or == len(aliseq)
+                    elif len(hmmseq) > len(aliseq):
+                        aliseq += regx.group(2)
+                    assert len(hmmseq) >= len(aliseq)
+                # check for start of new domain
+                elif (
+                    self.line.startswith("  == domain")
+                    or self.line.startswith(">>")
+                    or self.line.startswith("Internal pipeline")
+                ):
+                    frag.aln_annotation = annot
+                    if self._meta.get("program") == "hmmscan":
+                        frag.hit = hmmseq
+                        frag.query = aliseq
+                    elif self._meta.get("program") in ["hmmsearch", "phmmer"]:
+                        frag.hit = aliseq
+                        frag.query = hmmseq
+                    dom_counter += 1
+                    hmmseq = ""
+                    aliseq = ""
+                    annot = {}
+                    aln_prefix_len = None
+                    break
+                # check if it's an annotation line and parse it
+                # len(hmmseq) is only != len(aliseq) when the cursor is parsing
+                # the similarity character.
+                elif len(hmmseq) == len(aliseq):
+                    regx = re.search(_HRE_ANNOT_LINE, self.line)
+                    if regx:
+                        annot_name = regx.group(3)
+                        if annot_name in annot:
+                            annot[annot_name] += regx.group(2)
+                        else:
+                            annot[annot_name] = regx.group(2)
+                # otherwise, assume we are seeing the similarity string (the string
+                # between the two alignments). We do that by checking if we have
+                # defined the aln_prefix_len variable, which is the length of string
+                # from the beginning of the line to the start of the actual alignment
+                # (sans the IDs). We need this string to see how many characters we
+                # should strip from the beginning of the line. We can't call `strip()`
+                # since the similarity string might start with empty characters.
+                elif aln_prefix_len is not None:
+                    similarity = (
+                        self.line[aln_prefix_len:].removesuffix("\n").removesuffix("\r")
+                    )
+                    if "similarity" not in annot:
+                        annot["similarity"] = similarity
+                    else:
+                        annot["similarity"] += similarity
+
+                self.line = self.handle.readline()
+
+
+class Hmmer3TextIndexer(_BaseHmmerTextIndexer):
+    """Indexer class for HMMER plain text output."""
+
+    _parser = Hmmer3TextParser
+    qresult_start = b"Query: "
+    qresult_end = b"//"
+
+    def __iter__(self):
+        """Iterate over Hmmer3TextIndexer; yields query results' key, offsets, 0."""
+        handle = self._handle
+        handle.seek(0)
+        start_offset = handle.tell()
+        regex_id = re.compile(_QRE_ID_LEN_PTN.encode())
+
+        while True:
+            line = read_forward(handle)
+            end_offset = handle.tell()
+
+            if line.startswith(self.qresult_start):
+                regx = re.search(regex_id, line)
+                qresult_key = regx.group(1).strip()
+                # qresult start offset is the offset of this line
+                # (starts with the start mark)
+                start_offset = end_offset - len(line)
+            elif line.startswith(self.qresult_end):
+                yield qresult_key.decode(), start_offset, 0
+                start_offset = end_offset
+            elif not line:
+                break
+
+
+# if not used as a module, run the doctest
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/InfernalIO/__init__.py

@@ -0,0 +1,233 @@
+# Copyright 2024 by Samuel Prince. All rights reserved.
+#
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+
+
+"""Bio.SearchIO support for Infernal output formats.
+
+This module adds support for parsing Infernal outputs. Infernal is a
+suite of programs for searching DNA sequence databases for RNA structure
+and sequence similarities using covariance models (CMs).
+
+Bio.SearchIO.InfernalIO was tested on the following Infernal versions and flavors:
+
+    - Infernal (1.0.0+): cmscan and cmsearch
+
+More information on HMMER are available through these links:
+  - Web page: http://eddylab.org/infernal/
+  - User guide: http://eddylab.org/infernal/Userguide.pdf
+
+
+Supported formats
+=================
+
+Bio.SearchIO.InfernalIO supports the following Infernal output formats:
+    - Plain text   - 'infernal-text'    - parsing, indexing
+    - Tabular      - 'infernal-tab'     - parsing, indexing
+
+For all output formats, Infernal uses 'mdl' for 'query' and 'seq' for 'hit'.
+InfernalIO is aware of this different naming scheme, and will use 'query'
+and 'hit' to fit SearchIO's object model.
+
+Infernal sometime reports 'local ends' (i.e., a large insertion or deletion
+in the optimal alignment), which are expresented by a number in brackets in
+the alignment (ex. AUUAC*[88]*GUAGU). In InfernalIO, these local alignment
+are split into fragments of the same HSP.
+
+infernal-text
+=============
+
+The Infernal plain text parser supports output files with alignment
+blocks (default) or without (with the '-noali' flag). If the alignment blocks
+are present, it can parse files with variable alignment width (using the
+'-notextw' or '-textw' flag). Both CM or HMM searches (with the '--hmmonly'
+flag) output are supported. The parser only supports non-verbose output formats.
+
+The following SearchIO objects attributes are provided.
+
++-----------------+-------------------------+----------------------------------+
+| Object          | Attribute               | Value                            |
++=================+=========================+==================================+
+| QueryResult     | accession               | query accession                  |
+|                 +-------------------------+----------------------------------+
+|                 | description             | query sequence description       |
+|                 +-------------------------+----------------------------------+
+|                 | id                      | query sequence ID                |
+|                 +-------------------------+----------------------------------+
+|                 | program                 | Infernal flavor                  |
+|                 +-------------------------+----------------------------------+
+|                 | seq_len                 | full length of query sequence    |
+|                 +-------------------------+----------------------------------+
+|                 | target                  | target search database           |
+|                 +-------------------------+----------------------------------+
+|                 | version                 | Infernal version                 |
++-----------------+-------------------------+----------------------------------+
+| Hit             | description             | hit sequence description         |
+|                 +-------------------------+----------------------------------+
+|                 | id                      | hit sequence ID                  |
++-----------------+-------------------------+----------------------------------+
+| HSP             | evalue                  | hsp evalue                       |
+|                 +-------------------------+----------------------------------+
+|                 | bias                    | hsp bias                         |
+|                 +-------------------------+----------------------------------+
+|                 | bitscore                | hsp score                        |
+|                 +-------------------------+----------------------------------+
+|                 | gc                      | gc fraction                      |
+|                 +-------------------------+----------------------------------+
+|                 | is_included             | boolean, whether the hit of the  |
+|                 |                         | hsp is in the inclusion          |
+|                 |                         | threshold                        |
+|                 +-------------------------+----------------------------------+
+|                 | query_start             | query start position             |
+|                 +-------------------------+----------------------------------+
+|                 | query_end               | query end position               |
+|                 +-------------------------+----------------------------------+
+|                 | query_endtype           | query sequence end types (e.g.,  |
+|                 |                         | '[]', '..', '[.', '.]', etc.)    |
+|                 +-------------------------+----------------------------------+
+|                 | hit_start               | hit start position               |
+|                 +-------------------------+----------------------------------+
+|                 | hit_end                 | hit end position                 |
+|                 +-------------------------+----------------------------------+
+|                 | hit_endtype             | hit sequence end types           |
+|                 +-------------------------+----------------------------------+
+|                 | acc_avg                 | expected accuracy per alignment  |
+|                 |                         | residue (acc column)             |
+|                 +-------------------------+----------------------------------+
+|                 | model                   | type of model used (cm or hmm)   |
+|                 +-------------------------+----------------------------------+
+|                 | truncated               | indicate if the hit is truncated |
+|                 |                         | (5', 3' or both) or not          |
++-----------------+-------------------------+----------------------------------+
+| HSPFragment     | aln_annotation          | alignment similarity string and  |
+|                 |                         | other annotations (PP, CS,       |
+|                 |                         | similarity and NC (except for    |
+|                 |                         | --hmmonly))                      |
+|                 +-------------------------+----------------------------------+
+|                 | aln_span                | length of alignment fragment     |
+|                 +-------------------------+----------------------------------+
+|                 | hit                     | hit sequence                     |
+|                 +-------------------------+----------------------------------+
+|                 | hit_start               | local alignment sequence start   |
+|                 |                         | coordinate (seq from)            |
+|                 +-------------------------+----------------------------------+
+|                 | hit_end                 | local alignment sequence end     |
+|                 |                         | coordinate (seq to)              |
+|                 +-------------------------+----------------------------------+
+|                 | hit_strand              | hit sequence strand              |
+|                 +-------------------------+----------------------------------+
+|                 | query                   | query sequence                   |
+|                 +-------------------------+----------------------------------+
+|                 | query_start             | local model alignment start      |
+|                 |                         | coordinate (mdl from)            |
+|                 +-------------------------+----------------------------------+
+|                 | query_end               | local model alignment end        |
+|                 |                         | coordinate (mdl to)              |
++-----------------+-------------------------+----------------------------------+
+
+infernal-tab
+============
+
+The Infernal plain text parser supports the standard cmsearch tabular output and
+cmscan tabular output files formats 1, 2 and 3 (inferred automatically from the
+header).
+
+Rows marked with '*' denotes attributes not available in the default format.
+
++-----------------+-------------------------+----------------------------------+
+| Object          | Attribute               | Value                            |
++=================+=========================+==================================+
+| QueryResult     | accession               | query accession                  |
+|                 +-------------------------+----------------------------------+
+|                 | id                      | query sequence ID                |
+|                 +-------------------------+----------------------------------+
+|                 | clan*                   | Rfam clan                        |
+|                 +-------------------------+----------------------------------+
+|                 | seq_len*                | query sequence length            |
++-----------------+-------------------------+----------------------------------+
+| Hit             | description             | hit sequence description         |
+|                 +-------------------------+----------------------------------+
+|                 | id                      | hit sequence ID                  |
+|                 +-------------------------+----------------------------------+
+|                 | accession               | hit accession                    |
+|                 +-------------------------+----------------------------------+
+|                 | seq_len*                | hit sequence length              |
++-----------------+-------------------------+----------------------------------+
+| HSP             | evalue                  | hsp evalue                       |
+|                 +-------------------------+----------------------------------+
+|                 | bias                    | hsp bias                         |
+|                 +-------------------------+----------------------------------+
+|                 | bitscore                | hsp score                        |
+|                 +-------------------------+----------------------------------+
+|                 | gc                      | gc fraction                      |
+|                 +-------------------------+----------------------------------+
+|                 | is_included             | boolean, whether the hit of the  |
+|                 |                         | hsp is in the inclusion          |
+|                 |                         | threshold                        |
+|                 +-------------------------+----------------------------------+
+|                 | model                   | type of model used (cm or hmm)   |
+|                 +-------------------------+----------------------------------+
+|                 | truncated               | indicate if the hit is truncated |
+|                 |                         | (5', 3' or both) or not          |
+|                 +-------------------------+----------------------------------+
+|                 | pipeline_pass           | pipeline pass at which the hit   |
+|                 |                         | was identified                   |
+|                 +-------------------------+----------------------------------+
+|                 | olp*                    | overlap status of this hit ('*', |
+|                 |                         | '^', '$' or '=')                 |
+|                 +-------------------------+----------------------------------+
+|                 | anyidx*                 | index of the best scoring        |
+|                 |                         | overlapping hit (or none if      |
+|                 |                         | there are no overlap)            |
+|                 +-------------------------+----------------------------------+
+|                 | afrct1*                 | fraction of this hit that        |
+|                 |                         | overlap with anyidx hit (or none |
+|                 |                         | if there are no overlap)         |
+|                 +-------------------------+----------------------------------+
+|                 | afrct2*                 | fraction of anyidx hit           |
+|                 |                         | with this hit (or none if there  |
+|                 |                         | are no overlap)                  |
+|                 +-------------------------+----------------------------------+
+|                 | winidx*                 | index of the best scoring hit    |
+|                 |                         | that overlaps with this hit that |
+|                 |                         | is marked as '^' (or none if     |
+|                 |                         | there are no overlap)            |
+|                 +-------------------------+----------------------------------+
+|                 | wfrct1*                 | fraction of this hit that        |
+|                 |                         | overlap with winidx hit (or none |
+|                 |                         | if there are no overlap)         |
+|                 +-------------------------+----------------------------------+
+|                 | wfrct2*                 | fraction of winidx hit           |
+|                 |                         | with this hit (or none if there  |
+|                 |                         | are no overlap)                  |
++-----------------+-------------------------+----------------------------------+
+| HSPFragment     | hit_start               | local alignment sequence start   |
+| (also via HSP)  |                         | coordinate (seq from)            |
+|                 +-------------------------+----------------------------------+
+|                 | hit_end                 | local alignment sequence end     |
+|                 |                         | coordinate (seq to)              |
+|                 +-------------------------+----------------------------------+
+|                 | hit_strand              | hit sequence strand              |
+|                 +-------------------------+----------------------------------+
+|                 | query_start             | local model alignment start      |
+|                 |                         | coordinate (mdl from)            |
+|                 +-------------------------+----------------------------------+
+|                 | query_end               | local model alignment end        |
+|                 |                         | coordinate (mdl to)              |
++-----------------+-------------------------+----------------------------------+
+"""
+
+from .infernal_tab import InfernalTabParser
+from .infernal_tab import InfernalTabIndexer
+from .infernal_text import InfernalTextParser
+from .infernal_text import InfernalTextIndexer
+
+
+# if not used as a module, run the doctest
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/InfernalIO/_base.py

@@ -0,0 +1,39 @@
+# Copyright 2024 by Samuel Prince. All rights reserved.
+#
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+
+
+"""Bio.SearchIO base classes for Infernal-related code."""
+
+from Bio.SearchIO._model import Hit
+
+
+class _BaseInfernalParser:
+    """Abstract class for Infernal parser objects."""
+
+    def _add_hit_to_dict(self, hit_attrs, hsp, hit_dict):
+        """Add a hit information to the hit container (PRIVATE)."""
+        # add the hit to the container dict, creating a new
+        # entry if it does not exist yet
+        hid = hit_attrs["id"]
+        if hid not in hit_dict:
+            hit_dict[hid] = {"attrs": hit_attrs, "hsps": []}
+        else:
+            assert hit_dict[hid]["attrs"]["query_id"] == hit_attrs["query_id"]
+            assert hit_dict[hid]["attrs"]["description"] == hit_attrs["description"]
+
+        hit_dict[hid]["hsps"].append(hsp)
+
+    def _hit_to_list(self, hit_dict):
+        """Create a Hit list from the hit container (PRIVATE)."""
+
+        hit_list = []
+        for hit_info in hit_dict.values():
+            hit = Hit(hit_info["hsps"])
+            for attr, value in hit_info["attrs"].items():
+                setattr(hit, attr, value)
+            hit_list.append(hit)
+        return hit_list

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/InfernalIO/infernal_tab.py

@@ -0,0 +1,486 @@
+# Copyright 2024 by Samuel Prince. All rights reserved.
+#
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+
+"""Bio.SearchIO parser for Infernal tabular output format."""
+
+from Bio.SearchIO._index import SearchIndexer
+from Bio.SearchIO._model import HSP
+from Bio.SearchIO._model import HSPFragment
+from Bio.SearchIO._model import QueryResult
+
+from ._base import _BaseInfernalParser
+from Bio.File import _open_for_random_access
+
+__all__ = ("InfernalTabParser", "InfernalTabIndexer")
+
+# tabular format column names
+_TAB_FORMAT = {
+    1: (
+        "target_name",
+        "target_acc",
+        "query_name",
+        "query_acc",
+        "mdl",
+        "mdl_from",
+        "mdl_to",
+        "seq_from",
+        "seq_to",
+        "strand",
+        "trunc",
+        "pass",
+        "gc",
+        "bias",
+        "score",
+        "evalue",
+        "inc",
+        "description",
+    ),
+    2: (
+        "idx",
+        "target_name",
+        "target_acc",
+        "query_name",
+        "query_acc",
+        "clan",
+        "mdl",
+        "mdl_from",
+        "mdl_to",
+        "seq_from",
+        "seq_to",
+        "strand",
+        "trunc",
+        "pass",
+        "gc",
+        "bias",
+        "score",
+        "evalue",
+        "inc",
+        "olp",
+        "anyidx",
+        "afrct1",
+        "afrct2",
+        "winidx",
+        "wfrct1",
+        "wfrct2",
+        "mdl_len",
+        "seq_len",
+        "description",
+    ),
+    3: (
+        "target_name",
+        "target_acc",
+        "query_name",
+        "query_acc",
+        "mdl",
+        "mdl_from",
+        "mdl_to",
+        "seq_from",
+        "seq_to",
+        "strand",
+        "trunc",
+        "pass",
+        "gc",
+        "bias",
+        "score",
+        "evalue",
+        "inc",
+        "mdl_len",
+        "seq_len",
+        "description",
+    ),
+}
+
+_TABULAR_FMT_1_HEADER_FIELDS = [
+    "target name",
+    "accession",
+    "query name",
+    "accession",
+    "mdl",
+    "mdl from",
+    "mdl to",
+    "seq from",
+    "seq to",
+    "strand",
+    "trunc",
+    "pass",
+    "gc",
+    "bias",
+    "score",
+    "E-value",
+    "inc",
+    "description of target",
+]
+_TABULAR_FMT_2_HEADER_FIELDS = [
+    "idx",
+    "target name",
+    "accession",
+    "query name",
+    "accession",
+    "clan name",
+    "mdl",
+    "mdl from",
+    "mdl to",
+    "seq from",
+    "seq to",
+    "strand",
+    "trunc",
+    "pass",
+    "gc",
+    "bias",
+    "score",
+    "E-value",
+    "inc",
+    "olp",
+    "anyidx",
+    "afrct1",
+    "afrct2",
+    "winidx",
+    "wfrct1",
+    "wfrct2",
+    "mdl len",
+    "seq len",
+    "description of target",
+]
+_TABULAR_FMT_3_HEADER_FIELDS = [
+    "target name",
+    "accession",
+    "query name",
+    "accession",
+    "mdl",
+    "mdl from",
+    "mdl to",
+    "seq from",
+    "seq to",
+    "strand",
+    "trunc",
+    "pass",
+    "gc",
+    "bias",
+    "score",
+    "E-value",
+    "inc",
+    "mdl len",
+    "seq len",
+    "description of target",
+]
+
+# column to class attribute map
+_COLUMN_QRESULT = {
+    "query_name": ("id", str),
+    "query_acc": ("accession", str),
+    "seq_len": ("seq_len", int),
+    "clan": ("clan", str),
+}
+_COLUMN_HIT = {
+    "target_name": ("id", str),
+    "target_acc": ("accession", str),
+    "query_name": ("query_id", str),
+    "description": ("description", str),
+    "mdl_len": ("seq_len", int),
+}
+_COLUMN_HSP = {
+    "score": ("bitscore", float),
+    "evalue": ("evalue", float),
+    "bias": ("bias", float),
+    "gc": ("gc", float),
+    "mdl": ("model", str),
+    "trunc": ("truncated", str),
+    "pass": ("pipeline_pass", int),
+    "inc": ("is_included", lambda x: True if x == "!" else False),
+    "olp": ("olp", str),
+    "anyidx": ("anyidx", lambda x: None if x == "-" else int(x)),
+    "afrct1": ("afrct1", lambda x: None if x == "-" else float(x)),
+    "afrct2": ("afrct2", lambda x: None if x == "-" else float(x)),
+    "winidx": ("winidx", lambda x: None if (x == "-" or x == '"') else int(x)),
+    "wfrct1": ("wfrct1", lambda x: None if (x == "-" or x == '"') else float(x)),
+    "wfrct2": ("wfrct2", lambda x: None if (x == "-" or x == '"') else float(x)),
+}
+_COLUMN_FRAG = {
+    "mdl_from": ("query_start", int),
+    "mdl_to": ("query_end", int),
+    "seq_from": ("hit_start", int),
+    "seq_to": ("hit_end", int),
+    "strand": ("hit_strand", str),
+}
+
+
+def _infer_tabular_format(handle, is_byte=False):
+    """Infer tabular format from the tabular file header. (PRIVATE)"""
+    # infernal tabular output columns are space separated files with spaces in
+    # column names, ex:
+    # #target name         accession
+    # #------------------- ---------
+    # so we use the second line of the header where the is not spaces to
+    # determine the position of the headers labels. Then we can get the label names
+    # and compare the the different tabular format names. This label comparison is done
+    # (instead of counting fields) to avoid issues if future tabular format have the
+    # same number of fields, but with different signification
+
+    def process_line(handle, is_byte):
+        """Process a line from the handle, decoding byte stream."""
+        line = handle.readline().strip()
+        return line.decode() if is_byte else line
+
+    header_label = process_line(handle, is_byte)
+    header_delim = process_line(handle, is_byte)
+
+    if header_label == "" or header_delim == "":
+        raise ValueError(
+            "Unexpected empty line in the header of Infernal tabular output."
+        )
+
+    # get the indices of the spaces fields delimiter from the second header line
+    # the end of the file is added to the indices to process the last field
+    indices = [idx for idx, char in enumerate(header_delim) if char == " "] + [
+        len(header_delim)
+    ]
+    prev_idx = 1
+    fields = []
+    for idx in indices:
+        fields.append(header_label[prev_idx:idx].strip())
+        prev_idx = idx
+
+    # compare the headers fields to the possible fields to determine the format
+    if fields == _TABULAR_FMT_1_HEADER_FIELDS:
+        return 1
+    elif fields == _TABULAR_FMT_2_HEADER_FIELDS:
+        return 2
+    elif fields == _TABULAR_FMT_3_HEADER_FIELDS:
+        return 3
+    else:
+        raise ValueError(
+            "Cannot determine the tabular format from the header. \
+            The tabular file is likely incorrect or its format is unsupported. \
+            Tabular format 1, 2 and 3 are currently supported)."
+        )
+
+
+class InfernalTabParser(_BaseInfernalParser):
+    """Parser for the Infernal tabular format."""
+
+    def __init__(self, handle, _fmt=None):
+        """Initialize the class."""
+        self.handle = handle
+        if isinstance(_fmt, int):
+            assert _fmt in {1, 2, 3}
+            self.fmt = _fmt
+        else:
+            self.fmt = _infer_tabular_format(handle=handle)
+
+    def __iter__(self):
+        """Iterate over InfernalTabParser, yields query results."""
+        # read through the header (and footer if there is no results)
+        self.line = self.handle.readline()
+        while self.line.startswith("#"):
+            self.line = self.handle.readline()
+        # if we have result rows, parse them
+        if self.line:
+            yield from self._parse_qresult()
+
+    def _parse_row(self):
+        """Return a dictionary of parsed row values (PRIVATE)."""
+        cols = [x for x in self.line.strip().split(" ") if x]
+        if len(cols) < len(_TAB_FORMAT[self.fmt]):
+            raise ValueError(
+                f"Less columns than expected for format {self.fmt}, only {len(cols)}"
+            )
+        # combine extra description columns into one string
+        cols[len(_TAB_FORMAT[self.fmt]) - 1] = " ".join(
+            cols[len(_TAB_FORMAT[self.fmt]) - 1 :]
+        )
+
+        qresult, hit, hsp, frag = {}, {}, {}, {}
+        for sname, value in zip(
+            _TAB_FORMAT[self.fmt], cols[: len(_TAB_FORMAT[self.fmt])]
+        ):
+            # iterate over each dict, mapping pair to determine
+            # attribute name and value of each column
+            for parsed_dict, mapping in (
+                (qresult, _COLUMN_QRESULT),
+                (hit, _COLUMN_HIT),
+                (hsp, _COLUMN_HSP),
+                (frag, _COLUMN_FRAG),
+            ):
+                # process parsed value according to mapping
+                if sname in mapping:
+                    attr_name, caster = mapping[sname]
+                    if caster is not str:
+                        value = caster(value)
+                    parsed_dict[attr_name] = value
+
+        # adjust start and end coordinates according to strand
+        self._adjust_coords(frag)
+
+        return {"qresult": qresult, "hit": hit, "hsp": hsp, "frag": frag}
+
+    def _adjust_coords(self, frag):
+        """Adjust start and end coordinates according to strand (PRIVATE)."""
+        strand = frag["hit_strand"]
+        assert strand is not None
+        # switch start <--> end coordinates if strand is -1 and the strand to an integer (0 or -1)
+        if strand == "-":
+            hit_start = frag["hit_start"]
+            hit_end = frag["hit_end"]
+            frag["hit_start"] = hit_end
+            frag["hit_end"] = hit_start
+            frag["hit_strand"] = -1
+        else:
+            frag["hit_strand"] = 0
+
+    def _parse_qresult(self):
+        """Yield QueryResult objects (PRIVATE)."""
+        # state values, determines what to do for each line
+        state_EOF = 0
+        state_QRES_NEW = 1
+        state_QRES_SAME = 3
+        # dummies for initial states
+        qres_state = None
+        file_state = None
+        cur_qid = None
+        cur_hid = None
+        # dummies for initial id caches
+        prev_qid = None
+        prev_hid = None
+        # dummies for initial parsed value containers
+        cur, prev = None, None
+        hit_dict = {}
+
+        while True:
+            # store previous line's parsed values for all lines after the first
+            if cur is not None:
+                prev = cur
+                prev_qid = cur_qid
+                prev_hid = cur_hid
+            # only parse the result row if it's not EOF or a comment line
+            if self.line and not self.line.startswith("#"):
+                cur = self._parse_row()
+                cur_qid = cur["qresult"]["id"]
+                cur_hid = cur["hit"]["id"]
+            else:
+                file_state = state_EOF
+                # mock values for cur_qid and cur_hid since the line is empty
+                cur_qid, cur_hid = None, None
+
+            # get the state of hit and qresult
+            if prev_qid != cur_qid:
+                qres_state = state_QRES_NEW
+            else:
+                qres_state = state_QRES_SAME
+
+            # creating objects for the previously parsed line(s), so nothing is done
+            # in the first parsed line (prev == None)
+            if prev is not None:
+                # create fragment and HSP and set their attributes
+                # and append to hit container
+                frag = HSPFragment(prev_hid, prev_qid)
+                for attr, value in prev["frag"].items():
+                    setattr(frag, attr, value)
+                hsp = HSP([frag])
+                for attr, value in prev["hsp"].items():
+                    setattr(hsp, attr, value)
+                self._add_hit_to_dict(prev["hit"], hsp, hit_dict)
+
+                # create qresult and yield if we're at a new qresult or at EOF
+                if qres_state == state_QRES_NEW or file_state == state_EOF:
+                    # create the hit list from the temporary container
+                    qresult = QueryResult(self._hit_to_list(hit_dict), prev_qid)
+                    for attr, value in prev["qresult"].items():
+                        setattr(qresult, attr, value)
+                    yield qresult
+                    # if we're at EOF, break
+                    if file_state == state_EOF:
+                        break
+                    hit_dict = {}
+
+            self.line = self.handle.readline()
+
+
+class InfernalTabIndexer(SearchIndexer):
+    """Indexer class for Infernal tabular output."""
+
+    _parser = InfernalTabParser
+
+    def __init__(self, filename):
+        """Initialize the class."""
+        # the index of the query id column in the tabular file varies depending on the fmt
+        # we need to use the format set by the user, or infer the format to parse the records
+        with _open_for_random_access(filename) as handle:
+            fmt = _infer_tabular_format(handle, is_byte=True)
+        self._query_id_idx = 3 if fmt == 2 else 2
+
+        SearchIndexer.__init__(self, filename, _fmt=fmt)
+
+    def __iter__(self):
+        """Iterate over the file handle; yields key, start offset, and length."""
+        handle = self._handle
+        handle.seek(0)
+        qresult_key = None
+        start_offset = handle.tell()
+
+        # set line with mock value
+        line = b"#"
+
+        # read through header
+        while line.startswith(b"#"):
+            start_offset = handle.tell()
+            line = handle.readline()
+
+        # index the qresults
+        while True:
+            # get end offset here since we only know a qresult ends after
+            # encountering the next one
+            end_offset = handle.tell()
+
+            if not line:
+                break
+
+            cols = [x for x in line.strip().split(b" ") if x]
+
+            if qresult_key is None:
+                qresult_key = cols[self._query_id_idx]
+            else:
+                curr_key = cols[self._query_id_idx]
+                if curr_key != qresult_key:
+                    adj_end = end_offset - len(line)
+                    yield (qresult_key.decode(), start_offset, adj_end - start_offset)
+                    qresult_key = curr_key
+                    start_offset = adj_end
+
+            line = handle.readline()
+            if not line or line.startswith(b"#"):
+                yield (qresult_key.decode(), start_offset, end_offset - start_offset)
+                break
+
+    def get_raw(self, offset):
+        """Return the raw bytes string of a QueryResult object from the given offset."""
+        handle = self._handle
+        qresult_key = None
+        qresult_raw = b""
+
+        # read the qresult raw string
+        handle.seek(offset)
+        while True:
+            line = handle.readline()
+            if not line or line.startswith(b"#"):
+                break
+            cols = [x for x in line.strip().split(b" ") if x]
+            if qresult_key is None:
+                qresult_key = cols[self._query_id_idx]
+            else:
+                curr_key = cols[self._query_id_idx]
+                if curr_key != qresult_key:
+                    break
+            qresult_raw += line
+
+        return qresult_raw
+
+
+# if not used as a module, run the doctest
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/InfernalIO/infernal_text.py

@@ -0,0 +1,542 @@
+# Copyright 2024 by Samuel Prince. All rights reserved.
+#
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+
+
+"""Bio.SearchIO parser for Infernal plain text output format."""
+
+import operator
+import re
+
+from Bio.SearchIO._index import SearchIndexer
+from Bio.SearchIO._model import HSP
+from Bio.SearchIO._model import HSPFragment
+from Bio.SearchIO._model import QueryResult
+from Bio.SearchIO._utils import read_forward
+
+from ._base import _BaseInfernalParser
+
+__all__ = ("InfernalTextParser", "InfernalTextIndexer")
+
+# precompile regex patterns for faster processing
+# program name
+_RE_PROGRAM = re.compile(r"^# .*?(\w?cm\w+) :: .*$")
+# version string
+_RE_VERSION = re.compile(r"# INFERNAL+ ([\w+\.]{2,}) .*$")
+# option string
+_RE_OPT = re.compile(r"^# (.+):\s+(.+)$")
+# numbers only
+_RE_NUMERIC = re.compile(r"\d+")
+_RE_NOT_NUMERIC = re.compile(r"\D")
+# letters only
+_RE_LETTERS = re.compile(r"[^A-Za-z]")
+# missing segments in the alignment block
+_RE_SPLIT_ALN = re.compile(r"(\*\[[ 0-9]+\]\*)+")
+
+# divider for Infernal plain text output, these divider are
+# always taken from the beginning of the line to be usable in
+# self.line.startswith() method
+# header options
+_DIV_HEADER_OPT = "# - - -"
+# query
+_DIV_QUERY_END = "//"
+_DIV_QUERY_START = "Query:"
+# hits
+_DIV_HITS_END_CM = "Internal CM pipeline statistics summary:"
+_DIV_HITS_END_HMM = "Internal HMM-only pipeline statistics summary:"
+_DIV_HIT_SCORE_TABLE = "Hit scores:"
+_DIV_HIT_ALIGNMENT = "Hit alignments:"
+_DIV_NO_HIT = "   [No hits detected that satisfy reporting thresholds]"
+_DIV_TABLE_START = " ----   --------- ------"
+_DIV_INC_THRESHOLD = " ------ inclusion threshold ------"
+# hit alignment
+_DIV_ALIGNMENT_START = ">> "
+
+
+class InfernalTextParser(_BaseInfernalParser):
+    """Parser for the Infernal text output."""
+
+    def __init__(self, handle):
+        """Initialize the class."""
+        self.handle = handle
+        self.line = read_forward(self.handle)
+        self._meta = self._parse_header()
+
+    def __iter__(self):
+        """Iterate over query results."""
+        yield from self._parse_qresult()
+
+    def _read_until(self, bool_func):
+        """Read the file handle until the given function returns True (PRIVATE)."""
+        while True:
+            if not self.line or bool_func(self.line):
+                return
+            self.line = read_forward(self.handle)
+
+    def _parse_header(self):
+        """Parse Infernal header (PRIVATE)."""
+        meta = {}
+        # set the default value for the presence of alignment
+        # as this information is important for the hit section parsing
+        meta["show alignments in output"] = "yes"
+        # bool flag for storing state ~ whether we are parsing the option
+        # lines or not
+        has_opts = False
+        while True:
+            # no pound sign means we've left the preamble
+            if not self.line.startswith("#"):
+                break
+            # dashes could either mean we are entering or leaving the options
+            # section, so it's a switch for the has_opts flag
+            elif self.line.startswith(_DIV_HEADER_OPT):
+                if not has_opts:
+                    # if flag is false, that means we're entering opts
+                    # so switch the flag accordingly
+                    has_opts = True
+                else:
+                    # if flag is true, that means we've reached the end of opts
+                    # so we can break out of the function
+                    break
+            elif not has_opts:
+                # try parsing program
+                regx = re.search(_RE_PROGRAM, self.line)
+                if regx:
+                    meta["program"] = regx.group(1)
+                # try parsing version
+                regx = re.search(_RE_VERSION, self.line)
+                if regx:
+                    meta["version"] = regx.group(1)
+            elif has_opts:
+                regx = re.search(_RE_OPT, self.line)
+                # if target in regx.group(1), then we store the key as target
+                if "target" in regx.group(1):
+                    meta["target"] = regx.group(2).strip()
+                else:
+                    meta[regx.group(1)] = regx.group(2)
+
+            self.line = read_forward(self.handle)
+
+        return meta
+
+    def _parse_qresult(self):
+        """Parse a Infernal query block (PRIVATE)."""
+        self._read_until(lambda line: line.startswith(_DIV_QUERY_START))
+
+        while self.line:
+            # create qresult for query id
+            if self.line.startswith(_DIV_QUERY_START):
+                qid = self.line.strip().split()[1]
+                qlen = int(re.sub(_RE_NOT_NUMERIC, "", self.line.strip().split()[-1]))
+
+                # store qresult attributes
+                qresult_attrs = {
+                    "id": qid,
+                    "seq_len": qlen,
+                    "program": self._meta.get("program"),
+                    "version": self._meta.get("version"),
+                    "target": self._meta.get("target"),
+                }
+            else:
+                self.line = read_forward(self.handle)
+
+            # get description and accession, if they exist
+            qdesc = "<unknown description>"  # placeholder
+            while not self.line.startswith(_DIV_HIT_SCORE_TABLE):
+                self.line = read_forward(self.handle)
+
+                if self.line.startswith("Accession:"):
+                    acc = self.line.strip().split(" ", 1)[1]
+                    qresult_attrs["accession"] = acc.strip()
+                elif self.line.startswith("Description:"):
+                    qdesc = self.line.strip().split(" ", 1)[1].strip()
+                    qresult_attrs["description"] = qdesc
+
+            # parse the query hits
+            # initializing hit_list directly to handle empty hits
+            hit_list = []
+            while self.line and not self.line.startswith(_DIV_QUERY_END):
+                hit_list = self._parse_hit(qid, qdesc)
+                # read through the statistics summary
+                if self.line.startswith(_DIV_HITS_END_CM) or self.line.startswith(
+                    _DIV_HITS_END_HMM
+                ):
+                    while self.line and not self.line.startswith(_DIV_QUERY_END):
+                        self.line = read_forward(self.handle)
+            # create qresult, set its attributes and yield
+            qresult = QueryResult(id=qid, hits=hit_list)
+            for attr, value in qresult_attrs.items():
+                setattr(qresult, attr, value)
+            yield qresult
+            self.line = read_forward(self.handle)
+
+            # Infernal outputs '[ok]' at the end of all results file,
+            # which means we can break the main loop when we see the line
+            if "[ok]" in self.line:
+                break
+
+    def _parse_hit(self, qid, qdesc):
+        """Parse an Infernal hit (PRIVATE)."""
+        # state values, determines what to do for each block
+        hit_end = False
+        in_score_table = False
+        parsing_hits = False
+        prev_line = None
+        # hits are not guaranteed to be in order, and duplicate hit
+        # IDs will raise a ValueError. to avoid this, hits are stored in
+        # a temporary dictionary and the hit list required to create
+        # the QueryResult is generated at the end of the query block
+        hit_dict = {}
+
+        # set the divider based on the output type (with or without alignment)
+        if self._meta["show alignments in output"] == "no":
+            div_hit_start = _DIV_HIT_SCORE_TABLE
+        else:
+            div_hit_start = _DIV_ALIGNMENT_START
+
+        while True:
+            if not self.line:
+                raise ValueError("Unexpected end of file")
+            # if there are no hits, forward-read to the end of the query
+            elif self.line.startswith(_DIV_NO_HIT):
+                while True:
+                    self.line = read_forward(self.handle)
+                    if self.line.startswith(_DIV_HITS_END_CM) or self.line.startswith(
+                        _DIV_HITS_END_HMM
+                    ):
+                        hit_end = True
+                        return []
+            # entering hit alignment block
+            elif self.line.startswith(div_hit_start):
+                # for --noali output, move to the beginning of the hit score table
+                if self._meta["show alignments in output"] == "no":
+                    assert not in_score_table
+                    self._read_until(lambda line: line.startswith(_DIV_TABLE_START))
+                    self.line = read_forward(self.handle)
+                    parsing_hits = in_score_table = True
+                else:
+                    self._parse_hit_from_alignment(qid, hit_dict)
+                    parsing_hits = True
+            # we've reached the end of the hit section
+            elif self.line.startswith(_DIV_HITS_END_CM) or self.line.startswith(
+                _DIV_HITS_END_HMM
+            ):
+                hit_end = True
+                parsing_hits = False
+            # Read through the scores table. For regular output this information
+            # is not needed, so we can skip it. For --noali output, this table
+            # contains the HSP information
+            else:
+                # for --noali output, keep the line
+                if in_score_table:
+                    if self.line.strip():
+                        prev_line = self.line
+                    else:
+                        parsing_hits = in_score_table = False
+
+                # read one line at the time
+                self.line = self.handle.readline()
+
+            # for --noali output, parse the scores table row
+            if in_score_table and prev_line is not None:
+                if not prev_line.startswith(_DIV_INC_THRESHOLD):
+                    self._parse_scores_table_row(prev_line, qid, hit_dict)
+
+            # we've reached the end of the query block hits
+            # creating the Hit objects for this query
+            if hit_end:
+                return self._hit_to_list(hit_dict)
+
+    def _parse_hit_from_alignment(self, qid, hit_dict):
+        """Parse an Infernal hit alignment (PRIVATE)."""
+        hid, hdesc = self.line[len(_DIV_ALIGNMENT_START) :].split("  ", 1)
+        hdesc = hdesc.strip()
+
+        # read through the hit table header and move one more line
+        self._read_until(lambda line: line.startswith(_DIV_TABLE_START))
+        self.line = read_forward(self.handle)
+
+        # parse the hit table
+        row = [x for x in self.line.strip().split() if x]
+        assert len(row) == 16
+
+        # create hit and append to hit container
+        hit_attrs = {"id": hid, "query_id": qid, "description": hdesc}
+        hsp_attrs = {
+            "evalue": float(row[2]),
+            "bitscore": float(row[3]),
+            "bias": float(row[4]),
+            "model": row[5],
+            "truncated": row[14],
+            "gc": float(row[15]),
+            "avg_acc": float(row[13]),
+            "query_endtype": row[8],
+            "hit_endtype": row[12],
+            "is_included": True if row[1] == "!" else False,
+        }
+        query_start = int(row[6])
+        query_end = int(row[7])
+        hit_start = int(row[9]) if row[11] == "+" else int(row[10])
+        hit_end = int(row[10]) if row[11] == "+" else int(row[9])
+        hit_strand = 0 if row[11] == "+" else -1
+
+        # move to the HSP alignment block
+        self.line = read_forward(self.handle)
+
+        # create the hsp
+        frag_list = self._parse_aln_block(
+            hit_attrs["id"],
+            hit_attrs["query_id"],
+            hsp_attrs["model"],
+            query_start,
+            query_end,
+            hit_start,
+            hit_end,
+            hit_strand,
+        )
+        hsp = HSP(frag_list)
+        for attr, value in hsp_attrs.items():
+            setattr(hsp, attr, value)
+
+        # add the hit to the container
+        self._add_hit_to_dict(hit_attrs, hsp, hit_dict)
+
+    def _parse_scores_table_row(self, row, qid, hit_dict):
+        """Parse an Infernal hit scores table (when used with --noali) (PRIVATE)."""
+
+        # parse the columns into a list
+        row = [x for x in row.strip().split(" ") if x]
+        # join the description words if it's >1 word
+        if len(row) > 12:
+            row[12] = " ".join(row[12:])
+        # if there's no description, set it to an empty string
+        elif len(row) < 12:
+            row.append("")
+            assert len(row) == 12
+
+        # parse the attributes
+        hit_attrs = {"id": row[5], "query_id": qid, "description": row[12]}
+        hsp_attrs = {
+            "evalue": float(row[2]),
+            "bitscore": float(row[3]),
+            "bias": float(row[4]),
+            "model": row[9],
+            "truncated": row[10],
+            "gc": float(row[11]),
+            "is_included": True if row[1] == "!" else False,
+        }
+        hsp_frag_attrs = {
+            "hit_start": int(row[6]) if row[8] == "+" else int(row[7]),
+            "hit_end": int(row[7]) if row[8] == "+" else int(row[6]),
+            "hit_strand": 0 if row[8] == "+" else -1,
+        }
+
+        # create the hsp fragment and set it's attributes
+        hsp_frag = HSPFragment(row[5], qid)
+        for attr, value in hsp_frag_attrs.items():
+            setattr(hsp_frag, attr, value)
+
+        # create the hsp and set it's attributes
+        hsp = HSP([hsp_frag])
+        for attr, value in hsp_attrs.items():
+            setattr(hsp, attr, value)
+
+        # add the hit to the container
+        self._add_hit_to_dict(hit_attrs, hsp, hit_dict)
+
+    def _parse_aln_block(
+        self, hid, qid, model, query_start, query_end, hit_start, hit_end, hit_strand
+    ):
+        """Parse a Infernal HSP alignment block (PRIVATE)."""
+        frag_list = []
+        model_seq = ""
+        hit_seq = ""
+        if model == "cm":
+            annot = {"NC": "", "CS": "", "similarity": "", "PP": ""}
+        else:
+            annot = {"CS": "", "similarity": "", "PP": ""}
+        while True:
+            # we've reached the end of the alignment section
+            if (
+                self.line.startswith(_DIV_ALIGNMENT_START)
+                or self.line.startswith(_DIV_HITS_END_CM)
+                or self.line.startswith(_DIV_HITS_END_HMM)
+            ):
+                # Process local end in infernal hit alignment. Local end are
+                # large insertion or deletion indicated by *[NN]* where N is
+                # the number of model positions are deleted or the number of
+                # residues are inserted in the sequence. We split the
+                # alignment block in HSPs on these local ends.
+
+                # get local ends string (*[NN]*) indexes in the model sequence
+                # there can be more than one local ends back-to-back
+                local_aln_idx = [
+                    (0, 0)
+                ]  # there is always at least one local alignment starting at 0
+                local_aln_idx += [
+                    (m.start(0), m.end(0))
+                    for m in re.finditer(_RE_SPLIT_ALN, model_seq)
+                ]
+
+                prev_hit_start = hit_start if hit_strand == 0 else hit_end
+                prev_model_start = query_start
+                hsps = []
+
+                for i in range(len(local_aln_idx)):
+                    local_start = local_aln_idx[i][1]
+                    local_end = (
+                        local_aln_idx[i + 1][0] if i + 1 < len(local_aln_idx) else None
+                    )
+
+                    # hsp hit position. forward strand moves up, reverse strand moves down
+                    op = operator.add if hit_strand == 0 else operator.sub
+                    cur_hit_seq = hit_seq[local_start:local_end]
+                    cur_hit_gap_size = self._local_aln_gap_size(
+                        local_aln_idx[i], hit_seq
+                    )
+                    cur_hit_start = op(prev_hit_start, cur_hit_gap_size)
+                    cur_hit_end = op(
+                        cur_hit_start, len(re.sub(_RE_LETTERS, "", cur_hit_seq))
+                    )
+                    # adjust start and end elements positon
+                    if hit_strand == 0 and i == 0:
+                        cur_hit_end -= 1
+                    if hit_strand == -1 and i == 0:
+                        cur_hit_end += 1
+                    prev_hit_start = cur_hit_end
+                    # hsp model position
+                    cur_model_seq = model_seq[local_start:local_end].replace(".", "-")
+                    cur_model_gap_size = self._local_aln_gap_size(
+                        local_aln_idx[i], model_seq
+                    )
+                    cur_model_start = prev_model_start + cur_model_gap_size
+                    cur_model_end = cur_model_start + len(
+                        re.sub(_RE_LETTERS, "", cur_model_seq)
+                    )
+                    if i == 0:
+                        cur_model_end -= 1
+                    prev_model_start = cur_model_end
+                    # annotations
+                    cur_annot = {k: v[local_start:local_end] for k, v in annot.items()}
+
+                    # create the hsp fragment and add to container
+                    frag = HSPFragment(hid, qid)
+                    frag.query = cur_model_seq
+                    frag.hit = cur_hit_seq
+                    frag.query_start = cur_model_start
+                    frag.query_end = cur_model_end
+                    frag.hit_start = cur_hit_start if hit_strand == 0 else cur_hit_end
+                    frag.hit_end = cur_hit_end if hit_strand == 0 else cur_hit_start
+                    frag.hit_strand = hit_strand
+                    frag.aln_annotation = cur_annot
+
+                    frag_list.append(frag)
+
+                return frag_list
+
+            # parse the alignment blocks in the hsp
+            # each block have 4 (hmmonly) or 5 (cm) lines followed by an empty line
+            block_size = 6 if model == "cm" else 5
+            offset = 1 if model == "cm" else 0  # offset for the annotation line indexes
+            lines = [None] * block_size
+            for i in range(block_size):
+                lines[i] = self.line
+                self.line = read_forward(self.handle)
+
+            # get the position of the alignment in the string using the PP line
+            blklen = len(lines[4 + offset].strip().split()[0])
+            blkstart = len(lines[4 + offset]) - blklen - 4
+            blkend = len(lines[4 + offset]) - 4
+            model_seq += lines[1 + offset][blkstart:blkend]
+            hit_seq += lines[3 + offset][blkstart:blkend]
+            # NC line is specific to cm model searches
+            if model == "cm":
+                annot["NC"] += lines[0][blkstart:blkend]
+            annot["CS"] += lines[0 + offset][blkstart:blkend]
+            annot["similarity"] += lines[2 + offset][blkstart:blkend]
+            annot["PP"] += lines[4 + offset][blkstart:blkend]
+
+    def _local_aln_gap_size(self, cur_aln_idx, seq):
+        """Calculate the gap size between the local alignments (PRIVATE)."""
+        gap_len = 0
+        if cur_aln_idx[1] > 0:
+            gap_len = sum(
+                [
+                    int(n)
+                    for n in re.findall(
+                        _RE_NUMERIC, seq[cur_aln_idx[0] : cur_aln_idx[1]]
+                    )
+                ]
+            )
+            assert gap_len > 0
+        return gap_len
+
+
+class InfernalTextIndexer(SearchIndexer):
+    """Indexer class for Infernal plain text output."""
+
+    _parser = InfernalTextParser
+
+    def __init__(self, *args, **kwargs):
+        """Initialize the class."""
+        super().__init__(*args, **kwargs)
+        self._preamble = b""
+
+    def __iter__(self):
+        """Iterate over InfernalTextIndexer; yields query results' key, offsets, 0."""
+        handle = self._handle
+        handle.seek(0)
+        start_offset = handle.tell()
+
+        while True:
+            line = read_forward(handle)
+            end_offset = handle.tell()
+
+            if line.startswith(_DIV_QUERY_START.encode()):
+                qresult_key = line.strip().split()[1]
+                # qresult start offset is the offset of this line
+                # (starts with the start mark)
+                start_offset = end_offset - len(line)
+            elif line.startswith(_DIV_QUERY_END.encode()):
+                yield qresult_key.decode(), start_offset, 0
+                start_offset = end_offset
+            elif not line:
+                break
+
+    def get_raw(self, offset):
+        """Return the raw record from the file as a bytes string."""
+        handle = self._handle
+        qresult_raw = b""
+
+        # read header
+        if not self._preamble:
+            handle.seek(0)
+            while True:
+                line = handle.readline()
+                if line.startswith(_DIV_QUERY_START.encode()):
+                    break
+                self._preamble += line
+
+        qresult_raw += self._preamble
+
+        # read the qresult raw string
+        handle.seek(offset)
+        while True:
+            # preserve whitespace, don't use read_forward
+            line = handle.readline()
+            qresult_raw += line
+
+            # break when we've reached qresult end
+            if line.startswith(_DIV_QUERY_END.encode()) or not line:
+                break
+
+        return qresult_raw
+
+
+# if not used as a module, run the doctest
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/InterproscanIO/__init__.py

@@ -0,0 +1,96 @@
+# Copyright 2018 by Adhemar Zerlotini. All rights reserved.
+#
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+"""Bio.SearchIO support for InterProScan output formats.
+
+This module adds support for parsing InterProScan XML output.
+The InterProScan is available as a command line program or on
+EMBL-EBI's web page.
+Bio.SearchIO.InterproscanIO was tested on the following version:
+
+- versions: 5.26-65.0 (interproscan-model-2.1.xsd)
+
+More information about InterProScan are available through these links:
+- Publication: https://www.ncbi.nlm.nih.gov/pmc/articles/PMC3998142/
+- Web interface: https://www.ebi.ac.uk/interpro/search/sequence-search
+- Documentation: https://github.com/ebi-pf-team/interproscan/wiki
+
+
+Supported format
+================
+
+Bio.SearchIO.InterproscanIO supports the following format:
+
+- XML   - 'interproscan-xml' - parsing
+
+
+interproscan-xml
+================
+
+The interproscan-xml parser follows the InterProScan XML described here:
+https://github.com/ebi-pf-team/interproscan/wiki/OutputFormats
+
++--------------+--------------------+------------------------------------------+
+| Object       | Attribute          | XML Element                              |
++==============+====================+==========================================+
+| QueryResult  | target             | ``InterPro``                             |
+|              +--------------------+------------------------------------------+
+|              | program            | ``InterProScan``                         |
+|              +--------------------+------------------------------------------+
+|              | version            | ``protein-matches.interproscan-version`` |
++--------------+--------------------+------------------------------------------+
+| Hit          | accession          | ``signature.name``                       |
+|              +--------------------+------------------------------------------+
+|              | id                 | ``signature.ac``                         |
+|              +--------------------+------------------------------------------+
+|              | description        | ``signature.desc``                       |
+|              +--------------------+------------------------------------------+
+|              | dbxrefs            | ``IPR:entry.ac``                         |
+|              |                    | ``go-xref.id``                           |
+|              |                    | ``pathway-xref.db:pathway-xref.id``      |
+|              +--------------------+------------------------------------------+
+|              | attributes         |                                          |
+|              | ['Target']         | ``*-match`` / ``*-location``             |
+|              | ['Target version'] | ``signature-library-release.library``    |
+|              | ['Hit type']       | ``signature-library-release.version``    |
++--------------+--------------------+------------------------------------------+
+| HSP          | bitscore           | ``*-location.score``                     |
+|              +--------------------+------------------------------------------+
+|              | evalue             | ``*-location.evalue``                    |
++--------------+--------------------+------------------------------------------+
+| HSPFragment  | query_start        | ``*-location.start``                     |
+| (also via    +--------------------+------------------------------------------+
+| HSP)         | query_end          | ``*-location.end``                       |
+|              +--------------------+------------------------------------------+
+|              | hit_start          | ``*-location.hmm-start``                 |
+|              +--------------------+------------------------------------------+
+|              | hit_end            | ``*-location.hmm-end``                   |
+|              +--------------------+------------------------------------------+
+|              | query              | ``sequence``                             |
++--------------+--------------------+------------------------------------------+
+
+InterProScan XML files may contain a match with multiple locations or multiple
+matches to the same protein with a single location. In both cases, the match
+is uniquely stored as a HIT object and the locations as HSP objects.
+
+``HSP.*start == *start - 1`` (Since every start position is 0-based in Biopython)
+
+``HSP.aln_span ==  query-end - query-start``
+
+The types of matches or locations (eg. hmmer3-match, hmmer3-location,
+coils-match, panther-location) are stored in hit.attributes['Hit type'].
+For instance, for every 'phobious-match', there will be a 'phobious-location'.
+Therefore, Hit.type will store the string excluding '-match' or '-location'
+('phobious', in this example).
+"""
+
+from .interproscan_xml import InterproscanXmlParser
+
+# if not used as a module, run the doctest
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/InterproscanIO/interproscan_xml.py

@@ -0,0 +1,196 @@
+# Copyright 2018 by Adhemar Zerlotini. All rights reserved.
+#
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+
+"""Bio.SearchIO parser for InterProScan XML output formats."""
+# for more info: https://github.com/ebi-pf-team/interproscan/wiki/OutputFormats
+
+import re
+from xml.etree import ElementTree
+
+from Bio.SearchIO._model import Hit
+from Bio.SearchIO._model import HSP
+from Bio.SearchIO._model import HSPFragment
+from Bio.SearchIO._model import QueryResult
+
+# element - hit attribute name mapping
+_ELEM_HIT = {
+    "name": ("accession", str),
+    "ac": ("id", str),
+    "desc": ("description", str),
+}
+# element - hsp attribute name mapping
+_ELEM_HSP = {"score": ("bitscore", float), "evalue": ("evalue", float)}
+# element - fragment attribute name mapping
+_ELEM_FRAG = {
+    "start": ("query_start", int),
+    "end": ("query_end", int),
+    "hmm-start": ("hit_start", int),
+    "hmm-end": ("hit_end", int),
+}
+
+
+class InterproscanXmlParser:
+    """Parser for the InterProScan XML format."""
+
+    def __init__(self, handle):
+        """Initialize the class."""
+        self.xml_iter = iter(ElementTree.iterparse(handle, events=("start", "end")))
+        self._meta = self._parse_header()
+
+    def __iter__(self):
+        """Iterate qresults."""
+        yield from self._parse_qresult()
+
+    def _parse_header(self):
+        """Parse the header for the InterProScan version (PRIVATE)."""
+        event, elem = next(self.xml_iter)
+        meta = {}
+        meta["target"] = "InterPro"
+        meta["program"] = "InterProScan"
+        meta["version"] = elem.attrib["interproscan-version"]
+        # store the namespace value
+        self.NS = re.sub("protein-matches", "", elem.tag)
+        return meta
+
+    def _parse_qresult(self):
+        """Parse query results (PRIVATE)."""
+        for event, elem in self.xml_iter:
+            if event == "end" and elem.tag == self.NS + "protein":
+                # store the query sequence
+                seq = elem.find(self.NS + "sequence")
+                query_seq = seq.text
+
+                # store the query id and description
+                xref = elem.find(self.NS + "xref")
+                query_id = xref.attrib["id"]
+                query_desc = xref.attrib["name"]
+
+                # parse each hit
+                hit_list = []
+                for hit_new in self._parse_hit(
+                    elem.find(self.NS + "matches"), query_id, query_seq
+                ):
+                    # interproscan results contain duplicate hits rather than
+                    # a single hit with multiple hsps. In this case the hsps
+                    # of a duplicate hit will be appended to the already
+                    # existing hit
+                    for hit in hit_list:
+                        if hit.id == hit_new.id:
+                            for hsp in hit_new.hsps:
+                                hit.hsps.append(hsp)
+                            break
+                    else:
+                        hit_list.append(hit_new)
+
+                # create qresult and assign attributes
+                qresult = QueryResult(hit_list, query_id)
+                setattr(qresult, "description", query_desc)
+                for key, value in self._meta.items():
+                    setattr(qresult, key, value)
+                yield qresult
+
+    def _parse_hit(self, root_hit_elem, query_id, query_seq=None):
+        """Parse hit (PRIVATE)."""
+        # feed the loop below an empty list so iteration still works
+        if root_hit_elem is None:
+            root_hit_elem = []
+
+        for hit_elem in root_hit_elem:
+            # store the match/location type
+            hit_type = re.sub(r"%s(\w+)-match" % self.NS, r"\1", hit_elem.find(".").tag)
+            # store the hit id
+            signature = hit_elem.find(self.NS + "signature")
+            hit_id = signature.attrib["ac"]
+
+            # store xrefs and alt_descs
+            xrefs = self._parse_xrefs(signature.find(self.NS + "entry"))
+
+            # parse each hsp
+            hsps = list(
+                self._parse_hsp(
+                    hit_elem.find(self.NS + "locations"), query_id, hit_id, query_seq
+                )
+            )
+
+            # create hit and assign attributes
+            hit = Hit(hsps, hit_id)
+            setattr(hit, "dbxrefs", xrefs)
+            for key, (attr, caster) in _ELEM_HIT.items():
+                value = signature.attrib.get(key)
+                if value is not None:
+                    setattr(hit, attr, caster(value))
+            # format specific attributes
+            hit.attributes["Hit type"] = hit_type
+            signature_lib = signature.find(self.NS + "signature-library-release")
+            hit.attributes["Target"] = str(signature_lib.attrib.get("library"))
+            hit.attributes["Target version"] = str(signature_lib.attrib.get("version"))
+
+            yield hit
+
+    def _parse_hsp(self, root_hsp_elem, query_id, hit_id, query_seq=None):
+        """Parse hsp (PRIVATE)."""
+        # feed the loop below an empty list so iteration still works
+        if root_hsp_elem is None:
+            root_hsp_elem = []
+
+        for hsp_elem in root_hsp_elem:
+            # create frag and assign attributes
+            frag = HSPFragment(hit_id, query_id)
+            setattr(frag, "molecule_type", "protein")
+            if query_seq is not None:
+                setattr(frag, "query", query_seq)
+            for key, (attr, caster) in _ELEM_FRAG.items():
+                value = hsp_elem.attrib.get(key)
+                if value is not None:
+                    # start should be 0-based
+                    if attr.endswith("start"):
+                        value = caster(value) - 1
+                    # store query start and end to calculate aln_span
+                    if attr == "query_start":
+                        start = int(value)
+                    if attr == "query_end":
+                        end = int(value)
+                    setattr(frag, attr, caster(value))
+            # calculate aln_span and store
+            setattr(frag, "aln_span", end - start)
+
+            # create hsp and assign attributes
+            hsp = HSP([frag])
+            setattr(hsp, "query_id", query_id)
+            setattr(hsp, "hit_id", hit_id)
+            for key, (attr, caster) in _ELEM_HSP.items():
+                value = hsp_elem.attrib.get(key)
+                if value is not None:
+                    setattr(hsp, attr, caster(value))
+            yield hsp
+
+    def _parse_xrefs(self, root_entry_elem):
+        """Parse xrefs (PRIVATE)."""
+        xrefs = []
+        # store entry id and description
+        if root_entry_elem is not None:
+            xrefs.append("IPR:" + root_entry_elem.attrib["ac"])
+
+        # store go-xrefs and pathway-refs id and description
+        if root_entry_elem is not None:
+            xref_elems = []
+            xref_elems = xref_elems + root_entry_elem.findall(self.NS + "go-xref")
+            xref_elems = xref_elems + root_entry_elem.findall(self.NS + "pathway-xref")
+
+            for entry in xref_elems:
+                xref = entry.attrib["id"]
+                if ":" not in xref:
+                    xref = entry.attrib["db"] + ":" + xref
+                xrefs.append(xref)
+        return xrefs
+
+
+# if not used as a module, run the doctest
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/__init__.py

@@ -0,0 +1,684 @@
+# Copyright 2012 by Wibowo Arindrarto.  All rights reserved.
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+
+"""Biopython interface for sequence search program outputs.
+
+The SearchIO submodule provides parsers, indexers, and writers for outputs from
+various sequence search programs. It provides an API similar to SeqIO and
+AlignIO, with the following main functions: ``parse``, ``read``, ``to_dict``,
+``index``, ``index_db``, ``write``, and ``convert``.
+
+SearchIO parses a search output file's contents into a hierarchy of four nested
+objects: QueryResult, Hit, HSP, and HSPFragment. Each of them models a part of
+the search output file:
+
+    - QueryResult represents a search query. This is the main object returned
+      by the input functions and it contains all other objects.
+    - Hit represents a database hit,
+    - HSP represents high-scoring alignment region(s) in the hit,
+    - HSPFragment represents a contiguous alignment within the HSP
+
+In addition to the four objects above, SearchIO is also tightly integrated with
+the SeqRecord objects (see SeqIO) and MultipleSeqAlignment objects (see
+AlignIO). SeqRecord objects are used to store the actual matching hit and query
+sequences, while MultipleSeqAlignment objects store the alignment between them.
+
+A detailed description of these objects' features and their example usages are
+available in their respective documentations.
+
+
+Input
+=====
+The main function for parsing search output files is Bio.SearchIO.parse(...).
+This function parses a given search output file and returns a generator object
+that yields one QueryResult object per iteration.
+
+``parse`` takes two arguments: 1) a file handle or a filename of the input file
+(the search output file) and 2) the format name.
+
+    >>> from Bio import SearchIO
+    >>> for qresult in SearchIO.parse('Blast/mirna.xml', 'blast-xml'):
+    ...     print("%s %s" % (qresult.id, qresult.description))
+    ...
+    33211 mir_1
+    33212 mir_2
+    33213 mir_3
+
+SearchIO also provides the Bio.SearchIO.read(...) function, which is intended
+for use on search output files containing only one query. ``read`` returns one
+QueryResult object and will raise an exception if the source file contains more
+than one query:
+
+    >>> qresult = SearchIO.read('Blast/xml_2226_blastp_004.xml', 'blast-xml')
+    >>> print("%s %s" % (qresult.id, qresult.description))
+    ...
+    gi|11464971:4-101 pleckstrin [Mus musculus]
+
+    >>> SearchIO.read('Blast/mirna.xml', 'blast-xml')
+    Traceback (most recent call last):
+    ...
+    ValueError: ...
+
+For accessing search results of large output files, you may use the indexing
+functions Bio.SearchIO.index(...) or Bio.SearchIO.index_db(...). They have a
+similar interface to their counterparts in SeqIO and AlignIO, with the addition
+of optional, format-specific keyword arguments.
+
+
+Output
+======
+SearchIO has write support for several formats, accessible from the
+Bio.SearchIO.write(...) function. This function returns a tuple of four
+numbers: the number of QueryResult, Hit, HSP, and HSPFragment written::
+
+    qresults = SearchIO.parse('Blast/mirna.xml', 'blast-xml')
+    SearchIO.write(qresults, 'results.tab', 'blast-tab')
+    <stdout> (3, 239, 277, 277)
+
+Note that different writers may require different attribute values of the
+SearchIO objects. This limits the scope of writable search results to search
+results possessing the required attributes.
+
+For example, the writer for HMMER domain table output requires
+the conditional e-value attribute from each HSP object, among others. If you
+try to write to the HMMER domain table format and your HSPs do not have this
+attribute, an exception will be raised.
+
+
+Conversion
+==========
+SearchIO provides a shortcut function Bio.SearchIO.convert(...) to convert a
+given file into another format. Under the hood, ``convert`` simply parses a given
+output file and writes it to another using the ``parse`` and ``write`` functions.
+
+Note that the same restrictions found in Bio.SearchIO.write(...) apply to the
+convert function as well.
+
+
+Conventions
+===========
+The main goal of creating SearchIO is to have a common, easy to use interface
+across different search output files. As such, we have also created some
+conventions / standards for SearchIO that extend beyond the common object model.
+These conventions apply to all files parsed by SearchIO, regardless of their
+individual formats.
+
+Python-style sequence coordinates
+---------------------------------
+
+When storing sequence coordinates (start and end values), SearchIO uses
+the Python-style slice convention: zero-based and half-open intervals. For
+example, if in a BLAST XML output file the start and end coordinates of an
+HSP are 10 and 28, they would become 9 and 28 in SearchIO. The start
+coordinate becomes 9 because Python indices start from zero, while the end
+coordinate remains 28 as Python slices omit the last item in an interval.
+
+Beside giving you the benefits of standardization, this convention also
+makes the coordinates usable for slicing sequences. For example, given a
+full query sequence and the start and end coordinates of an HSP, one can
+use the coordinates to extract part of the query sequence that results in
+the database hit.
+
+When these objects are written to an output file using
+SearchIO.write(...), the coordinate values are restored to their
+respective format's convention. Using the example above, if the HSP would
+be written to an XML file, the start and end coordinates would become 10
+and 28 again.
+
+Sequence coordinate order
+-------------------------
+
+Some search output formats reverse the start and end coordinate sequences
+according to the sequence's strand.
+
+In SearchIO, start coordinates are always smaller than the end
+coordinates, regardless of their originating strand. This ensures
+consistency when using the coordinates to slice full sequences.
+
+Note that this coordinate order convention is only enforced in the
+HSPFragment level. If an HSP object has several HSPFragment objects, each
+individual fragment will conform to this convention. But the order of the
+fragments within the HSP object follows what the search output file uses.
+
+Similar to the coordinate style convention, the start and end coordinates'
+order are restored to their respective formats when the objects are
+written using Bio.SearchIO.write(...).
+
+Frames and strand values
+------------------------
+
+SearchIO only allows -1, 0, 1 and None as strand values. For frames, the
+only allowed values are integers from -3 to 3 (inclusive) and None. Both
+of these are standard Biopython conventions.
+
+
+Supported Formats
+=================
+Below is a list of search program output formats supported by SearchIO.
+
+Support for parsing, indexing, and writing:
+
+ - blast-tab        - BLAST+ tabular output. Both variants without comments
+                      (-m 6 flag) and with comments (-m 7 flag) are supported.
+ - blast-xml        - BLAST+ XML output.
+ - blat-psl         - The default output of BLAT (PSL format). Variants with or
+                      without header are both supported. PSLX (PSL + sequences)
+                      is also supported.
+ - hmmer3-tab       - HMMER3 table output.
+ - hmmer3-domtab    - HMMER3 domain table output. When using this format, the
+                      program name has to be specified. For example, for parsing
+                      hmmscan output, the name would be 'hmmscan-domtab'.
+
+Support for parsing and indexing:
+
+ - exonerate-text   - Exonerate plain text output.
+ - exonerate-vulgar - Exonerate vulgar line.
+ - exonerate-cigar  - Exonerate cigar line.
+ - fasta-m10        - Bill Pearson's FASTA -m 10 output.
+ - hmmer3-text      - HMMER3 regular text output format. Supported HMMER3
+                      subprograms are hmmscan, hmmsearch, and phmmer.
+ - hmmer2-text      - HMMER2 regular text output format. Supported HMMER2
+                      subprograms are hmmpfam, hmmsearch.
+ - infernal-tab     - Infernal tabular output.
+ - infernal-text    - Infernal regular text output. Supported Infernal
+                      subprograms are cmsearch and cmscan.
+
+Support for parsing:
+
+ - hhsuite2-text    - HHSUITE plain text output.
+
+Each of these formats have different keyword arguments available for use with
+the main SearchIO functions. More details and examples are available in each
+of the format's documentation.
+
+"""
+
+from Bio.File import as_handle
+from Bio.SearchIO._model import Hit
+from Bio.SearchIO._model import HSP
+from Bio.SearchIO._model import HSPFragment
+from Bio.SearchIO._model import QueryResult
+from Bio.SearchIO._utils import get_processor
+
+__all__ = ("read", "parse", "to_dict", "index", "index_db", "write", "convert")
+
+
+# dictionary of supported formats for parse() and read()
+_ITERATOR_MAP = {
+    "blast-tab": ("BlastIO", "BlastTabParser"),
+    "blast-xml": ("BlastIO", "BlastXmlParser"),
+    "blat-psl": ("BlatIO", "BlatPslParser"),
+    "exonerate-cigar": ("ExonerateIO", "ExonerateCigarParser"),
+    "exonerate-text": ("ExonerateIO", "ExonerateTextParser"),
+    "exonerate-vulgar": ("ExonerateIO", "ExonerateVulgarParser"),
+    "fasta-m10": ("FastaIO", "FastaM10Parser"),
+    "hhsuite2-text": ("HHsuiteIO", "Hhsuite2TextParser"),
+    "hhsuite3-text": ("HHsuiteIO", "Hhsuite2TextParser"),
+    "hmmer2-text": ("HmmerIO", "Hmmer2TextParser"),
+    "hmmer3-text": ("HmmerIO", "Hmmer3TextParser"),
+    "hmmer3-tab": ("HmmerIO", "Hmmer3TabParser"),
+    # for hmmer3-domtab, the specific program is part of the format name
+    # as we need it distinguish hit / target coordinates
+    "hmmscan3-domtab": ("HmmerIO", "Hmmer3DomtabHmmhitParser"),
+    "hmmsearch3-domtab": ("HmmerIO", "Hmmer3DomtabHmmqueryParser"),
+    "infernal-tab": ("InfernalIO", "InfernalTabParser"),
+    "infernal-text": ("InfernalIO", "InfernalTextParser"),
+    "interproscan-xml": ("InterproscanIO", "InterproscanXmlParser"),
+    "phmmer3-domtab": ("HmmerIO", "Hmmer3DomtabHmmqueryParser"),
+}
+
+# dictionary of supported formats for index()
+_INDEXER_MAP = {
+    "blast-tab": ("BlastIO", "BlastTabIndexer"),
+    "blast-xml": ("BlastIO", "BlastXmlIndexer"),
+    "blat-psl": ("BlatIO", "BlatPslIndexer"),
+    "exonerate-cigar": ("ExonerateIO", "ExonerateCigarIndexer"),
+    "exonerate-text": ("ExonerateIO", "ExonerateTextIndexer"),
+    "exonerate-vulgar": ("ExonerateIO", "ExonerateVulgarIndexer"),
+    "fasta-m10": ("FastaIO", "FastaM10Indexer"),
+    "hmmer2-text": ("HmmerIO", "Hmmer2TextIndexer"),
+    "hmmer3-text": ("HmmerIO", "Hmmer3TextIndexer"),
+    "hmmer3-tab": ("HmmerIO", "Hmmer3TabIndexer"),
+    "hmmscan3-domtab": ("HmmerIO", "Hmmer3DomtabHmmhitIndexer"),
+    "hmmsearch3-domtab": ("HmmerIO", "Hmmer3DomtabHmmqueryIndexer"),
+    "infernal-tab": ("InfernalIO", "InfernalTabIndexer"),
+    "infernal-text": ("InfernalIO", "InfernalTextIndexer"),
+    "phmmer3-domtab": ("HmmerIO", "Hmmer3DomtabHmmqueryIndexer"),
+}
+
+# dictionary of supported formats for write()
+_WRITER_MAP = {
+    "blast-tab": ("BlastIO", "BlastTabWriter"),
+    "blast-xml": ("BlastIO", "BlastXmlWriter"),
+    "blat-psl": ("BlatIO", "BlatPslWriter"),
+    "hmmer3-tab": ("HmmerIO", "Hmmer3TabWriter"),
+    "hmmscan3-domtab": ("HmmerIO", "Hmmer3DomtabHmmhitWriter"),
+    "hmmsearch3-domtab": ("HmmerIO", "Hmmer3DomtabHmmqueryWriter"),
+    "phmmer3-domtab": ("HmmerIO", "Hmmer3DomtabHmmqueryWriter"),
+}
+
+
+def parse(handle, format=None, **kwargs):
+    """Iterate over search tool output file as QueryResult objects.
+
+    Arguments:
+     - handle - Handle to the file, or the filename as a string.
+     - format - Lower case string denoting one of the supported formats.
+     - kwargs - Format-specific keyword arguments.
+
+    This function is used to iterate over each query in a given search output
+    file:
+
+    >>> from Bio import SearchIO
+    >>> qresults = SearchIO.parse('Blast/mirna.xml', 'blast-xml')
+    >>> qresults
+    <generator object ...>
+    >>> for qresult in qresults:
+    ...     print("Search %s has %i hits" % (qresult.id, len(qresult)))
+    ...
+    Search 33211 has 100 hits
+    Search 33212 has 44 hits
+    Search 33213 has 95 hits
+
+    Depending on the file format, ``parse`` may also accept additional keyword
+    argument(s) that modifies the behavior of the format parser. Here is a
+    simple example, where the keyword argument enables parsing of a commented
+    BLAST tabular output file:
+
+    >>> from Bio import SearchIO
+    >>> for qresult in SearchIO.parse('Blast/mirna.tab', 'blast-tab', comments=True):
+    ...     print("Search %s has %i hits" % (qresult.id, len(qresult)))
+    ...
+    Search 33211 has 100 hits
+    Search 33212 has 44 hits
+    Search 33213 has 95 hits
+
+    """
+    # get the iterator object and do error checking
+    iterator = get_processor(format, _ITERATOR_MAP)
+
+    # HACK: force BLAST XML decoding to use utf-8
+    handle_kwargs = {}
+    if format == "blast-xml":
+        handle_kwargs["encoding"] = "utf-8"
+
+    # and start iterating
+    with as_handle(handle, **handle_kwargs) as source_file:
+        generator = iterator(source_file, **kwargs)
+        yield from generator
+
+
+def read(handle, format=None, **kwargs):
+    """Turn a search output file containing one query into a single QueryResult.
+
+     - handle - Handle to the file, or the filename as a string.
+     - format - Lower case string denoting one of the supported formats.
+     - kwargs - Format-specific keyword arguments.
+
+    ``read`` is used for parsing search output files containing exactly one query:
+
+    >>> from Bio import SearchIO
+    >>> qresult = SearchIO.read('Blast/xml_2226_blastp_004.xml', 'blast-xml')
+    >>> print("%s %s" % (qresult.id, qresult.description))
+    ...
+    gi|11464971:4-101 pleckstrin [Mus musculus]
+
+    If the given handle has no results, an exception will be raised:
+
+    >>> from Bio import SearchIO
+    >>> qresult = SearchIO.read('Blast/tab_2226_tblastn_002.txt', 'blast-tab')
+    Traceback (most recent call last):
+    ...
+    ValueError: No query results found in handle
+
+    Similarly, if the given handle has more than one result, an exception will
+    be raised:
+
+    >>> from Bio import SearchIO
+    >>> qresult = SearchIO.read('Blast/tab_2226_tblastn_001.txt', 'blast-tab')
+    Traceback (most recent call last):
+    ...
+    ValueError: More than one query result found in handle
+
+    Like ``parse``, ``read`` may also accept keyword argument(s) depending on the
+    search output file format.
+
+    """
+    query_results = parse(handle, format, **kwargs)
+
+    try:
+        query_result = next(query_results)
+    except StopIteration:
+        raise ValueError("No query results found in handle") from None
+    try:
+        next(query_results)
+        raise ValueError("More than one query result found in handle")
+    except StopIteration:
+        pass
+
+    return query_result
+
+
+def to_dict(qresults, key_function=None):
+    """Turn a QueryResult iterator or list into a dictionary.
+
+     - qresults     - Iterable returning QueryResult objects.
+     - key_function - Optional callback function which when given a
+                      QueryResult object should return a unique key for the
+                      dictionary. Defaults to using .id of the result.
+
+    This function enables access of QueryResult objects from a single search
+    output file using its identifier.
+
+    >>> from Bio import SearchIO
+    >>> qresults = SearchIO.parse('Blast/wnts.xml', 'blast-xml')
+    >>> search_dict = SearchIO.to_dict(qresults)
+    >>> list(search_dict)
+    ['gi|195230749:301-1383', 'gi|325053704:108-1166', ..., 'gi|53729353:216-1313']
+    >>> search_dict['gi|156630997:105-1160']
+    QueryResult(id='gi|156630997:105-1160', 5 hits)
+
+    By default, the dictionary key is the QueryResult's string ID. This may be
+    changed by supplying a callback function that returns the desired identifier.
+    Here is an example using a function that removes the 'gi|' part in the
+    beginning of the QueryResult ID.
+
+    >>> from Bio import SearchIO
+    >>> qresults = SearchIO.parse('Blast/wnts.xml', 'blast-xml')
+    >>> key_func = lambda qresult: qresult.id.split('|')[1]
+    >>> search_dict = SearchIO.to_dict(qresults, key_func)
+    >>> list(search_dict)
+    ['195230749:301-1383', '325053704:108-1166', ..., '53729353:216-1313']
+    >>> search_dict['156630997:105-1160']
+    QueryResult(id='gi|156630997:105-1160', 5 hits)
+
+    Note that the callback function does not change the QueryResult's ID value.
+    It only changes the key value used to retrieve the associated QueryResult.
+
+    As this function loads all QueryResult objects into memory, it may be
+    unsuitable for dealing with files containing many queries. In that case, it
+    is recommended that you use either ``index`` or ``index_db``.
+
+    Since Python 3.7, the default dict class maintains key order, meaning
+    this dictionary will reflect the order of records given to it. For
+    CPython and PyPy, this was already implemented for Python 3.6, so
+    effectively you can always assume the record order is preserved.
+    """
+
+    def _default_key_function(rec):
+        return rec.id
+
+    if key_function is None:
+        key_function = _default_key_function
+
+    qdict = {}
+    for qresult in qresults:
+        key = key_function(qresult)
+        if key in qdict:
+            raise ValueError("Duplicate key %r" % key)
+        qdict[key] = qresult
+    return qdict
+
+
+def index(filename, format=None, key_function=None, **kwargs):
+    """Indexes a search output file and returns a dictionary-like object.
+
+     - filename     - string giving name of file to be indexed
+     - format       - Lower case string denoting one of the supported formats.
+     - key_function - Optional callback function which when given a
+                      QueryResult should return a unique key for the dictionary.
+     - kwargs       - Format-specific keyword arguments.
+
+    Index returns a pseudo-dictionary object with QueryResult objects as its
+    values and a string identifier as its keys. The function is mainly useful
+    for dealing with large search output files, as it enables access to any
+    given QueryResult object much faster than using parse or read.
+
+    Index works by storing in-memory the start locations of all queries in a
+    file. When a user requests access to the query, this function will jump
+    to its start position, parse the whole query, and return it as a
+    QueryResult object:
+
+    >>> from Bio import SearchIO
+    >>> search_idx = SearchIO.index('Blast/wnts.xml', 'blast-xml')
+    >>> search_idx
+    SearchIO.index('Blast/wnts.xml', 'blast-xml', key_function=None)
+    >>> sorted(search_idx)
+    ['gi|156630997:105-1160', 'gi|195230749:301-1383', ..., 'gi|53729353:216-1313']
+    >>> search_idx['gi|195230749:301-1383']
+    QueryResult(id='gi|195230749:301-1383', 5 hits)
+    >>> search_idx.close()
+
+    If the file is BGZF compressed, this is detected automatically. Ordinary
+    GZIP files are not supported:
+
+    >>> from Bio import SearchIO
+    >>> search_idx = SearchIO.index('Blast/wnts.xml.bgz', 'blast-xml')
+    >>> search_idx
+    SearchIO.index('Blast/wnts.xml.bgz', 'blast-xml', key_function=None)
+    >>> search_idx['gi|195230749:301-1383']
+    QueryResult(id='gi|195230749:301-1383', 5 hits)
+    >>> search_idx.close()
+
+    You can supply a custom callback function to alter the default identifier
+    string. This function should accept as its input the QueryResult ID string
+    and return a modified version of it.
+
+    >>> from Bio import SearchIO
+    >>> key_func = lambda id: id.split('|')[1]
+    >>> search_idx = SearchIO.index('Blast/wnts.xml', 'blast-xml', key_func)
+    >>> search_idx
+    SearchIO.index('Blast/wnts.xml', 'blast-xml', key_function=<function <lambda> at ...>)
+    >>> sorted(search_idx)
+    ['156630997:105-1160', ..., '371502086:108-1205', '53729353:216-1313']
+    >>> search_idx['156630997:105-1160']
+    QueryResult(id='gi|156630997:105-1160', 5 hits)
+    >>> search_idx.close()
+
+    Note that the callback function does not change the QueryResult's ID value.
+    It only changes the key value used to retrieve the associated QueryResult.
+
+    """
+    if not isinstance(filename, str):
+        raise TypeError("Need a filename (not a handle)")
+
+    from Bio.File import _IndexedSeqFileDict
+
+    proxy_class = get_processor(format, _INDEXER_MAP)
+    repr = f"SearchIO.index({filename!r}, {format!r}, key_function={key_function!r})"
+    return _IndexedSeqFileDict(
+        proxy_class(filename, **kwargs), key_function, repr, "QueryResult"
+    )
+
+
+def index_db(index_filename, filenames=None, format=None, key_function=None, **kwargs):
+    """Indexes several search output files into an SQLite database.
+
+     - index_filename - The SQLite filename.
+     - filenames    - List of strings specifying file(s) to be indexed, or when
+                      indexing a single file this can be given as a string.
+                      (optional if reloading an existing index, but must match)
+     - format       - Lower case string denoting one of the supported formats.
+                      (optional if reloading an existing index, but must match)
+     - key_function - Optional callback function which when given a
+                      QueryResult identifier string should return a unique
+                      key for the dictionary.
+     - kwargs       - Format-specific keyword arguments.
+
+    The ``index_db`` function is similar to ``index`` in that it indexes the start
+    position of all queries from search output files. The main difference is
+    instead of storing these indices in-memory, they are written to disk as an
+    SQLite database file. This allows the indices to persist between Python
+    sessions. This enables access to any queries in the file without any
+    indexing overhead, provided it has been indexed at least once.
+
+    >>> from Bio import SearchIO
+    >>> idx_filename = ":memory:" # Use a real filename, this is in RAM only!
+    >>> db_idx = SearchIO.index_db(idx_filename, 'Blast/mirna.xml', 'blast-xml')
+    >>> sorted(db_idx)
+    ['33211', '33212', '33213']
+    >>> db_idx['33212']
+    QueryResult(id='33212', 44 hits)
+    >>> db_idx.close()
+
+    ``index_db`` can also index multiple files and store them in the same
+    database, making it easier to group multiple search files and access them
+    from a single interface.
+
+    >>> from Bio import SearchIO
+    >>> idx_filename = ":memory:" # Use a real filename, this is in RAM only!
+    >>> files = ['Blast/mirna.xml', 'Blast/wnts.xml']
+    >>> db_idx = SearchIO.index_db(idx_filename, files, 'blast-xml')
+    >>> sorted(db_idx)
+    ['33211', '33212', '33213', 'gi|156630997:105-1160', ..., 'gi|53729353:216-1313']
+    >>> db_idx['33212']
+    QueryResult(id='33212', 44 hits)
+    >>> db_idx.close()
+
+    One common example where this is helpful is if you had a large set of
+    query sequences (say ten thousand) which you split into ten query files
+    of one thousand sequences each in order to run as ten separate BLAST jobs
+    on a cluster. You could use ``index_db`` to index the ten BLAST output
+    files together for seamless access to all the results as one dictionary.
+
+    Note that ':memory:' rather than an index filename tells SQLite to hold
+    the index database in memory. This is useful for quick tests, but using
+    the Bio.SearchIO.index(...) function instead would use less memory.
+
+    BGZF compressed files are supported, and detected automatically. Ordinary
+    GZIP compressed files are not supported.
+
+    See also Bio.SearchIO.index(), Bio.SearchIO.to_dict(), and the Python module
+    glob which is useful for building lists of files.
+    """
+    # cast filenames to list if it's a string
+    # (can we check if it's a string or a generator?)
+    if isinstance(filenames, str):
+        filenames = [filenames]
+
+    from Bio.File import _SQLiteManySeqFilesDict
+
+    repr = f"SearchIO.index_db({index_filename!r}, filenames={filenames!r}, {format!r}, key_function={key_function!r})"
+
+    def proxy_factory(format, filename=None):
+        """Given a filename returns proxy object, else boolean if format OK."""
+        if filename:
+            return get_processor(format, _INDEXER_MAP)(filename, **kwargs)
+        else:
+            return format in _INDEXER_MAP
+
+    return _SQLiteManySeqFilesDict(
+        index_filename, filenames, proxy_factory, format, key_function, repr
+    )
+
+
+def write(qresults, handle, format=None, **kwargs):
+    """Write QueryResult objects to a file in the given format.
+
+     - qresults - An iterator returning QueryResult objects or a single
+                  QueryResult object.
+     - handle   - Handle to the file, or the filename as a string.
+     - format   - Lower case string denoting one of the supported formats.
+     - kwargs   - Format-specific keyword arguments.
+
+    The ``write`` function writes QueryResult object(s) into the given output
+    handle / filename. You can supply it with a single QueryResult object or an
+    iterable returning one or more QueryResult objects. In both cases, the
+    function will return a tuple of four values: the number of QueryResult, Hit,
+    HSP, and HSPFragment objects it writes to the output file::
+
+        from Bio import SearchIO
+        qresults = SearchIO.parse('Blast/mirna.xml', 'blast-xml')
+        SearchIO.write(qresults, 'results.tab', 'blast-tab')
+        <stdout> (3, 239, 277, 277)
+
+    The output of different formats may be adjusted using the format-specific
+    keyword arguments. Here is an example that writes BLAT PSL output file with
+    a header::
+
+        from Bio import SearchIO
+        qresults = SearchIO.parse('Blat/psl_34_001.psl', 'blat-psl')
+        SearchIO.write(qresults, 'results.tab', 'blat-psl', header=True)
+        <stdout> (2, 13, 22, 26)
+
+    """
+    # turn qresults into an iterator if it's a single QueryResult object
+    if isinstance(qresults, QueryResult):
+        qresults = iter([qresults])
+    else:
+        qresults = iter(qresults)
+
+    # get the writer object and do error checking
+    writer_class = get_processor(format, _WRITER_MAP)
+
+    # write to the handle
+    with as_handle(handle, "w") as target_file:
+        writer = writer_class(target_file, **kwargs)
+        # count how many qresults, hits, and hsps
+        qresult_count, hit_count, hsp_count, frag_count = writer.write_file(qresults)
+
+    return qresult_count, hit_count, hsp_count, frag_count
+
+
+def convert(in_file, in_format, out_file, out_format, in_kwargs=None, out_kwargs=None):
+    """Convert between two search output formats, return number of records.
+
+     - in_file    - Handle to the input file, or the filename as string.
+     - in_format  - Lower case string denoting the format of the input file.
+     - out_file   - Handle to the output file, or the filename as string.
+     - out_format - Lower case string denoting the format of the output file.
+     - in_kwargs  - Dictionary of keyword arguments for the input function.
+     - out_kwargs - Dictionary of keyword arguments for the output function.
+
+    The convert function is a shortcut function for ``parse`` and ``write``. It has
+    the same return type as ``write``. Format-specific arguments may be passed to
+    the convert function, but only as dictionaries.
+
+    Here is an example of using ``convert`` to convert from a BLAST+ XML file
+    into a tabular file with comments::
+
+        from Bio import SearchIO
+        in_file = 'Blast/mirna.xml'
+        in_fmt = 'blast-xml'
+        out_file = 'results.tab'
+        out_fmt = 'blast-tab'
+        out_kwarg = {'comments': True}
+        SearchIO.convert(in_file, in_fmt, out_file, out_fmt, out_kwargs=out_kwarg)
+        <stdout> (3, 239, 277, 277)
+
+    Given that different search output file provide different statistics and
+    different level of details, the convert function is limited only to
+    converting formats that have the same statistics and for conversion to
+    formats with the same level of detail, or less.
+
+    For example, converting from a BLAST+ XML output to a HMMER table file
+    is not possible, as these are two search programs with different kinds of
+    statistics. In theory, you may provide the necessary values required by the
+    HMMER table file (e.g. conditional e-values, envelope coordinates, etc).
+    However, these values are likely to hold little meaning as they are not true
+    HMMER-computed values.
+
+    Another example is converting from BLAST+ XML to BLAST+ tabular file. This
+    is possible, as BLAST+ XML provide all the values necessary to create a
+    BLAST+ tabular file. However, the reverse conversion may not be possible.
+    There are more details covered in the XML file that are not found in a
+    tabular file (e.g. the lambda and kappa values)
+
+    """
+    if in_kwargs is None:
+        in_kwargs = {}
+    if out_kwargs is None:
+        out_kwargs = {}
+
+    qresults = parse(in_file, in_format, **in_kwargs)
+    return write(qresults, out_file, out_format, **out_kwargs)
+
+
+# if not used as a module, run the doctest
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/_index.py

@@ -0,0 +1,35 @@
+# Copyright 2012 by Wibowo Arindrarto.  All rights reserved.
+# Revisions copyright 2012-2016 by Peter Cock.  All rights reserved.
+#
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+
+"""Custom indexing for Bio.SearchIO objects."""
+
+from io import StringIO
+
+from Bio.File import _IndexedSeqFileProxy
+from Bio.File import _open_for_random_access
+
+
+class SearchIndexer(_IndexedSeqFileProxy):
+    """Base class for file format specific random access.
+
+    Subclasses for each file format should define '_parser' and optionally
+    'get_raw' methods.
+    """
+
+    def __init__(self, filename, **kwargs):
+        """Initialize the class."""
+        self._handle = _open_for_random_access(filename)
+        self._kwargs = kwargs
+
+    def _parse(self, handle):
+        """Pass handle and arguments to the next iterable (PRIVATE)."""
+        return next(iter(self._parser(handle, **self._kwargs)))
+
+    def get(self, offset):
+        """Get offset and convert it from bytes to string."""
+        return self._parse(StringIO(self.get_raw(offset).decode()))

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/_model/__init__.py

@@ -0,0 +1,59 @@
+# Copyright 2012 by Wibowo Arindrarto.  All rights reserved.
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+"""Bio.SearchIO objects to model similarity search program outputs.
+
+The SearchIO object model consists of a hierarchy of four nested objects:
+
+    * QueryResult, to represent a search query.
+
+      This is the top-level object returned by the main SearchIO ``parse`` and
+      ``read`` functions. QueryResult objects may contain zero or more Hit
+      objects, each accessible by its ID string (like in Python dictionaries)
+      or integer index (like in Python lists).
+
+    * Hit, to represent a database entry containing a full or partial sequence
+      match with the query sequence.
+
+      Hit objects contain one or more HSP objects, each accessible by its integer
+      index. They behave very similar to a Python list.
+
+    * HSP, to represent a region of significant alignment(s) between the query
+      and hit sequences.
+
+      HSP objects contain one or more HSPFragment objects, each accessible by
+      its integer index. In most cases, the HSP objects are where the bulk of
+      search result statistics (e.g. e-value, bitscore) are stored. Like Hit
+      objects, HSPs also behave very similar to a Python list.
+
+    * HSPFragment, to represent a single contiguous alignment between the query
+      and hit sequences.
+
+      HSPFragment objects may store hit and query sequences resulting from the
+      sequence search. If present, these sequences are stored as SeqRecord
+      objects (see SeqRecord). If both of them are present, HSPFragment will
+      create a MultipleSeqAlignment object from both sequences.
+
+      Most search programs only have HSPs with one HSPFragment in them, making
+      these two objects inseparable. However, there are programs (e.g. BLAT and
+      Exonerate) which may have more than one HSPFragment objects in any given
+      HSP. If you are not using these programs, you can safely consider HSP and
+      HSPFragment as a single union.
+
+"""
+
+from .hit import Hit
+from .hsp import HSP
+from .hsp import HSPFragment
+from .query import QueryResult
+
+__all__ = ("QueryResult", "Hit", "HSP", "HSPFragment")
+
+
+# if not used as a module, run the doctest
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/_model/_base.py

@@ -0,0 +1,69 @@
+# Copyright 2012 by Wibowo Arindrarto.  All rights reserved.
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+"""Abstract base classes for the SearchIO object model."""
+
+from typing import Union
+
+from Bio.SearchIO._utils import getattr_str
+
+
+class _BaseSearchObject:
+    """Abstract class for SearchIO objects."""
+
+    _NON_STICKY_ATTRS: tuple | tuple[str] = ()
+
+    def _transfer_attrs(self, obj):
+        """Transfer instance attributes to the given object (PRIVATE).
+
+        This method is used to transfer attributes set externally (for example
+        using ``setattr``) to a new object created from this one (for example
+        from slicing).
+
+        The reason this method is necessary is because different parsers will
+        set different attributes for each QueryResult, Hit, HSP, or HSPFragment
+        objects, depending on the attributes they found in the search output
+        file. Ideally, we want these attributes to 'stick' with any new instance
+        object created from the original one.
+
+        """
+        # list of attribute names we don't want to transfer
+        for attr in self.__dict__:
+            if attr not in self._NON_STICKY_ATTRS:
+                setattr(obj, attr, self.__dict__[attr])
+
+
+class _BaseHSP(_BaseSearchObject):
+    """Abstract base class for HSP objects."""
+
+    def _str_hsp_header(self):
+        """Print the alignment header info (PRIVATE)."""
+        lines = []
+        # set query id line
+        qid_line = f"      Query: {self.query_id} {self.query_description}"
+        qid_line = qid_line[:77] + "..." if len(qid_line) > 80 else qid_line
+        # set hit id line
+        hid_line = f"        Hit: {self.hit_id} {self.hit_description}"
+        hid_line = hid_line[:77] + "..." if len(hid_line) > 80 else hid_line
+        lines.append(qid_line)
+        lines.append(hid_line)
+
+        # coordinates
+        query_start = getattr_str(self, "query_start")
+        query_end = getattr_str(self, "query_end")
+        hit_start = getattr_str(self, "hit_start")
+        hit_end = getattr_str(self, "hit_end")
+
+        # strands
+        try:
+            qstrand = self.query_strand
+            hstrand = self.hit_strand
+        except ValueError:
+            qstrand = self.query_strand_all[0]
+            hstrand = self.hit_strand_all[0]
+        lines.append(f"Query range: [{query_start}:{query_end}] ({qstrand!r})")
+        lines.append(f"  Hit range: [{hit_start}:{hit_end}] ({hstrand!r})")
+
+        return "\n".join(lines)

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/_model/hit.py

@@ -0,0 +1,464 @@
+# Copyright 2012 by Wibowo Arindrarto.  All rights reserved.
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+"""Bio.SearchIO object to model a single database hit."""
+
+from itertools import chain
+
+from Bio.SearchIO._utils import allitems
+from Bio.SearchIO._utils import getattr_str
+from Bio.SearchIO._utils import optionalcascade
+
+from ._base import _BaseSearchObject
+from .hsp import HSP
+
+
+class Hit(_BaseSearchObject):
+    """Class representing a single database hit of a search result.
+
+    Hit objects are the second-level container in the SearchIO module. They
+    are the objects contained within a QueryResult (see QueryResult). They
+    themselves are container for HSP objects and will contain at least one
+    HSP.
+
+    To have a quick look at a Hit and its contents, invoke ``print`` on it::
+
+        >>> from Bio import SearchIO
+        >>> qresult = next(SearchIO.parse('Blast/mirna.xml', 'blast-xml'))
+        >>> hit = qresult[3]
+        >>> print(hit)
+        Query: 33211
+               mir_1
+          Hit: gi|301171322|ref|NR_035857.1| (86)
+               Pan troglodytes microRNA mir-520c (MIR520C), microRNA
+         HSPs: ----  --------  ---------  ------  ---------------  ---------------------
+                  #   E-value  Bit score    Span      Query range              Hit range
+               ----  --------  ---------  ------  ---------------  ---------------------
+                  0   8.9e-20     100.47      60           [1:61]                [13:73]
+                  1   3.3e-06      55.39      60           [0:60]                [13:73]
+
+    You can invoke ``len`` on a Hit object to see how many HSP objects it contains::
+
+        >>> len(hit)
+        2
+
+    Hit objects behave very similar to Python lists. You can retrieve the HSP
+    object inside a Hit using the HSP's integer index. Hit objects can also be
+    sliced, which will return a new Hit objects containing only the sliced HSPs::
+
+        # HSP items inside the Hit can be retrieved using its integer index
+        >>> hit[0]
+        HSP(hit_id='gi|301171322|ref|NR_035857.1|', query_id='33211', 1 fragments)
+
+        # slicing returns a new Hit
+        >>> hit
+        Hit(id='gi|301171322|ref|NR_035857.1|', query_id='33211', 2 hsps)
+        >>> hit[:1]
+        Hit(id='gi|301171322|ref|NR_035857.1|', query_id='33211', 1 hsps)
+        >>> print(hit[1:])
+        Query: 33211
+               mir_1
+          Hit: gi|301171322|ref|NR_035857.1| (86)
+               Pan troglodytes microRNA mir-520c (MIR520C), microRNA
+         HSPs: ----  --------  ---------  ------  ---------------  ---------------------
+                  #   E-value  Bit score    Span      Query range              Hit range
+               ----  --------  ---------  ------  ---------------  ---------------------
+                  0   3.3e-06      55.39      60           [0:60]                [13:73]
+
+    Hit objects provide ``filter`` and ``map`` methods, which are analogous to
+    Python's built-in ``filter`` and ``map`` except that they return a new Hit
+    object instead of a list.
+
+    Here is an example of using ``filter`` to select for HSPs whose e-value is
+    less than 1e-10::
+
+        >>> evalue_filter = lambda hsp: hsp.evalue < 1e-10
+        >>> filtered_hit = hit.filter(evalue_filter)
+        >>> len(hit)
+        2
+        >>> len(filtered_hit)
+        1
+        >>> print(filtered_hit)
+        Query: 33211
+               mir_1
+          Hit: gi|301171322|ref|NR_035857.1| (86)
+               Pan troglodytes microRNA mir-520c (MIR520C), microRNA
+         HSPs: ----  --------  ---------  ------  ---------------  ---------------------
+                  #   E-value  Bit score    Span      Query range              Hit range
+               ----  --------  ---------  ------  ---------------  ---------------------
+                  0   8.9e-20     100.47      60           [1:61]                [13:73]
+
+    There are also other methods which are counterparts of Python lists' methods
+    with the same names: ``append``, ``index``, ``pop``, and ``sort``. Consult their
+    respective documentations for more details and examples of their usage.
+
+    """
+
+    # attributes we don't want to transfer when creating a new Hit class
+    # from this one
+    _NON_STICKY_ATTRS = ("_items",)
+
+    def __init__(self, hsps=(), id=None, query_id=None):
+        """Initialize a Hit object.
+
+        :param hsps: HSP objects contained in the Hit object
+        :type hsps: iterable yielding HSP
+        :param id: hit ID
+        :type id: string
+        :param query_id: query ID
+        :type query_id: string
+
+        If multiple HSP objects are used for initialization, they must all
+        have the same ``query_id``, ``query_description``, ``hit_id``, and
+        ``hit_description`` properties.
+        """
+        # default attribute values
+        self._id = id
+        self._id_alt = []
+        self._query_id = query_id
+        self._description = None
+        self._description_alt = []
+        self._query_description = None
+        self.attributes = {}
+        self.dbxrefs = []
+
+        # TODO - Move this into the for look below in case
+        # hsps is a single use iterator?
+        for attr in ("query_id", "query_description", "hit_id", "hit_description"):
+            # HACK: setting the if clause to '> 1' allows for empty hit objects.
+            # This makes it easier to work with file formats with unpredictable
+            # hit-hsp ordering. The empty hit object itself is nonfunctional,
+            # however, since all its cascading properties are empty.
+            if len({getattr(hsp, attr) for hsp in hsps}) > 1:
+                raise ValueError(
+                    "Hit object can not contain HSPs with more than one %s." % attr
+                )
+
+        self._items = []
+        for hsp in hsps:
+            # validate each HSP
+            self._validate_hsp(hsp)
+            # and store it them as an instance attribute
+            self.append(hsp)
+
+    def __repr__(self):
+        """Return string representation of Hit object."""
+        return f"Hit(id={self.id!r}, query_id={self.query_id!r}, {len(self)!r} hsps)"
+
+    def __iter__(self):
+        """Iterate over hsps."""
+        return iter(self.hsps)
+
+    def __len__(self):
+        """Return number of hsps."""
+        return len(self.hsps)
+
+    def __bool__(self):
+        """Return True if there are hsps."""
+        return bool(self.hsps)
+
+    def __contains__(self, hsp):
+        """Return True if hsp in items."""
+        return hsp in self._items
+
+    def __str__(self):
+        """Return a human readable summary of the Hit object."""
+        lines = []
+
+        # set query id line
+        qid_line = "Query: %s" % self.query_id
+        lines.append(qid_line)
+        if self.query_description:
+            line = "       %s" % self.query_description
+            line = line[:77] + "..." if len(line) > 80 else line
+            lines.append(line)
+
+        # set hit id line
+        hid_line = "  Hit: %s" % self.id
+        try:
+            seq_len = self.seq_len
+        except AttributeError:
+            pass
+        else:
+            hid_line += " (%i)" % seq_len
+        lines.append(hid_line)
+        if self.description:
+            line = "       %s" % self.description
+            line = line[:77] + "..." if len(line) > 80 else line
+            lines.append(line)
+
+        # set attributes lines
+        for key, value in sorted(self.attributes.items()):
+            lines.append(f" {key}: {value}")
+
+        # set dbxrefs line
+        if self.dbxrefs:
+            lines.append("Database cross-references: " + ", ".join(self.dbxrefs))
+
+        # set hsp line and table
+        if not self.hsps:
+            lines.append(" HSPs: ?")
+        else:
+            lines.append(
+                " HSPs: %s  %s  %s  %s  %s  %s"
+                % ("-" * 4, "-" * 8, "-" * 9, "-" * 6, "-" * 15, "-" * 21)
+            )
+            pattern = "%11s  %8s  %9s  %6s  %15s  %21s"
+            lines.append(
+                pattern
+                % ("#", "E-value", "Bit score", "Span", "Query range", "Hit range")
+            )
+            lines.append(
+                pattern % ("-" * 4, "-" * 8, "-" * 9, "-" * 6, "-" * 15, "-" * 21)
+            )
+            for idx, hsp in enumerate(self.hsps):
+                # evalue
+                evalue = getattr_str(hsp, "evalue", fmt="%.2g")
+                # bitscore
+                bitscore = getattr_str(hsp, "bitscore", fmt="%.2f")
+                # alignment length
+                aln_span = getattr_str(hsp, "aln_span")
+                # query region
+                query_start = getattr_str(hsp, "query_start")
+                query_end = getattr_str(hsp, "query_end")
+                query_range = f"[{query_start}:{query_end}]"
+                # max column length is 18
+                query_range = (
+                    query_range[:13] + "~]" if len(query_range) > 15 else query_range
+                )
+                # hit region
+                hit_start = getattr_str(hsp, "hit_start")
+                hit_end = getattr_str(hsp, "hit_end")
+                hit_range = f"[{hit_start}:{hit_end}]"
+                hit_range = hit_range[:19] + "~]" if len(hit_range) > 21 else hit_range
+                # append the hsp row
+                lines.append(
+                    pattern % (idx, evalue, bitscore, aln_span, query_range, hit_range)
+                )
+
+        return "\n".join(lines)
+
+    def __getitem__(self, idx):
+        """Return the HSP object at the given index."""
+        # if key is slice, return a new Hit instance
+        if isinstance(idx, slice):
+            obj = self.__class__(self.hsps[idx])
+            self._transfer_attrs(obj)
+            return obj
+        return self._items[idx]
+
+    def __setitem__(self, idx, hsps):
+        """Assign hsps to index idx."""
+        # handle case if hsps is a list of hsp
+        if isinstance(hsps, (list, tuple)):
+            for hsp in hsps:
+                self._validate_hsp(hsp)
+        else:
+            self._validate_hsp(hsps)
+
+        self._items[idx] = hsps
+
+    def __delitem__(self, idx):
+        """Delete item of index idx."""
+        del self._items[idx]
+
+    # hsp properties #
+    def _validate_hsp(self, hsp):
+        """Validate an HSP object (PRIVATE).
+
+        Valid HSP objects have the same hit_id as the Hit object ID and the
+        same query_id as the Hit object's query_id.
+
+        """
+        if not isinstance(hsp, HSP):
+            raise TypeError("Hit objects can only contain HSP objects.")
+        # HACK: to make validation during __init__ work
+        if self._items:
+            if self.id is not None:
+                if hsp.hit_id != self.id:
+                    raise ValueError(
+                        "Expected HSP with hit ID %r, found %r instead."
+                        % (self.id, hsp.hit_id)
+                    )
+            else:
+                self.id = hsp.hit_id
+
+            if self.description is not None:
+                if hsp.hit_description != self.description:
+                    raise ValueError(
+                        "Expected HSP with hit description %r, found %r instead."
+                        % (self.description, hsp.hit_description)
+                    )
+            else:
+                self.description = hsp.hit_description
+
+            if self.query_id is not None:
+                if hsp.query_id != self.query_id:
+                    raise ValueError(
+                        "Expected HSP with query ID %r, found %r instead."
+                        % (self.query_id, hsp.query_id)
+                    )
+            else:
+                self.query_id = hsp.query_id
+
+            if self.query_description is not None:
+                if hsp.query_description != self.query_description:
+                    raise ValueError(
+                        "Expected HSP with query description %r, found %r instead."
+                        % (self.query_description, hsp.query_description)
+                    )
+            else:
+                self.query_description = hsp.query_description
+
+    # properties #
+    description = optionalcascade(
+        "_description", "hit_description", """Hit description"""
+    )
+    query_description = optionalcascade(
+        "_query_description",
+        "query_description",
+        """Description of the query that produced the hit""",
+    )
+    id = optionalcascade("_id", "hit_id", """Hit ID string.""")
+    query_id = optionalcascade(
+        "_query_id", "query_id", """ID string of the query that produced the hit"""
+    )
+    # returns all hsps
+    hsps = allitems(doc="""HSP objects contained in the Hit""")
+
+    @property
+    def id_all(self):
+        """Alternative ID(s) of the Hit."""
+        return [self.id] + self._id_alt
+
+    @property
+    def description_all(self):
+        """Alternative descriptions of the Hit."""
+        return [self.description] + self._description_alt
+
+    @property
+    def fragments(self):
+        """Access the HSPFragment objects contained in the Hit."""
+        return list(chain(*self._items))
+
+    # public methods #
+    def append(self, hsp):
+        """Add a HSP object to the end of Hit.
+
+        Parameters
+        hsp -- HSP object to append.
+
+        Any HSP object appended must have the same ``hit_id`` property as the
+        Hit object's ``id`` property and the same ``query_id`` property as the
+        Hit object's ``query_id`` property.
+
+        """
+        self._validate_hsp(hsp)
+        self._items.append(hsp)
+
+    def filter(self, func=None):
+        """Create new Hit object whose HSP objects pass the filter function.
+
+        :param func: function for filtering
+        :type func: callable, accepts HSP, returns bool
+
+        ``filter`` is analogous to Python's built-in ``filter`` function, except
+        that instead of returning a list it returns a ``Hit`` object. Here is an
+        example of using ``filter`` to select for HSPs having bitscores bigger
+        than 60::
+
+            >>> from Bio import SearchIO
+            >>> qresult = next(SearchIO.parse('Blast/mirna.xml', 'blast-xml'))
+            >>> hit = qresult[3]
+            >>> evalue_filter = lambda hsp: hsp.bitscore > 60
+            >>> filtered_hit = hit.filter(evalue_filter)
+            >>> len(hit)
+            2
+            >>> len(filtered_hit)
+            1
+            >>> print(filtered_hit)
+            Query: 33211
+                   mir_1
+              Hit: gi|301171322|ref|NR_035857.1| (86)
+                   Pan troglodytes microRNA mir-520c (MIR520C), microRNA
+             HSPs: ----  --------  ---------  ------  ---------------  ---------------------
+                      #   E-value  Bit score    Span      Query range              Hit range
+                   ----  --------  ---------  ------  ---------------  ---------------------
+                      0   8.9e-20     100.47      60           [1:61]                [13:73]
+
+        """
+        hsps = list(filter(func, self.hsps))
+        if hsps:
+            obj = self.__class__(hsps)
+            self._transfer_attrs(obj)
+            return obj
+
+    def index(self, hsp):
+        """Return the index of a given HSP object, zero-based.
+
+        :param hsp: object to look up
+        :type hsp: HSP
+
+        """
+        return self._items.index(hsp)
+
+    def map(self, func=None):
+        """Create new Hit object, mapping the given function to its HSPs.
+
+        :param func: function for mapping
+        :type func: callable, accepts HSP, returns HSP
+
+        ``map`` is analogous to Python's built-in ``map`` function. It is applied to
+        all HSPs contained in the Hit object and returns a new Hit object.
+
+        """
+        if func is not None:
+            hsps = [func(x) for x in self.hsps[:]]  # this creates a shallow copy
+        else:
+            hsps = self.hsps[:]
+        if hsps:
+            obj = self.__class__(hsps)
+            self._transfer_attrs(obj)
+            return obj
+
+    def pop(self, index=-1):
+        """Remove and returns the HSP object at the specified index.
+
+        :param index: index of HSP object to pop
+        :type index: int
+
+        """
+        return self._items.pop(index)
+
+    def sort(self, key=None, reverse=False, in_place=True):
+        """Sort the HSP objects.
+
+        :param key: sorting function
+        :type key: callable, accepts HSP, returns key for sorting
+        :param reverse: whether to reverse sorting results or no
+        :type reverse: bool
+        :param in_place: whether to do in-place sorting or no
+        :type in_place: bool
+
+        ``sort`` defaults to sorting in-place, to mimic Python's ``list.sort``
+        method. If you set the ``in_place`` argument to False, it will treat
+        return a new, sorted Hit object and keep the initial one unsorted
+
+        """
+        if in_place:
+            self._items.sort(key=key, reverse=reverse)
+        else:
+            hsps = self.hsps[:]
+            hsps.sort(key=key, reverse=reverse)
+            obj = self.__class__(hsps)
+            self._transfer_attrs(obj)
+            return obj
+
+
+# if not used as a module, run the doctest
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/_model/hsp.py

@@ -0,0 +1,1228 @@
+# Copyright 2012 by Wibowo Arindrarto.  All rights reserved.
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+"""Bio.SearchIO objects to model high scoring regions between query and hit."""
+
+import warnings
+from operator import ge
+from operator import le
+
+from Bio import BiopythonWarning
+from Bio.Align import MultipleSeqAlignment
+from Bio.SearchIO._utils import allitems
+from Bio.SearchIO._utils import fragcascade
+from Bio.SearchIO._utils import fullcascade
+from Bio.SearchIO._utils import getattr_str
+from Bio.SearchIO._utils import singleitem
+from Bio.Seq import Seq
+from Bio.SeqRecord import SeqRecord
+
+from ._base import _BaseHSP
+
+
+class HSP(_BaseHSP):
+    """Class representing high-scoring region(s) between query and hit.
+
+    HSP (high-scoring pair) objects are contained by Hit objects (see Hit).
+    In most cases, HSP objects store the bulk of the statistics and results
+    (e.g. e-value, bitscores, query sequence, etc.) produced by a search
+    program.
+
+    Depending on the search output file format, a given HSP will contain one
+    or more HSPFragment object(s). Examples of search programs that produce HSP
+    with one HSPFragments are BLAST, HMMER, and FASTA. Other programs such as
+    BLAT or Exonerate may produce HSPs containing more than one HSPFragment.
+    However, their native terminologies may differ: in BLAT these fragments
+    are called 'blocks' while in Exonerate they are called exons or NER.
+
+    Here are examples from each type of HSP. The first one comes from a BLAST
+    search::
+
+        >>> from Bio import SearchIO
+        >>> blast_qresult = next(SearchIO.parse('Blast/mirna.xml', 'blast-xml'))
+        >>> blast_hsp = blast_qresult[1][0]     # the first HSP from the second hit
+        >>> blast_hsp
+        HSP(hit_id='gi|301171311|ref|NR_035856.1|', query_id='33211', 1 fragments)
+        >>> print(blast_hsp)
+              Query: 33211 mir_1
+                Hit: gi|301171311|ref|NR_035856.1| Pan troglodytes microRNA mir-520b ...
+        Query range: [1:61] (1)
+          Hit range: [0:60] (1)
+        Quick stats: evalue 1.7e-22; bitscore 109.49
+          Fragments: 1 (60 columns)
+             Query - CCTCTACAGGGAAGCGCTTTCTGTTGTCTGAAAGAAAAGAAAGTGCTTCCTTTTAGAGGG
+                     ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
+               Hit - CCTCTACAGGGAAGCGCTTTCTGTTGTCTGAAAGAAAAGAAAGTGCTTCCTTTTAGAGGG
+
+    For HSPs with a single HSPFragment, you can invoke ``print`` on it and see the
+    underlying sequence alignment, if it exists. This is not the case for HSPs
+    with more than one HSPFragment. Below is an example, using an HSP from a
+    BLAT search. Invoking ``print`` on these HSPs will instead show a table of the
+    HSPFragment objects it contains::
+
+        >>> blat_qresult = SearchIO.read('Blat/mirna.pslx', 'blat-psl', pslx=True)
+        >>> blat_hsp = blat_qresult[1][0]       # the first HSP from the second hit
+        >>> blat_hsp
+        HSP(hit_id='chr11', query_id='blat_1', 2 fragments)
+        >>> print(blat_hsp)
+              Query: blat_1 <unknown description>
+                Hit: chr11 <unknown description>
+        Query range: [42:67] (-1)
+          Hit range: [59018929:59018955] (1)
+        Quick stats: evalue ?; bitscore ?
+          Fragments: ---  --------------  ----------------------  ----------------------
+                       #            Span             Query range               Hit range
+                     ---  --------------  ----------------------  ----------------------
+                       0               6                 [61:67]     [59018929:59018935]
+                       1              16                 [42:58]     [59018939:59018955]
+
+    Notice that in HSPs with more than one HSPFragments, the HSP's ``query_range``
+    ``hit_range`` properties encompasses all fragments it contains.
+
+    You can check whether an HSP has more than one HSPFragments or not using the
+    ``is_fragmented`` property::
+
+        >>> blast_hsp.is_fragmented
+        False
+        >>> blat_hsp.is_fragmented
+        True
+
+    Since HSP objects are also containers similar to Python lists, you can
+    access a single fragment in an HSP using its integer index::
+
+        >>> blat_fragment = blat_hsp[0]
+        >>> print(blat_fragment)
+              Query: blat_1 <unknown description>
+                Hit: chr11 <unknown description>
+        Query range: [61:67] (-1)
+          Hit range: [59018929:59018935] (1)
+          Fragments: 1 (6 columns)
+             Query - tatagt
+               Hit - tatagt
+
+    This applies to HSPs objects with a single fragment as well::
+
+        >>> blast_fragment = blast_hsp[0]
+        >>> print(blast_fragment)
+              Query: 33211 mir_1
+                Hit: gi|301171311|ref|NR_035856.1| Pan troglodytes microRNA mir-520b ...
+        Query range: [1:61] (1)
+          Hit range: [0:60] (1)
+          Fragments: 1 (60 columns)
+             Query - CCTCTACAGGGAAGCGCTTTCTGTTGTCTGAAAGAAAAGAAAGTGCTTCCTTTTAGAGGG
+                     ||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
+               Hit - CCTCTACAGGGAAGCGCTTTCTGTTGTCTGAAAGAAAAGAAAGTGCTTCCTTTTAGAGGG
+
+    Regardless of the search output file format, HSP objects provide the
+    properties listed below. These properties always return values in a list,
+    due to the HSP object itself being a list-like container. However, for
+    HSP objects with a single HSPFragment, shortcut properties that fetches
+    the item from the list are also provided.
+
+    +----------------------+---------------------+-----------------------------+
+    | Property             | Shortcut            | Value                       |
+    +======================+=====================+=============================+
+    | aln_all              | aln                 | HSP alignments as           |
+    |                      |                     | MultipleSeqAlignment object |
+    +----------------------+---------------------+-----------------------------+
+    | aln_annotation_all   | aln_annotation      | dictionary of annotation(s) |
+    |                      |                     | of all fragments' alignments|
+    +----------------------+---------------------+-----------------------------+
+    | fragments            | fragment            | HSPFragment objects         |
+    +----------------------+---------------------+-----------------------------+
+    | hit_all              | hit                 | hit sequence as SeqRecord   |
+    |                      |                     | objects                     |
+    +----------------------+---------------------+-----------------------------+
+    | hit_features_all     | hit_features        | SeqFeatures of all hit      |
+    |                      |                     | fragments                   |
+    +----------------------+---------------------+-----------------------------+
+    | hit_start_all        | hit_start*          | start coordinates of the    |
+    |                      |                     | hit fragments               |
+    +----------------------+---------------------+-----------------------------+
+    | hit_end_all          | hit_end*            | end coordinates of the hit  |
+    |                      |                     | fragments                   |
+    +----------------------+---------------------+-----------------------------+
+    | hit_span_all         | hit_span*           | sizes of each hit fragments |
+    +----------------------+---------------------+-----------------------------+
+    | hit_strand_all       | hit_strand          | strand orientations of the  |
+    |                      |                     | hit fragments               |
+    +----------------------+---------------------+-----------------------------+
+    | hit_frame_all        | hit_frame           | reading frames of the hit   |
+    |                      |                     | fragments                   |
+    +----------------------+---------------------+-----------------------------+
+    | hit_range_all        | hit_range           | tuples of start and end     |
+    |                      |                     | coordinates of each hit     |
+    |                      |                     | fragment                    |
+    +----------------------+---------------------+-----------------------------+
+    | query_all            | query               | query sequence as SeqRecord |
+    |                      |                     | object                      |
+    +----------------------+---------------------+-----------------------------+
+    | query_features_all   | query_features      | SeqFeatures of all query    |
+    |                      |                     | fragments                   |
+    +----------------------+---------------------+-----------------------------+
+    | query_start_all      | query_start*        | start coordinates of the    |
+    |                      |                     | fragments                   |
+    +----------------------+---------------------+-----------------------------+
+    | query_end_all        | query_end*          | end coordinates of the      |
+    |                      |                     | query fragments             |
+    +----------------------+---------------------+-----------------------------+
+    | query_span_all       | query_span*         | sizes of each query         |
+    |                      |                     | fragments                   |
+    +----------------------+---------------------+-----------------------------+
+    | query_strand_all     | query_strand        | strand orientations of the  |
+    |                      |                     | query fragments             |
+    +----------------------+---------------------+-----------------------------+
+    | query_frame_all      | query_frame         | reading frames of the query |
+    |                      |                     | fragments                   |
+    +----------------------+---------------------+-----------------------------+
+    | query_range_all      | query_range         | tuples of start and end     |
+    |                      |                     | coordinates of each query   |
+    |                      |                     | fragment                    |
+    +----------------------+---------------------+-----------------------------+
+
+    For all types of HSP objects, the property will return the values in a list.
+    Shortcuts are only applicable for HSPs with one fragment. Except the ones
+    noted, if they are used on an HSP with more than one fragments, an exception
+    will be raised.
+
+    For properties that may be used in HSPs with multiple or single fragments
+    (``*_start``, ``*_end``, and ``*_span`` properties), their interpretation depends
+    on how many fragment the HSP has:
+
+    +------------+---------------------------------------------------+
+    | Property   | Value                                             |
+    +============+===================================================+
+    | hit_start  | smallest coordinate value of all hit fragments    |
+    +------------+---------------------------------------------------+
+    | hit_end    | largest coordinate value of all hit fragments     |
+    +------------+---------------------------------------------------+
+    | hit_span   | difference between ``hit_start`` and ``hit_end``  |
+    +------------+---------------------------------------------------+
+    | query_start| smallest coordinate value of all query fragments  |
+    +------------+---------------------------------------------------+
+    | query_end  | largest coordinate value of all query fragments   |
+    +------------+---------------------------------------------------+
+    | query_span | difference between ``query_start`` and            |
+    |            | ``query_end``                                     |
+    +------------+---------------------------------------------------+
+
+    In addition to the objects listed above, HSP objects also provide the
+    following properties and/or attributes:
+
+    +--------------------+------------------------------------------------------+
+    | Property           | Value                                                |
+    +====================+======================================================+
+    | aln_span           | total number of residues in all HSPFragment objects  |
+    +--------------------+------------------------------------------------------+
+    | molecule_type      | molecule_type of the hit and query SeqRecord objects |
+    +--------------------+------------------------------------------------------+
+    | is_fragmented      | boolean, whether there are multiple fragments or not |
+    +--------------------+------------------------------------------------------+
+    | hit_id             | ID of the hit sequence                               |
+    +--------------------+------------------------------------------------------+
+    | hit_description    | description of the hit sequence                      |
+    +--------------------+------------------------------------------------------+
+    | hit_inter_ranges   | list of hit sequence coordinates of the regions      |
+    |                    | between fragments                                    |
+    +--------------------+------------------------------------------------------+
+    | hit_inter_spans    | list of lengths of the regions between hit fragments |
+    +--------------------+------------------------------------------------------+
+    | output_index       | 0-based index for storing the order by which the HSP |
+    |                    | appears in the output file (default: -1).            |
+    +--------------------+------------------------------------------------------+
+    | query_id           | ID of the query sequence                             |
+    +--------------------+------------------------------------------------------+
+    | query_description  | description of the query sequence                    |
+    +--------------------+------------------------------------------------------+
+    | query_inter_ranges | list of query sequence coordinates of the regions    |
+    |                    | between fragments                                    |
+    +--------------------+------------------------------------------------------+
+    | query_inter_spans  | list of lengths of the regions between query         |
+    |                    | fragments                                            |
+    +--------------------+------------------------------------------------------+
+
+    .. [1] may be used in HSPs with multiple fragments
+
+    """
+
+    # attributes we don't want to transfer when creating a new Hit class
+    # from this one
+    _NON_STICKY_ATTRS = ("_items",)
+
+    def __init__(self, fragments=(), output_index=-1):
+        """Initialize an HSP object.
+
+        :param fragments: fragments contained in the HSP object
+        :type fragments: iterable yielding HSPFragment
+        :param output_index: optional index / ordering of the HSP fragment in
+            the original input file.
+        :type output_index: integer
+
+        HSP objects must be initialized with a list containing at least one
+        HSPFragment object. If multiple HSPFragment objects are used for
+        initialization, they must all have the same ``query_id``,
+        ``query_description``, ``hit_id``, ``hit_description``, and
+        ``molecule_type`` properties.
+
+        """
+        if not fragments:
+            raise ValueError("HSP objects must have at least one HSPFragment object.")
+        # TODO - Move this into the for look in case hsps is a single use
+        # iterable?
+        # check that all fragments contain the same IDs, descriptions,
+        # molecule_type
+        for attr in (
+            "query_id",
+            "query_description",
+            "hit_id",
+            "hit_description",
+            "molecule_type",
+        ):
+            if len({getattr(frag, attr) for frag in fragments}) != 1:
+                raise ValueError(
+                    "HSP object can not contain fragments with more than one %s." % attr
+                )
+
+        self.output_index = output_index
+        self._items = []
+        for fragment in fragments:
+            self._validate_fragment(fragment)
+            self._items.append(fragment)
+
+    def __repr__(self):
+        """Return string representation of HSP object."""
+        return "%s(hit_id=%r, query_id=%r, %r fragments)" % (
+            self.__class__.__name__,
+            self.hit_id,
+            self.query_id,
+            len(self),
+        )
+
+    def __iter__(self):
+        """Iterate over HSP items."""
+        return iter(self._items)
+
+    def __contains__(self, fragment):
+        """Return True if HSPFragment is on HSP items."""
+        return fragment in self._items
+
+    def __len__(self):
+        """Return number of HSPs items."""
+        return len(self._items)
+
+    def __bool__(self):
+        """Return True if it has HSPs."""
+        return bool(self._items)
+
+    def __str__(self):
+        """Return a human readable summary of the HSP object."""
+        lines = []
+        # set hsp info line
+        statline = []
+        # evalue
+        evalue = getattr_str(self, "evalue", fmt="%.2g")
+        statline.append("evalue " + evalue)
+        # bitscore
+        bitscore = getattr_str(self, "bitscore", fmt="%.2f")
+        statline.append("bitscore " + bitscore)
+        lines.append("Quick stats: " + "; ".join(statline))
+
+        if len(self.fragments) == 1:
+            return "\n".join(
+                [self._str_hsp_header(), "\n".join(lines), self.fragments[0]._str_aln()]
+            )
+        else:
+            lines.append(
+                "  Fragments: %s  %s  %s  %s" % ("-" * 3, "-" * 14, "-" * 22, "-" * 22)
+            )
+            pattern = "%16s  %14s  %22s  %22s"
+            lines.append(pattern % ("#", "Span", "Query range", "Hit range"))
+            lines.append(pattern % ("-" * 3, "-" * 14, "-" * 22, "-" * 22))
+            for idx, block in enumerate(self.fragments):
+                # set hsp line and table
+                # alignment span
+                aln_span = getattr_str(block, "aln_span")
+                # query region
+                query_start = getattr_str(block, "query_start")
+                query_end = getattr_str(block, "query_end")
+                query_range = "[%s:%s]" % (query_start, query_end)
+                # max column length is 20
+                query_range = (
+                    query_range[:20] + "~]" if len(query_range) > 22 else query_range
+                )
+                # hit region
+                hit_start = getattr_str(block, "hit_start")
+                hit_end = getattr_str(block, "hit_end")
+                hit_range = "[%s:%s]" % (hit_start, hit_end)
+                hit_range = hit_range[:20] + "~]" if len(hit_range) > 22 else hit_range
+                # append the hsp row
+                lines.append(pattern % (str(idx), aln_span, query_range, hit_range))
+
+            return self._str_hsp_header() + "\n" + "\n".join(lines)
+
+    def __getitem__(self, idx):
+        """Return object of index idx."""
+        # if key is slice, return a new HSP instance
+        if isinstance(idx, slice):
+            obj = self.__class__(self._items[idx])
+            self._transfer_attrs(obj)
+            return obj
+        return self._items[idx]
+
+    def __setitem__(self, idx, fragments):
+        """Set an item of index idx with the given fragments."""
+        # handle case if hsps is a list of hsp
+        if isinstance(fragments, (list, tuple)):
+            for fragment in fragments:
+                self._validate_fragment(fragment)
+        else:
+            self._validate_fragment(fragments)
+
+        self._items[idx] = fragments
+
+    def __delitem__(self, idx):
+        """Delete item of index idx."""
+        # note that this may result in an empty HSP object, which should be
+        # invalid
+        del self._items[idx]
+
+    def _validate_fragment(self, fragment):
+        if not isinstance(fragment, HSPFragment):
+            raise TypeError("HSP objects can only contain HSPFragment objects.")
+        # HACK: to make validation during __init__ work
+        if self._items:
+            if fragment.hit_id != self.hit_id:
+                raise ValueError(
+                    "Expected HSPFragment with hit ID %r, found %r instead."
+                    % (self.id, fragment.hit_id)
+                )
+
+            if fragment.hit_description != self.hit_description:
+                raise ValueError(
+                    "Expected HSPFragment with hit description %r, found %r instead."
+                    % (self.description, fragment.hit_description)
+                )
+
+            if fragment.query_id != self.query_id:
+                raise ValueError(
+                    "Expected HSPFragment with query ID %r, found %r instead."
+                    % (self.query_id, fragment.query_id)
+                )
+
+            if fragment.query_description != self.query_description:
+                raise ValueError(
+                    "Expected HSP with query description %r, found %r instead."
+                    % (self.query_description, fragment.query_description)
+                )
+
+    def _aln_span_get(self):
+        # length of all alignments
+        # alignment span can be its own attribute, or computed from
+        # query / hit length
+        return sum(frg.aln_span for frg in self.fragments)
+
+    aln_span = property(
+        fget=_aln_span_get, doc="Total number of columns in all HSPFragment objects."
+    )
+
+    # coordinate properties #
+    def _get_coords(self, seq_type, coord_type):
+        assert seq_type in ("hit", "query")
+        assert coord_type in ("start", "end")
+        coord_name = "%s_%s" % (seq_type, coord_type)
+        coords = [getattr(frag, coord_name) for frag in self.fragments]
+        if None in coords:
+            warnings.warn(
+                "'None' exist in %s coordinates; ignored" % (coord_name),
+                BiopythonWarning,
+            )
+        return coords
+
+    def _hit_start_get(self):
+        return min(self._get_coords("hit", "start"))
+
+    hit_start = property(
+        fget=_hit_start_get, doc="Smallest coordinate value of all hit fragments."
+    )
+
+    def _query_start_get(self):
+        return min(self._get_coords("query", "start"))
+
+    query_start = property(
+        fget=_query_start_get, doc="Smallest coordinate value of all query fragments."
+    )
+
+    def _hit_end_get(self):
+        return max(self._get_coords("hit", "end"))
+
+    hit_end = property(
+        fget=_hit_end_get, doc="Largest coordinate value of all hit fragments."
+    )
+
+    def _query_end_get(self):
+        return max(self._get_coords("query", "end"))
+
+    query_end = property(
+        fget=_query_end_get, doc="Largest coordinate value of all hit fragments."
+    )
+
+    # coordinate-dependent properties #
+    def _hit_span_get(self):
+        try:
+            return self.hit_end - self.hit_start
+        except TypeError:  # triggered if any of the coordinates are None
+            return None
+
+    hit_span = property(
+        fget=_hit_span_get, doc="The number of hit residues covered by the HSP."
+    )
+
+    def _query_span_get(self):
+        try:
+            return self.query_end - self.query_start
+        except TypeError:  # triggered if any of the coordinates are None
+            return None
+
+    query_span = property(
+        fget=_query_span_get, doc="The number of query residues covered by the HSP."
+    )
+
+    def _hit_range_get(self):
+        return (self.hit_start, self.hit_end)
+
+    hit_range = property(
+        fget=_hit_range_get, doc="Tuple of HSP hit start and end coordinates."
+    )
+
+    def _query_range_get(self):
+        return (self.query_start, self.query_end)
+
+    query_range = property(
+        fget=_query_range_get, doc="Tuple of HSP query start and end coordinates."
+    )
+
+    def _inter_ranges_get(self, seq_type):
+        # this property assumes that there are no mixed strands in a hit/query
+        assert seq_type in ("query", "hit")
+        strand = getattr(self, "%s_strand_all" % seq_type)[0]
+        coords = getattr(self, "%s_range_all" % seq_type)
+        # determine function used to set inter range
+        # start and end coordinates, given two pairs
+        # of fragment start and end coordinates
+        if strand == -1:
+            startfunc, endfunc = min, max
+        else:
+            startfunc, endfunc = max, min
+        inter_coords = []
+        for idx, coord in enumerate(coords[:-1]):
+            start = startfunc(coords[idx])
+            end = endfunc(coords[idx + 1])
+            inter_coords.append((min(start, end), max(start, end)))
+
+        return inter_coords
+
+    def _hit_inter_ranges_get(self):
+        return self._inter_ranges_get("hit")
+
+    hit_inter_ranges = property(
+        fget=_hit_inter_ranges_get,
+        doc="Hit sequence coordinates of the regions between fragments.",
+    )
+
+    def _query_inter_ranges_get(self):
+        return self._inter_ranges_get("query")
+
+    query_inter_ranges = property(
+        fget=_query_inter_ranges_get,
+        doc="Query sequence coordinates of the regions between fragments.",
+    )
+
+    def _inter_spans_get(self, seq_type):
+        assert seq_type in ("query", "hit")
+        attr_name = "%s_inter_ranges" % seq_type
+        return [coord[1] - coord[0] for coord in getattr(self, attr_name)]
+
+    def _hit_inter_spans_get(self):
+        return self._inter_spans_get("hit")
+
+    hit_inter_spans = property(
+        fget=_hit_inter_spans_get, doc="Lengths of regions between hit fragments."
+    )
+
+    def _query_inter_spans_get(self):
+        return self._inter_spans_get("query")
+
+    query_inter_spans = property(
+        fget=_query_inter_spans_get, doc="Lengths of regions between query fragments."
+    )
+
+    # shortcuts for fragments' properties #
+
+    # bool check if there's more than one fragments
+    is_fragmented = property(
+        lambda self: len(self) > 1,
+        doc="Whether the HSP has more than one HSPFragment objects.",
+    )
+
+    # first item properties with setters
+    hit_description = fullcascade(
+        "hit_description", doc="Description of the hit sequence."
+    )
+
+    query_description = fullcascade(
+        "query_description", doc="Description of the query sequence."
+    )
+
+    hit_id = fullcascade("hit_id", doc="ID of the hit sequence.")
+
+    query_id = fullcascade("query_id", doc="ID of the query sequence.")
+
+    molecule_type = fullcascade(
+        "molecule_type", doc="molecule_type of the hit and query SeqRecord objects."
+    )
+
+    # properties for single-fragment HSPs
+    fragment = singleitem(doc="HSPFragment object, first fragment.")
+
+    hit = singleitem("hit", doc="Hit sequence as a SeqRecord object, first fragment.")
+
+    query = singleitem(
+        "query", doc="Query sequence as a SeqRecord object, first fragment."
+    )
+
+    aln = singleitem(
+        "aln", doc="Alignment of the first fragment as a MultipleSeqAlignment object."
+    )
+
+    aln_annotation = singleitem(
+        "aln_annotation",
+        doc="Dictionary of annotation(s) of the first fragment's alignment.",
+    )
+
+    hit_features = singleitem(
+        "hit_features", doc="Hit sequence features, first fragment."
+    )
+
+    query_features = singleitem(
+        "query_features", doc="Query sequence features, first fragment."
+    )
+
+    hit_strand = singleitem("hit_strand", doc="Hit strand orientation, first fragment.")
+
+    query_strand = singleitem(
+        "query_strand", doc="Query strand orientation, first fragment."
+    )
+
+    hit_frame = singleitem(
+        "hit_frame", doc="Hit sequence reading frame, first fragment."
+    )
+
+    query_frame = singleitem(
+        "query_frame", doc="Query sequence reading frame, first fragment."
+    )
+
+    # properties for multi-fragment HSPs
+    fragments = allitems(doc="List of all HSPFragment objects.")
+
+    hit_all = allitems(
+        "hit", doc="List of all fragments' hit sequences as SeqRecord objects."
+    )
+
+    query_all = allitems(
+        "query", doc="List of all fragments' query sequences as SeqRecord objects."
+    )
+
+    aln_all = allitems(
+        "aln", doc="List of all fragments' alignments as MultipleSeqAlignment objects."
+    )
+
+    aln_annotation_all = allitems(
+        "aln_annotation",
+        doc="Dictionary of annotation(s) of all fragments' alignments.",
+    )
+
+    hit_features_all = allitems(
+        "hit_features", doc="List of all hit sequence features."
+    )
+
+    query_features_all = allitems(
+        "query_features", doc="List of all query sequence features."
+    )
+
+    hit_strand_all = allitems(
+        "hit_strand", doc="List of all fragments' hit sequence strands."
+    )
+
+    query_strand_all = allitems(
+        "query_strand", doc="List of all fragments' query sequence strands"
+    )
+
+    hit_frame_all = allitems(
+        "hit_frame", doc="List of all fragments' hit sequence reading frames."
+    )
+
+    query_frame_all = allitems(
+        "query_frame", doc="List of all fragments' query sequence reading frames."
+    )
+
+    hit_start_all = allitems(
+        "hit_start", doc="List of all fragments' hit start coordinates."
+    )
+
+    query_start_all = allitems(
+        "query_start", doc="List of all fragments' query start coordinates."
+    )
+
+    hit_end_all = allitems("hit_end", doc="List of all fragments' hit end coordinates.")
+
+    query_end_all = allitems(
+        "query_end", doc="List of all fragments' query end coordinates."
+    )
+
+    hit_span_all = allitems("hit_span", doc="List of all fragments' hit sequence size.")
+
+    query_span_all = allitems(
+        "query_span", doc="List of all fragments' query sequence size."
+    )
+
+    hit_range_all = allitems(
+        "hit_range", doc="List of all fragments' hit start and end coordinates."
+    )
+
+    query_range_all = allitems(
+        "query_range", doc="List of all fragments' query start and end coordinates."
+    )
+
+
+class HSPFragment(_BaseHSP):
+    """Class representing a contiguous alignment of hit-query sequence.
+
+    HSPFragment forms the core of any parsed search output file. Depending on
+    the search output file format, it may contain the actual query and/or hit
+    sequences that produces the search hits. These sequences are stored as
+    SeqRecord objects (see SeqRecord):
+
+    >>> from Bio import SearchIO
+    >>> qresult = next(SearchIO.parse('Blast/mirna.xml', 'blast-xml'))
+    >>> fragment = qresult[0][0][0]   # first hit, first hsp, first fragment
+    >>> print(fragment)
+          Query: 33211 mir_1
+            Hit: gi|262205317|ref|NR_030195.1| Homo sapiens microRNA 520b (MIR520...
+    Query range: [0:61] (1)
+      Hit range: [0:61] (1)
+      Fragments: 1 (61 columns)
+         Query - CCCTCTACAGGGAAGCGCTTTCTGTTGTCTGAAAGAAAAGAAAGTGCTTCCTTTTAGAGGG
+                 |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
+           Hit - CCCTCTACAGGGAAGCGCTTTCTGTTGTCTGAAAGAAAAGAAAGTGCTTCCTTTTAGAGGG
+
+    # the query sequence is a SeqRecord object
+    >>> fragment.query.__class__
+    <class 'Bio.SeqRecord.SeqRecord'>
+    >>> print(fragment.query)
+    ID: 33211
+    Name: aligned query sequence
+    Description: mir_1
+    Number of features: 0
+    /molecule_type=DNA
+    Seq('CCCTCTACAGGGAAGCGCTTTCTGTTGTCTGAAAGAAAAGAAAGTGCTTCCTTT...GGG')
+
+    # the hit sequence is a SeqRecord object as well
+    >>> fragment.hit.__class__
+    <class 'Bio.SeqRecord.SeqRecord'>
+    >>> print(fragment.hit)
+    ID: gi|262205317|ref|NR_030195.1|
+    Name: aligned hit sequence
+    Description: Homo sapiens microRNA 520b (MIR520B), microRNA
+    Number of features: 0
+    /molecule_type=DNA
+    Seq('CCCTCTACAGGGAAGCGCTTTCTGTTGTCTGAAAGAAAAGAAAGTGCTTCCTTT...GGG')
+
+    # when both query and hit are present, we get a MultipleSeqAlignment object
+    >>> fragment.aln.__class__
+    <class 'Bio.Align.MultipleSeqAlignment'>
+    >>> print(fragment.aln)
+    Alignment with 2 rows and 61 columns
+    CCCTCTACAGGGAAGCGCTTTCTGTTGTCTGAAAGAAAAGAAAG...GGG 33211
+    CCCTCTACAGGGAAGCGCTTTCTGTTGTCTGAAAGAAAAGAAAG...GGG gi|262205317|ref|NR_030195.1|
+
+    """
+
+    def __init__(
+        self,
+        hit_id="<unknown id>",
+        query_id="<unknown id>",
+        hit=None,
+        query=None,
+        molecule_type=None,
+    ):
+        """Initialize the class."""
+        self._molecule_type = molecule_type
+        self.aln_annotation = {}
+
+        self._hit_id = hit_id
+        self._query_id = query_id
+
+        for seq_type in ("query", "hit"):
+            # query or hit attributes default attributes
+            setattr(self, "_%s_description" % seq_type, "<unknown description>")
+            setattr(self, "_%s_features" % seq_type, [])
+            # query or hit attributes whose default attribute is None
+            for attr in ("strand", "frame", "start", "end"):
+                setattr(self, "%s_%s" % (seq_type, attr), None)
+            # self.query or self.hit
+            if eval(seq_type):
+                setattr(self, seq_type, eval(seq_type))
+            else:
+                setattr(self, seq_type, None)
+
+    def __repr__(self):
+        """Return HSPFragment info; hit id, query id, number of columns."""
+        info = "hit_id=%r, query_id=%r" % (self.hit_id, self.query_id)
+        try:
+            info += ", %i columns" % len(self)
+        except AttributeError:
+            pass
+        return "%s(%s)" % (self.__class__.__name__, info)
+
+    def __len__(self):
+        """Return alignment span."""
+        return self.aln_span
+
+    def __str__(self):
+        """Return string of HSP header and alignments."""
+        return self._str_hsp_header() + "\n" + self._str_aln()
+
+    def __getitem__(self, idx):
+        """Return object of index idx."""
+        if self.aln is not None:
+            obj = self.__class__(
+                hit_id=self.hit_id,
+                query_id=self.query_id,
+                molecule_type=self.molecule_type,
+            )
+            # transfer query and hit attributes
+            # let SeqRecord handle feature slicing, then retrieve the sliced
+            # features into the sliced HSPFragment
+            if self.query is not None:
+                obj.query = self.query[idx]
+                obj.query_features = obj.query.features
+            if self.hit is not None:
+                obj.hit = self.hit[idx]
+                obj.hit_features = obj.hit.features
+            # description, strand, frame
+            for attr in ("description", "strand", "frame"):
+                for seq_type in ("hit", "query"):
+                    attr_name = "%s_%s" % (seq_type, attr)
+                    self_val = getattr(self, attr_name)
+                    setattr(obj, attr_name, self_val)
+            # alignment annotation should be transferred, since we can compute
+            # the resulting annotation
+            obj.aln_annotation = {}
+            for key, value in self.aln_annotation.items():
+                assert len(value[idx]) == len(obj)
+                obj.aln_annotation[key] = value[idx]
+            return obj
+        else:
+            raise TypeError(
+                "Slicing for HSP objects without alignment is not supported."
+            )
+
+    def _str_aln(self):
+        lines = []
+        # alignment length
+        aln_span = getattr_str(self, "aln_span")
+        lines.append("  Fragments: 1 (%s columns)" % aln_span)
+        # sequences
+        if self.query is not None and self.hit is not None:
+            try:
+                qseq = self.query.seq
+            except AttributeError:  # query is None
+                qseq = "?"
+            try:
+                hseq = self.hit.seq
+            except AttributeError:  # hit is None
+                hseq = "?"
+
+            # similarity line
+            simil = ""
+            if "similarity" in self.aln_annotation and isinstance(
+                self.aln_annotation.get("similarity"), str
+            ):
+                simil = self.aln_annotation["similarity"]
+
+            if self.aln_span <= 67:
+                lines.append("%10s - %s" % ("Query", qseq))
+                if simil:
+                    lines.append("             %s" % simil)
+                lines.append("%10s - %s" % ("Hit", hseq))
+            else:
+                # adjust continuation character length, so we don't display
+                # the same residues twice
+                if self.aln_span - 66 > 3:
+                    cont = "~" * 3
+                else:
+                    cont = "~" * (self.aln_span - 66)
+                lines.append("%10s - %s%s%s" % ("Query", qseq[:59], cont, qseq[-5:]))
+                if simil:
+                    lines.append("             %s%s%s" % (simil[:59], cont, simil[-5:]))
+                lines.append("%10s - %s%s%s" % ("Hit", hseq[:59], cont, hseq[-5:]))
+
+        return "\n".join(lines)
+
+    # sequence properties #
+    def _set_seq(self, seq, seq_type):
+        """Check the given sequence for attribute setting (PRIVATE).
+
+        :param seq: sequence to check
+        :type seq: string or SeqRecord
+        :param seq_type: sequence type
+        :type seq_type: string, choice of 'hit' or 'query'
+
+        """
+        assert seq_type in ("hit", "query")
+        if seq is None:
+            return seq  # return immediately if seq is None
+        else:
+            if not isinstance(seq, (str, SeqRecord)):
+                raise TypeError(
+                    "%s sequence must be a string or a SeqRecord object." % seq_type
+                )
+        # check length if the opposite sequence is not None
+        opp_type = "hit" if seq_type == "query" else "query"
+        opp_seq = getattr(self, "_%s" % opp_type, None)
+        if opp_seq is not None:
+            if len(seq) != len(opp_seq):
+                raise ValueError(
+                    "Sequence lengths do not match. Expected: %r (%s); found: %r (%s)."
+                    % (len(opp_seq), opp_type, len(seq), seq_type)
+                )
+
+        seq_id = getattr(self, "%s_id" % seq_type)
+        seq_desc = getattr(self, "%s_description" % seq_type)
+        seq_feats = getattr(self, "%s_features" % seq_type)
+        seq_name = "aligned %s sequence" % seq_type
+
+        if isinstance(seq, SeqRecord):
+            seq.id = seq_id
+            seq.description = seq_desc
+            seq.name = seq_name
+            seq.features = seq_feats
+            seq.annotations["molecule_type"] = self.molecule_type
+        elif isinstance(seq, str):
+            seq = SeqRecord(
+                Seq(seq),
+                id=seq_id,
+                name=seq_name,
+                description=seq_desc,
+                features=seq_feats,
+                annotations={"molecule_type": self.molecule_type},
+            )
+
+        return seq
+
+    def _hit_get(self):
+        return self._hit
+
+    def _hit_set(self, value):
+        self._hit = self._set_seq(value, "hit")
+
+    hit = property(
+        fget=_hit_get,
+        fset=_hit_set,
+        doc="Hit sequence as a SeqRecord object, defaults to None.",
+    )
+
+    def _query_get(self):
+        return self._query
+
+    def _query_set(self, value):
+        self._query = self._set_seq(value, "query")
+
+    query = property(
+        fget=_query_get,
+        fset=_query_set,
+        doc="Query sequence as a SeqRecord object, defaults to None.",
+    )
+
+    def _aln_get(self):
+        if self.query is None and self.hit is None:
+            return None
+        if self.hit is None:
+            msa = MultipleSeqAlignment([self.query])
+        elif self.query is None:
+            msa = MultipleSeqAlignment([self.hit])
+        else:
+            msa = MultipleSeqAlignment([self.query, self.hit])
+        molecule_type = self.molecule_type
+        if molecule_type is not None:
+            msa.molecule_type = molecule_type
+        return msa
+
+    aln = property(
+        fget=_aln_get,
+        doc="Query-hit alignment as a MultipleSeqAlignment object, defaults to None.",
+    )
+
+    def _molecule_type_get(self):
+        return self._molecule_type
+
+    def _molecule_type_set(self, value):
+        self._molecule_type = value
+        try:
+            self.query.annotations["molecule_type"] = value
+        except AttributeError:
+            pass
+        try:
+            self.hit.annotations["molecule_type"] = value
+        except AttributeError:
+            pass
+
+    molecule_type = property(
+        fget=_molecule_type_get,
+        fset=_molecule_type_set,
+        doc="molecule type used in the fragment's "
+        "sequence records and alignment, defaults to None.",
+    )
+
+    def _aln_span_get(self):
+        # length of alignment (gaps included)
+        # alignment span can be its own attribute, or computed from
+        # query / hit length
+        try:
+            self._aln_span
+        except AttributeError:
+            if self.query is not None:
+                self._aln_span = len(self.query)
+            elif self.hit is not None:
+                self._aln_span = len(self.hit)
+
+        return self._aln_span
+
+    def _aln_span_set(self, value):
+        self._aln_span = value
+
+    aln_span = property(
+        fget=_aln_span_get,
+        fset=_aln_span_set,
+        doc="The number of alignment columns covered by the fragment.",
+    )
+
+    # id, description, and features properties #
+    hit_description = fragcascade("description", "hit", doc="Hit sequence description.")
+
+    query_description = fragcascade(
+        "description", "query", doc="Query sequence description."
+    )
+
+    hit_id = fragcascade("id", "hit", doc="Hit sequence ID.")
+
+    query_id = fragcascade("id", "query", doc="Query sequence ID.")
+
+    hit_features = fragcascade("features", "hit", doc="Hit sequence features.")
+
+    query_features = fragcascade("features", "query", doc="Query sequence features.")
+
+    # strand properties #
+    def _prep_strand(self, strand):
+        # follow SeqFeature's convention
+        if strand not in (-1, 0, 1, None):
+            raise ValueError("Strand should be -1, 0, 1, or None; not %r" % strand)
+        return strand
+
+    def _get_strand(self, seq_type):
+        assert seq_type in ("hit", "query")
+        strand = getattr(self, "_%s_strand" % seq_type)
+
+        if strand is None:
+            # try to compute strand from frame
+            frame = getattr(self, "%s_frame" % seq_type)
+            if frame is not None:
+                try:
+                    strand = frame // abs(frame)
+                except ZeroDivisionError:
+                    strand = 0
+                setattr(self, "%s_strand" % seq_type, strand)
+
+        return strand
+
+    def _hit_strand_get(self):
+        return self._get_strand("hit")
+
+    def _hit_strand_set(self, value):
+        self._hit_strand = self._prep_strand(value)
+
+    hit_strand = property(
+        fget=_hit_strand_get,
+        fset=_hit_strand_set,
+        doc="Hit sequence strand, defaults to None.",
+    )
+
+    def _query_strand_get(self):
+        return self._get_strand("query")
+
+    def _query_strand_set(self, value):
+        self._query_strand = self._prep_strand(value)
+
+    query_strand = property(
+        fget=_query_strand_get,
+        fset=_query_strand_set,
+        doc="Query sequence strand, defaults to None.",
+    )
+
+    # frame properties #
+    def _prep_frame(self, frame):
+        if frame not in (-3, -2, -1, 0, 1, 2, 3, None):
+            raise ValueError(
+                "Strand should be an integer between -3 and 3, or None; not %r" % frame
+            )
+        return frame
+
+    def _hit_frame_get(self):
+        return self._hit_frame
+
+    def _hit_frame_set(self, value):
+        self._hit_frame = self._prep_frame(value)
+
+    hit_frame = property(
+        fget=_hit_frame_get,
+        fset=_hit_frame_set,
+        doc="Hit sequence reading frame, defaults to None.",
+    )
+
+    def _query_frame_get(self):
+        """Get query sequence reading frame (PRIVATE)."""
+        return self._query_frame
+
+    def _query_frame_set(self, value):
+        """Set query sequence reading frame (PRIVATE)."""
+        self._query_frame = self._prep_frame(value)
+
+    query_frame = property(
+        fget=_query_frame_get,
+        fset=_query_frame_set,
+        doc="Query sequence reading frame, defaults to None.",
+    )
+
+    # coordinate properties #
+    def _prep_coord(self, coord, opp_coord_name, op):
+        # coord must either be None or int
+        if coord is None:
+            return coord
+        assert isinstance(coord, int)
+        # try to get opposite coordinate, if it's not present, return
+        try:
+            opp_coord = getattr(self, opp_coord_name)
+        except AttributeError:
+            return coord
+        # if opposite coordinate is None, return
+        if opp_coord is None:
+            return coord
+        # otherwise compare it to coord ('>=' or '<=')
+        else:
+            assert op(coord, opp_coord)
+        return coord
+
+    def _hit_start_get(self):
+        """Get the sequence hit start coordinate (PRIVATE)."""
+        return self._hit_start
+
+    def _hit_start_set(self, value):
+        """Set the sequence hit start coordinate (PRIVATE)."""
+        self._hit_start = self._prep_coord(value, "hit_end", le)
+
+    hit_start = property(
+        fget=_hit_start_get,
+        fset=_hit_start_set,
+        doc="Hit sequence start coordinate, defaults to None.",
+    )
+
+    def _query_start_get(self):
+        """Get the query sequence start coordinate (PRIVATE)."""
+        return self._query_start
+
+    def _query_start_set(self, value):
+        """Set the query sequence start coordinate (PRIVATE)."""
+        self._query_start = self._prep_coord(value, "query_end", le)
+
+    query_start = property(
+        fget=_query_start_get,
+        fset=_query_start_set,
+        doc="Query sequence start coordinate, defaults to None.",
+    )
+
+    def _hit_end_get(self):
+        """Get the hit sequence end coordinate (PRIVATE)."""
+        return self._hit_end
+
+    def _hit_end_set(self, value):
+        """Set the hit sequence end coordinate (PRIVATE)."""
+        self._hit_end = self._prep_coord(value, "hit_start", ge)
+
+    hit_end = property(
+        fget=_hit_end_get,
+        fset=_hit_end_set,
+        doc="Hit sequence end coordinate, defaults to None.",
+    )
+
+    def _query_end_get(self):
+        """Get the query sequence end coordinate (PRIVATE)."""
+        return self._query_end
+
+    def _query_end_set(self, value):
+        """Set the query sequence end coordinate (PRIVATE)."""
+        self._query_end = self._prep_coord(value, "query_start", ge)
+
+    query_end = property(
+        fget=_query_end_get,
+        fset=_query_end_set,
+        doc="Query sequence end coordinate, defaults to None.",
+    )
+
+    # coordinate-dependent properties #
+    def _hit_span_get(self):
+        """Return the number of residues covered by the hit sequence (PRIVATE)."""
+        try:
+            return self.hit_end - self.hit_start
+        except TypeError:  # triggered if any of the coordinates are None
+            return None
+
+    hit_span = property(
+        fget=_hit_span_get, doc="The number of residues covered by the hit sequence."
+    )
+
+    def _query_span_get(self):
+        """Return the number or residues covered by the query (PRIVATE)."""
+        try:
+            return self.query_end - self.query_start
+        except TypeError:  # triggered if any of the coordinates are None
+            return None
+
+    query_span = property(
+        fget=_query_span_get,
+        doc="The number of residues covered by the query sequence.",
+    )
+
+    def _hit_range_get(self):
+        """Return the start and end of a hit (PRIVATE)."""
+        return (self.hit_start, self.hit_end)
+
+    hit_range = property(
+        fget=_hit_range_get, doc="Tuple of hit start and end coordinates."
+    )
+
+    def _query_range_get(self):
+        """Return the start and end of a query (PRIVATE)."""
+        return (self.query_start, self.query_end)
+
+    query_range = property(
+        fget=_query_range_get, doc="Tuple of query start and end coordinates."
+    )
+
+
+# if not used as a module, run the doctest
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/_model/query.py

@@ -0,0 +1,737 @@
+# Copyright 2012 by Wibowo Arindrarto.  All rights reserved.
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+"""Bio.SearchIO object to model search results from a single query."""
+
+from copy import deepcopy
+from itertools import chain
+
+from Bio.SearchIO._utils import optionalcascade
+
+from ._base import _BaseSearchObject
+from .hit import Hit
+
+
+class QueryResult(_BaseSearchObject):
+    """Class representing search results from a single query.
+
+    QueryResult is the container object that stores all search hits from a
+    single search query. It is the top-level object returned by SearchIO's two
+    main functions, ``read`` and ``parse``. Depending on the search results and
+    search output format, a QueryResult object will contain zero or more Hit
+    objects (see Hit).
+
+    You can take a quick look at a QueryResult's contents and attributes by
+    invoking ``print`` on it::
+
+        >>> from Bio import SearchIO
+        >>> qresult = next(SearchIO.parse('Blast/mirna.xml', 'blast-xml'))
+        >>> print(qresult)
+        Program: blastn (2.2.27+)
+          Query: 33211 (61)
+                 mir_1
+         Target: refseq_rna
+           Hits: ----  -----  ----------------------------------------------------------
+                    #  # HSP  ID + description
+                 ----  -----  ----------------------------------------------------------
+                    0      1  gi|262205317|ref|NR_030195.1|  Homo sapiens microRNA 52...
+                    1      1  gi|301171311|ref|NR_035856.1|  Pan troglodytes microRNA...
+                    2      1  gi|270133242|ref|NR_032573.1|  Macaca mulatta microRNA ...
+                    3      2  gi|301171322|ref|NR_035857.1|  Pan troglodytes microRNA...
+                    4      1  gi|301171267|ref|NR_035851.1|  Pan troglodytes microRNA...
+                    5      2  gi|262205330|ref|NR_030198.1|  Homo sapiens microRNA 52...
+                    6      1  gi|262205302|ref|NR_030191.1|  Homo sapiens microRNA 51...
+                    7      1  gi|301171259|ref|NR_035850.1|  Pan troglodytes microRNA...
+                    8      1  gi|262205451|ref|NR_030222.1|  Homo sapiens microRNA 51...
+                    9      2  gi|301171447|ref|NR_035871.1|  Pan troglodytes microRNA...
+                   10      1  gi|301171276|ref|NR_035852.1|  Pan troglodytes microRNA...
+                   11      1  gi|262205290|ref|NR_030188.1|  Homo sapiens microRNA 51...
+        ...
+
+    If you just want to know how many hits a QueryResult has, you can invoke
+    ``len`` on it. Alternatively, you can simply type its name in the interpreter::
+
+        >>> len(qresult)
+        100
+        >>> qresult
+        QueryResult(id='33211', 100 hits)
+
+    QueryResult behaves like a hybrid of Python's built-in list and dictionary.
+    You can retrieve its items (Hit objects) using the integer index of the
+    item, just like regular Python lists::
+
+        >>> first_hit = qresult[0]
+        >>> first_hit
+        Hit(id='gi|262205317|ref|NR_030195.1|', query_id='33211', 1 hsps)
+
+    You can slice QueryResult objects as well. Slicing will return a new
+    QueryResult object containing only the sliced hits::
+
+        >>> sliced_qresult = qresult[:3]    # slice the first three hits
+        >>> len(qresult)
+        100
+        >>> len(sliced_qresult)
+        3
+        >>> print(sliced_qresult)
+        Program: blastn (2.2.27+)
+          Query: 33211 (61)
+                 mir_1
+         Target: refseq_rna
+           Hits: ----  -----  ----------------------------------------------------------
+                    #  # HSP  ID + description
+                 ----  -----  ----------------------------------------------------------
+                    0      1  gi|262205317|ref|NR_030195.1|  Homo sapiens microRNA 52...
+                    1      1  gi|301171311|ref|NR_035856.1|  Pan troglodytes microRNA...
+                    2      1  gi|270133242|ref|NR_032573.1|  Macaca mulatta microRNA ...
+
+    Like Python dictionaries, you can also retrieve hits using the hit's ID.
+    This is useful for retrieving hits that you know should exist in a given
+    search::
+
+        >>> hit = qresult['gi|262205317|ref|NR_030195.1|']
+        >>> hit
+        Hit(id='gi|262205317|ref|NR_030195.1|', query_id='33211', 1 hsps)
+
+    You can also replace a Hit in QueryResult with another Hit using either the
+    integer index or hit key string. Note that the replacing object must be a
+    Hit that has the same ``query_id`` property as the QueryResult object.
+
+    If you're not sure whether a QueryResult contains a particular hit, you can
+    use the hit ID to check for membership first::
+
+        >>> 'gi|262205317|ref|NR_030195.1|' in qresult
+        True
+        >>> 'gi|262380031|ref|NR_023426.1|' in qresult
+        False
+
+    Or, if you just want to know the rank / position of a given hit, you can
+    use the hit ID as an argument for the ``index`` method. Note that the values
+    returned will be zero-based. So zero (0) means the hit is the first in the
+    QueryResult, three (3) means the hit is the fourth item, and so on. If the
+    hit does not exist in the QueryResult, a ``ValueError`` will be raised.
+
+        >>> qresult.index('gi|262205317|ref|NR_030195.1|')
+        0
+        >>> qresult.index('gi|262205330|ref|NR_030198.1|')
+        5
+        >>> qresult.index('gi|262380031|ref|NR_023426.1|')
+        Traceback (most recent call last):
+        ...
+        ValueError: ...
+
+    To ease working with a large number of hits, QueryResult has several
+    ``filter`` and ``map`` methods, analogous to Python's built-in functions with
+    the same names. There are ``filter`` and ``map`` methods available for
+    operations over both Hit objects or HSP objects. As an example, here we are
+    using the ``hit_map`` method to rename all hit IDs within a QueryResult::
+
+        >>> def renamer(hit):
+        ...     hit.id = hit.id.split('|')[3]
+        ...     return hit
+        >>> mapped_qresult = qresult.hit_map(renamer)
+        >>> print(mapped_qresult)
+        Program: blastn (2.2.27+)
+          Query: 33211 (61)
+                 mir_1
+         Target: refseq_rna
+           Hits: ----  -----  ----------------------------------------------------------
+                    #  # HSP  ID + description
+                 ----  -----  ----------------------------------------------------------
+                    0      1  NR_030195.1  Homo sapiens microRNA 520b (MIR520B), micr...
+                    1      1  NR_035856.1  Pan troglodytes microRNA mir-520b (MIR520B...
+                    2      1  NR_032573.1  Macaca mulatta microRNA mir-519a (MIR519A)...
+        ...
+
+    The principle for other ``map`` and ``filter`` methods are similar: they accept
+    a function, applies it, and returns a new QueryResult object.
+
+    There are also other methods useful for working with list-like objects:
+    ``append``, ``pop``, and ``sort``. More details and examples are available in
+    their respective documentations.
+
+    Finally, just like Python lists and dictionaries, QueryResult objects are
+    iterable. Iteration over QueryResults will yield Hit objects::
+
+        >>> for hit in qresult[:4]:     # iterate over the first four items
+        ...     hit
+        ...
+        Hit(id='gi|262205317|ref|NR_030195.1|', query_id='33211', 1 hsps)
+        Hit(id='gi|301171311|ref|NR_035856.1|', query_id='33211', 1 hsps)
+        Hit(id='gi|270133242|ref|NR_032573.1|', query_id='33211', 1 hsps)
+        Hit(id='gi|301171322|ref|NR_035857.1|', query_id='33211', 2 hsps)
+
+    If you need access to all the hits in a QueryResult object, you can get
+    them in a list using the ``hits`` property. Similarly, access to all hit IDs is
+    available through the ``hit_keys`` property.
+
+        >>> qresult.hits
+        [Hit(id='gi|262205317|ref|NR_030195.1|', query_id='33211', 1 hsps), ...]
+        >>> qresult.hit_keys
+        ['gi|262205317|ref|NR_030195.1|', 'gi|301171311|ref|NR_035856.1|', ...]
+
+    """
+
+    # attributes we don't want to transfer when creating a new QueryResult class
+    # from this one
+    _NON_STICKY_ATTRS = ("_items", "__alt_hit_ids")
+
+    def __init__(self, hits=(), id=None, hit_key_function=None):
+        """Initialize a QueryResult object.
+
+        :param id: query sequence ID
+        :type id: string
+        :param hits: iterator yielding Hit objects
+        :type hits: iterable
+        :param hit_key_function: function to define hit keys
+        :type hit_key_function: callable, accepts Hit objects, returns string
+
+        """
+        # default values
+        self._id = id
+        self._hit_key_function = hit_key_function or _hit_key_func
+        self._items = {}
+        self._description = None
+        self.__alt_hit_ids = {}
+        self.program = "<unknown program>"
+        self.target = "<unknown target>"
+        self.version = "<unknown version>"
+
+        # validate Hit objects and fill up self._items
+        for hit in hits:
+            # validation is handled by __setitem__
+            self.append(hit)
+
+    def __iter__(self):
+        """Iterate over hits."""
+        return iter(self.hits)
+
+    @property
+    def hits(self):
+        """Hit objects contained in the QueryResult."""
+        return list(self._items.values())
+
+    @property
+    def hit_keys(self):
+        """Hit IDs of the Hit objects contained in the QueryResult."""
+        return list(self._items.keys())
+
+    @property
+    def items(self):
+        """List of tuples of Hit IDs and Hit objects."""
+        return list(self._items.items())
+
+    def iterhits(self):
+        """Return an iterator over the Hit objects."""
+        yield from self._items.values()
+
+    def iterhit_keys(self):
+        """Return an iterator over the ID of the Hit objects."""
+        yield from self._items
+
+    def iteritems(self):
+        """Return an iterator yielding tuples of Hit ID and Hit objects."""
+        yield from self._items.items()
+
+    def __contains__(self, hit_key):
+        """Return True if hit key in items or alternative hit identifiers."""
+        if isinstance(hit_key, Hit):
+            return self._hit_key_function(hit_key) in self._items
+        return hit_key in self._items or hit_key in self.__alt_hit_ids
+
+    def __len__(self):
+        """Return the number of items."""
+        return len(self._items)
+
+    def __bool__(self):
+        """Return True if there are items."""
+        return bool(self._items)
+
+    def __repr__(self):
+        """Return string representation of the QueryResult object."""
+        return "QueryResult(id=%r, %r hits)" % (self.id, len(self))
+
+    def __str__(self):
+        """Return a human readable summary of the QueryResult object."""
+        lines = []
+
+        # set program and version line
+        lines.append("Program: %s (%s)" % (self.program, self.version))
+
+        # set query id line
+        qid_line = "  Query: %s" % self.id
+        try:
+            seq_len = self.seq_len
+        except AttributeError:
+            pass
+        else:
+            qid_line += " (%i)" % seq_len
+        lines.append(qid_line)
+        if self.description:
+            line = "         %s" % self.description
+            line = line[:77] + "..." if len(line) > 80 else line
+            lines.append(line)
+
+        # set target line
+        lines.append(" Target: %s" % self.target)
+
+        # set hit lines
+        if not self.hits:
+            lines.append("   Hits: 0")
+        else:
+            lines.append("   Hits: %s  %s  %s" % ("-" * 4, "-" * 5, "-" * 58))
+            pattern = "%13s  %5s  %s"
+            lines.append(pattern % ("#", "# HSP", "ID + description"))
+            lines.append(pattern % ("-" * 4, "-" * 5, "-" * 58))
+            for idx, hit in enumerate(self.hits):
+                if idx < 30:
+                    hid_line = "%s  %s" % (hit.id, hit.description)
+                    if len(hid_line) > 58:
+                        hid_line = hid_line[:55] + "..."
+                    lines.append(pattern % (idx, len(hit), hid_line))
+                elif idx > len(self.hits) - 4:
+                    hid_line = "%s  %s" % (hit.id, hit.description)
+                    if len(hid_line) > 58:
+                        hid_line = hid_line[:55] + "..."
+                    lines.append(pattern % (idx, len(hit), hid_line))
+                elif idx == 30:
+                    lines.append("%14s" % "~~~")
+
+        return "\n".join(lines)
+
+    def __getitem__(self, hit_key):
+        """Return a QueryResult object that matches the hit_key."""
+        # retrieval using slice objects returns another QueryResult object
+        if isinstance(hit_key, slice):
+            # should we return just a list of Hits instead of a full blown
+            # QueryResult object if it's a slice?
+            hits = list(self.hits)[hit_key]
+            obj = self.__class__(hits, self.id, self._hit_key_function)
+            self._transfer_attrs(obj)
+            return obj
+
+        # if key is an int, then retrieve the Hit at the int index
+        elif isinstance(hit_key, int):
+            length = len(self)
+            if 0 <= hit_key < length:
+                for idx, item in enumerate(self.iterhits()):
+                    if idx == hit_key:
+                        return item
+            elif -1 * length <= hit_key < 0:
+                for idx, item in enumerate(self.iterhits()):
+                    if length + hit_key == idx:
+                        return item
+            raise IndexError("list index out of range")
+
+        # if key is a string, then do a regular dictionary retrieval
+        # falling back on alternative hit IDs
+        try:
+            return self._items[hit_key]
+        except KeyError:
+            return self._items[self.__alt_hit_ids[hit_key]]
+
+    def __setitem__(self, hit_key, hit):
+        """Add an item of key hit_key and value hit."""
+        # only accept string keys
+        if not isinstance(hit_key, str):
+            raise TypeError("QueryResult object keys must be a string.")
+        # hit must be a Hit object
+        if not isinstance(hit, Hit):
+            raise TypeError("QueryResult objects can only contain Hit objects.")
+        qid = self.id
+        hqid = hit.query_id
+        # and it must have the same query ID as this object's ID
+        # unless it's the query ID is None (default for empty objects), in which
+        # case we want to use the hit's query ID as the query ID
+        if qid is not None:
+            if hqid != qid:
+                raise ValueError(
+                    "Expected Hit with query ID %r, found %r instead." % (qid, hqid)
+                )
+        else:
+            self.id = hqid
+        # same thing with descriptions
+        qdesc = self.description
+        hqdesc = hit.query_description
+        if qdesc is not None:
+            if hqdesc != qdesc:
+                raise ValueError(
+                    "Expected Hit with query description %r, found %r instead."
+                    % (qdesc, hqdesc)
+                )
+        else:
+            self.description = hqdesc
+
+        # remove existing alt_id references, if hit_key already exists
+        if hit_key in self._items:
+            for alt_key in self._items[hit_key].id_all[1:]:
+                del self.__alt_hit_ids[alt_key]
+
+        # if hit_key is already present as an alternative ID
+        # delete it from the alternative ID dict
+        if hit_key in self.__alt_hit_ids:
+            del self.__alt_hit_ids[hit_key]
+
+        self._items[hit_key] = hit
+        for alt_id in hit.id_all[1:]:
+            self.__alt_hit_ids[alt_id] = hit_key
+
+    def __delitem__(self, hit_key):
+        """Delete item of key hit_key."""
+        # if hit_key an integer or slice, get the corresponding key first
+        # and put it into a list
+        if isinstance(hit_key, int):
+            hit_keys = [list(self.hit_keys)[hit_key]]
+        # the same, if it's a slice
+        elif isinstance(hit_key, slice):
+            hit_keys = list(self.hit_keys)[hit_key]
+        # otherwise put it in a list
+        else:
+            hit_keys = [hit_key]
+
+        for key in hit_keys:
+            deleted = False
+            if key in self._items:
+                del self._items[key]
+                deleted = True
+            if key in self.__alt_hit_ids:
+                del self._items[self.__alt_hit_ids[key]]
+                del self.__alt_hit_ids[key]
+                deleted = True
+            if not deleted:
+                raise KeyError(repr(key))
+
+    # properties #
+    id = optionalcascade("_id", "query_id", """QueryResult ID string""")
+    description = optionalcascade(
+        "_description", "query_description", """QueryResult description"""
+    )
+
+    @property
+    def hsps(self):
+        """Access the HSP objects contained in the QueryResult."""
+        return sorted(
+            (hsp for hsp in chain(*self.hits)), key=lambda hsp: hsp.output_index
+        )
+
+    @property
+    def fragments(self):
+        """Access the HSPFragment objects contained in the QueryResult."""
+        return list(chain(*self.hsps))
+
+    # public methods #
+    def absorb(self, hit):
+        """Add a Hit object to the end of QueryResult.
+
+        If the QueryResult already has a Hit with the same ID, append the new
+        Hit's HSPs into the existing Hit.
+
+        :param hit: object to absorb
+        :type hit: Hit
+
+        This method is used for file formats that may output the same Hit in
+        separate places, such as BLAT or Exonerate. In both formats, Hit
+        with different strands are put in different places. However, SearchIO
+        considers them to be the same as a Hit object should be all database
+        entries with the same ID, regardless of strand orientation.
+
+        """
+        try:
+            self.append(hit)
+        except ValueError:
+            assert hit.id in self
+            for hsp in hit:
+                self[hit.id].append(hsp)
+
+    def append(self, hit):
+        """Add a Hit object to the end of QueryResult.
+
+        :param hit: object to append
+        :type hit: Hit
+
+        Any Hit object appended must have the same ``query_id`` property as the
+        QueryResult's ``id`` property. If the hit key already exists, a
+        ``ValueError`` will be raised.
+
+        """
+        # if a custom hit_key_function is supplied, use it to define th hit key
+        if self._hit_key_function is not None:
+            hit_key = self._hit_key_function(hit)
+        else:
+            hit_key = hit.id
+
+        if hit_key not in self and all(pid not in self for pid in hit.id_all[1:]):
+            self[hit_key] = hit
+        else:
+            raise ValueError(
+                "The ID or alternative IDs of Hit %r exists in this QueryResult."
+                % hit_key
+            )
+
+    def hit_filter(self, func=None):
+        """Create new QueryResult object whose Hit objects pass the filter function.
+
+        :param func: filter function
+        :type func: callable, accepts Hit, returns bool
+
+        Here is an example of using ``hit_filter`` to select Hits whose
+        description begins with the string 'Homo sapiens', case sensitive::
+
+            >>> from Bio import SearchIO
+            >>> qresult = next(SearchIO.parse('Blast/mirna.xml', 'blast-xml'))
+            >>> def desc_filter(hit):
+            ...     return hit.description.startswith('Homo sapiens')
+            ...
+            >>> len(qresult)
+            100
+            >>> filtered = qresult.hit_filter(desc_filter)
+            >>> len(filtered)
+            39
+            >>> print(filtered[:4])
+            Program: blastn (2.2.27+)
+              Query: 33211 (61)
+                     mir_1
+             Target: refseq_rna
+               Hits: ----  -----  ----------------------------------------------------------
+                        #  # HSP  ID + description
+                     ----  -----  ----------------------------------------------------------
+                        0      1  gi|262205317|ref|NR_030195.1|  Homo sapiens microRNA 52...
+                        1      2  gi|262205330|ref|NR_030198.1|  Homo sapiens microRNA 52...
+                        2      1  gi|262205302|ref|NR_030191.1|  Homo sapiens microRNA 51...
+                        3      1  gi|262205451|ref|NR_030222.1|  Homo sapiens microRNA 51...
+
+        Note that instance attributes (other than the hits) from the unfiltered
+        QueryResult are retained in the filtered object.
+
+            >>> qresult.program == filtered.program
+            True
+            >>> qresult.target == filtered.target
+            True
+
+        """
+        hits = list(filter(func, self.hits))
+        obj = self.__class__(hits, self.id, self._hit_key_function)
+        self._transfer_attrs(obj)
+        return obj
+
+    def hit_map(self, func=None):
+        """Create new QueryResult object, mapping the given function to its Hits.
+
+        :param func: map function
+        :type func: callable, accepts Hit, returns Hit
+
+        Here is an example of using ``hit_map`` with a function that discards all
+        HSPs in a Hit except for the first one::
+
+            >>> from Bio import SearchIO
+            >>> qresult = next(SearchIO.parse('Blast/mirna.xml', 'blast-xml'))
+            >>> print(qresult[:8])
+            Program: blastn (2.2.27+)
+              Query: 33211 (61)
+                     mir_1
+             Target: refseq_rna
+               Hits: ----  -----  ----------------------------------------------------------
+                        #  # HSP  ID + description
+                     ----  -----  ----------------------------------------------------------
+                        0      1  gi|262205317|ref|NR_030195.1|  Homo sapiens microRNA 52...
+                        1      1  gi|301171311|ref|NR_035856.1|  Pan troglodytes microRNA...
+                        2      1  gi|270133242|ref|NR_032573.1|  Macaca mulatta microRNA ...
+                        3      2  gi|301171322|ref|NR_035857.1|  Pan troglodytes microRNA...
+                        4      1  gi|301171267|ref|NR_035851.1|  Pan troglodytes microRNA...
+                        5      2  gi|262205330|ref|NR_030198.1|  Homo sapiens microRNA 52...
+                        6      1  gi|262205302|ref|NR_030191.1|  Homo sapiens microRNA 51...
+                        7      1  gi|301171259|ref|NR_035850.1|  Pan troglodytes microRNA...
+
+            >>> top_hsp = lambda hit: hit[:1]
+            >>> mapped_qresult = qresult.hit_map(top_hsp)
+            >>> print(mapped_qresult[:8])
+            Program: blastn (2.2.27+)
+              Query: 33211 (61)
+                     mir_1
+             Target: refseq_rna
+               Hits: ----  -----  ----------------------------------------------------------
+                        #  # HSP  ID + description
+                     ----  -----  ----------------------------------------------------------
+                        0      1  gi|262205317|ref|NR_030195.1|  Homo sapiens microRNA 52...
+                        1      1  gi|301171311|ref|NR_035856.1|  Pan troglodytes microRNA...
+                        2      1  gi|270133242|ref|NR_032573.1|  Macaca mulatta microRNA ...
+                        3      1  gi|301171322|ref|NR_035857.1|  Pan troglodytes microRNA...
+                        4      1  gi|301171267|ref|NR_035851.1|  Pan troglodytes microRNA...
+                        5      1  gi|262205330|ref|NR_030198.1|  Homo sapiens microRNA 52...
+                        6      1  gi|262205302|ref|NR_030191.1|  Homo sapiens microRNA 51...
+                        7      1  gi|301171259|ref|NR_035850.1|  Pan troglodytes microRNA...
+
+        """
+        hits = [deepcopy(hit) for hit in self.hits]
+        if func is not None:
+            hits = [func(x) for x in hits]
+        obj = self.__class__(hits, self.id, self._hit_key_function)
+        self._transfer_attrs(obj)
+        return obj
+
+    def hsp_filter(self, func=None):
+        """Create new QueryResult object whose HSP objects pass the filter function.
+
+        ``hsp_filter`` is the same as ``hit_filter``, except that it filters
+        directly on each HSP object in every Hit. If the filtering removes
+        all HSP objects in a given Hit, the entire Hit will be discarded. This
+        will result in the QueryResult having less Hit after filtering.
+        """
+        hits = [x for x in (hit.filter(func) for hit in self.hits) if x]
+        obj = self.__class__(hits, self.id, self._hit_key_function)
+        self._transfer_attrs(obj)
+        return obj
+
+    def hsp_map(self, func=None):
+        """Create new QueryResult object, mapping the given function to its HSPs.
+
+        ``hsp_map`` is the same as ``hit_map``, except that it applies the given
+        function to all HSP objects in every Hit, instead of the Hit objects.
+        """
+        hits = [x for x in (hit.map(func) for hit in list(self.hits)[:]) if x]
+        obj = self.__class__(hits, self.id, self._hit_key_function)
+        self._transfer_attrs(obj)
+        return obj
+
+    # marker for default self.pop() return value
+    # this method is adapted from Python's built in OrderedDict.pop
+    # implementation
+    __marker = object()
+
+    def pop(self, hit_key=-1, default=__marker):
+        """Remove the specified hit key and return the Hit object.
+
+        :param hit_key: key of the Hit object to return
+        :type hit_key: int or string
+        :param default: return value if no Hit exists with the given key
+        :type default: object
+
+        By default, ``pop`` will remove and return the last Hit object in the
+        QueryResult object. To remove specific Hit objects, you can use its
+        integer index or hit key.
+
+            >>> from Bio import SearchIO
+            >>> qresult = next(SearchIO.parse('Blast/mirna.xml', 'blast-xml'))
+            >>> len(qresult)
+            100
+            >>> for hit in qresult[:5]:
+            ...     print(hit.id)
+            ...
+            gi|262205317|ref|NR_030195.1|
+            gi|301171311|ref|NR_035856.1|
+            gi|270133242|ref|NR_032573.1|
+            gi|301171322|ref|NR_035857.1|
+            gi|301171267|ref|NR_035851.1|
+
+            # remove the last hit
+            >>> qresult.pop()
+            Hit(id='gi|397513516|ref|XM_003827011.1|', query_id='33211', 1 hsps)
+
+            # remove the first hit
+            >>> qresult.pop(0)
+            Hit(id='gi|262205317|ref|NR_030195.1|', query_id='33211', 1 hsps)
+
+            # remove hit with the given ID
+            >>> qresult.pop('gi|301171322|ref|NR_035857.1|')
+            Hit(id='gi|301171322|ref|NR_035857.1|', query_id='33211', 2 hsps)
+
+        """
+        # if key is an integer (index)
+        # get the ID for the Hit object at that index
+        if isinstance(hit_key, int):
+            # raise the appropriate error if there is no hit
+            if not self:
+                raise IndexError("pop from empty list")
+            hit_key = list(self.hit_keys)[hit_key]
+
+        try:
+            hit = self._items.pop(hit_key)
+            # remove all alternative IDs of the popped hit
+            for alt_id in hit.id_all[1:]:
+                self.__alt_hit_ids.pop(alt_id, None)
+        except KeyError:
+            try:
+                hit = self.pop(self.__alt_hit_ids[hit_key])
+            except KeyError:
+                # hit_key is not a valid id
+                # use the default if it has been set
+                if default is not self.__marker:
+                    hit = default
+                else:
+                    raise KeyError(hit_key) from None
+        return hit
+
+    def index(self, hit_key):
+        """Return the index of a given hit key, zero-based.
+
+        :param hit_key: hit ID
+        :type hit_key: string
+
+        This method is useful for finding out the integer index (usually
+        correlated with search rank) of a given hit key.
+
+            >>> from Bio import SearchIO
+            >>> qresult = next(SearchIO.parse('Blast/mirna.xml', 'blast-xml'))
+            >>> qresult.index('gi|301171259|ref|NR_035850.1|')
+            7
+
+        """
+        if isinstance(hit_key, Hit):
+            return list(self.hit_keys).index(hit_key.id)
+        try:
+            return list(self.hit_keys).index(hit_key)
+        except ValueError:
+            if hit_key in self.__alt_hit_ids:
+                return self.index(self.__alt_hit_ids[hit_key])
+            raise
+
+    def sort(self, key=None, reverse=False, in_place=True):
+        """Sort the Hit objects.
+
+        :param key: sorting function
+        :type key: callable, accepts Hit, returns key for sorting
+        :param reverse: whether to reverse sorting results or no
+        :type reverse: bool
+        :param in_place: whether to do in-place sorting or no
+        :type in_place: bool
+
+        ``sort`` defaults to sorting in-place, to mimic Python's ``list.sort``
+        method. If you set the ``in_place`` argument to False, it will treat
+        return a new, sorted QueryResult object and keep the initial one
+        unsorted.
+
+        """
+        if key is None:
+            # if reverse is True, reverse the hits
+            if reverse:
+                sorted_hits = list(self.hits)[::-1]
+            # otherwise (default options) make a copy of the hits
+            else:
+                sorted_hits = list(self.hits)[:]
+        else:
+            sorted_hits = sorted(self.hits, key=key, reverse=reverse)
+
+        # if sorting is in-place, don't create a new QueryResult object
+        if in_place:
+            self._items = {self._hit_key_function(hit): hit for hit in sorted_hits}
+        # otherwise, return a new sorted QueryResult object
+        else:
+            obj = self.__class__(sorted_hits, self.id, self._hit_key_function)
+            self._transfer_attrs(obj)
+            return obj
+
+
+def _hit_key_func(hit):
+    """Map hit to its identifier (PRIVATE).
+
+    Default hit key function for QueryResult.__init__ use.
+    """
+    return hit.id
+
+
+# if not used as a module, run the doctest
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()

.venv_haddock/lib/python3.12/site-packages/Bio/SearchIO/_utils.py

@@ -0,0 +1,169 @@
+# Copyright 2012 by Wibowo Arindrarto.  All rights reserved.
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+"""Common SearchIO utility functions."""
+
+import sys
+
+
+def getattr_str(obj, attr, fmt=None, fallback="?"):
+    """Return string of the given object's attribute.
+
+    Defaults to the given fallback value if attribute is not present.
+    """
+    try:
+        value = getattr(obj, attr)
+    except AttributeError:
+        return fallback
+    if fmt is None:
+        return str(value)
+    return fmt % value
+
+
+def read_forward(handle):
+    """Read through whitespaces, return the first non-whitespace line."""
+    while True:
+        line = handle.readline()
+        # if line is empty or line has characters and stripping does not remove
+        # them, return the line
+        if (not line) or (line and line.strip()):
+            return line
+
+
+def get_processor(format, mapping):
+    """Return the object to process the given format according to the mapping.
+
+    :param format: format name
+    :type format: string, lower case
+    :param mapping: mapping of format name and its processor object
+    :type mapping: dictionary {string: object}
+
+    """
+    # map file format to iterator name
+    try:
+        obj_info = mapping[format]
+    except KeyError:
+        # handle the errors with helpful messages
+        if format is None:
+            raise ValueError("Format required (lower case string)") from None
+        elif not isinstance(format, str):
+            raise TypeError("Need a string for the file format (lower case)") from None
+        elif format != format.lower():
+            raise ValueError("Format string %r should be lower case" % format) from None
+        else:
+            raise ValueError(
+                "Unknown format %r. Supported formats are %r"
+                % (format, "', '".join(mapping))
+            ) from None
+
+    mod_name, obj_name = obj_info
+    mod = __import__("Bio.SearchIO.%s" % mod_name, fromlist=[""])
+
+    return getattr(mod, obj_name)
+
+
+def singleitem(attr=None, doc=""):
+    """Property for fetching attribute from first entry of container.
+
+    Returns a property that fetches the given attribute from
+    the first item in a SearchIO container object.
+    """
+
+    def getter(self):
+        if len(self._items) > 1:
+            raise ValueError("More than one HSPFragment objects found in HSP")
+        if attr is None:
+            return self._items[0]
+        return getattr(self._items[0], attr)
+
+    return property(fget=getter, doc=doc)
+
+
+def allitems(attr=None, doc=""):
+    """Property for fetching attribute from all entries of container.
+
+    Returns a property that fetches the given attributes from
+    all items in a SearchIO container object.
+    """
+
+    def getter(self):
+        if attr is None:
+            return self._items
+        return [getattr(frag, attr) for frag in self._items]
+
+    return property(fget=getter, doc=doc)
+
+
+def fullcascade(attr, doc=""):
+    """Return a getter property with a cascading setter.
+
+    This is similar to ``optionalcascade``, but for SearchIO containers that have
+    at least one item (HSP). The getter always retrieves the attribute
+    value from the first item. If the items have more than one attribute values,
+    an error will be raised. The setter behaves like ``partialcascade``, except
+    that it only sets attributes to items in the object, not the object itself.
+
+    """
+
+    def getter(self):
+        return getattr(self._items[0], attr)
+
+    def setter(self, value):
+        for item in self:
+            setattr(item, attr, value)
+
+    return property(fget=getter, fset=setter, doc=doc)
+
+
+def optionalcascade(cont_attr, item_attr, doc=""):
+    """Return a getter property with a cascading setter.
+
+    This is used for the ``id`` and ``description`` properties of the container
+    objects with zero or more items. These items have their own private
+    attributes that stores query and/or hit ID and description. When the
+    container has zero items, attribute values are always retrieved from the
+    container's attribute. Otherwise, the first item's attribute is used.
+
+    To keep the container items' query and/or hit ID and description in-sync,
+    the setter cascades any new value given to the items' values.
+
+    """
+
+    def getter(self):
+        if self._items:
+            # don't use self._items here, so QueryResult can use this property
+            # as well (the underlying dict is not integer-indexable)
+            return getattr(self[0], item_attr)
+        else:
+            return getattr(self, cont_attr)
+
+    def setter(self, value):
+        setattr(self, cont_attr, value)
+        for item in self:
+            setattr(item, item_attr, value)
+
+    return property(fget=getter, fset=setter, doc=doc)
+
+
+def fragcascade(attr, seq_type, doc=""):
+    """Return a getter property with cascading setter, for HSPFragment objects.
+
+    Similar to ``partialcascade``, but for HSPFragment objects and acts on ``query``
+    or ``hit`` properties of the object if they are not None.
+
+    """
+    assert seq_type in ("hit", "query")
+    attr_name = f"_{seq_type}_{attr}"
+
+    def getter(self):
+        return getattr(self, attr_name)
+
+    def setter(self, value):
+        setattr(self, attr_name, value)
+        seq = getattr(self, seq_type)
+        if seq is not None:
+            setattr(seq, attr, value)
+
+    return property(fget=getter, fset=setter, doc=doc)

.venv_haddock/lib/python3.12/site-packages/Bio/SeqFeature.py

@@ -0,0 +1,2332 @@
+# Copyright 2000-2003 Jeff Chang.
+# Copyright 2001-2008 Brad Chapman.
+# Copyright 2005-2024 by Peter Cock.
+# Copyright 2006-2009 Michiel de Hoon.
+# All rights reserved.
+#
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+"""Represent a Sequence Feature holding info about a part of a sequence.
+
+This is heavily modeled after the Biocorba SeqFeature objects, and
+may be pretty biased towards GenBank stuff since I'm writing it
+for the GenBank parser output...
+
+What's here:
+
+Base class to hold a Feature
+----------------------------
+
+Classes:
+ - SeqFeature
+
+Hold information about a Reference
+----------------------------------
+
+This is an attempt to create a General class to hold Reference type
+information.
+
+Classes:
+ - Reference
+
+Specify locations of a feature on a Sequence
+--------------------------------------------
+
+This aims to handle, in Ewan Birney's words, 'the dreaded fuzziness issue'.
+This has the advantages of allowing us to handle fuzzy stuff in case anyone
+needs it, and also be compatible with BioPerl etc and BioSQL.
+
+Classes:
+ - Location - abstract base class of SimpleLocation and CompoundLocation.
+ - SimpleLocation - Specify the start and end location of a feature.
+ - CompoundLocation - Collection of SimpleLocation objects (for joins etc).
+ - Position - abstract base class of ExactPosition, WithinPosition,
+   BetweenPosition, AfterPosition, OneOfPosition, UncertainPosition, and
+   UnknownPosition.
+ - ExactPosition - Specify the position as being exact.
+ - WithinPosition - Specify a position occurring within some range.
+ - BetweenPosition - Specify a position occurring between a range (OBSOLETE?).
+ - BeforePosition - Specify the position as being found before some base.
+ - AfterPosition - Specify the position as being found after some base.
+ - OneOfPosition - Specify a position consisting of multiple alternative positions.
+ - UncertainPosition - Specify a specific position which is uncertain.
+ - UnknownPosition - Represents missing information like '?' in UniProt.
+
+
+Exceptions:
+ - LocationParserError - Exception indicating a failure to parse a location
+   string.
+
+"""
+
+import functools
+import re
+import warnings
+from abc import ABC
+from abc import abstractmethod
+
+from Bio import BiopythonParserWarning
+from Bio.Seq import MutableSeq
+from Bio.Seq import reverse_complement
+from Bio.Seq import Seq
+
+# Regular expressions for location parsing
+
+_reference = r"(?:[a-zA-Z][a-zA-Z0-9_\.\|]*[a-zA-Z0-9]?\:)"
+_oneof_position = r"one\-of\(\d+[,\d+]+\)"
+
+_oneof_location = rf"[<>]?(?:\d+|{_oneof_position})\.\.[<>]?(?:\d+|{_oneof_position})"
+
+_any_location = rf"({_reference}?{_oneof_location}|complement\({_oneof_location}\)|[^,]+|complement\([^,]+\))"
+
+_split = re.compile(_any_location).split
+
+assert _split("123..145")[1::2] == ["123..145"]
+assert _split("123..145,200..209")[1::2] == ["123..145", "200..209"]
+assert _split("one-of(200,203)..300")[1::2] == ["one-of(200,203)..300"]
+assert _split("complement(123..145),200..209")[1::2] == [
+    "complement(123..145)",
+    "200..209",
+]
+assert _split("123..145,one-of(200,203)..209")[1::2] == [
+    "123..145",
+    "one-of(200,203)..209",
+]
+assert _split("123..145,one-of(200,203)..one-of(209,211),300")[1::2] == [
+    "123..145",
+    "one-of(200,203)..one-of(209,211)",
+    "300",
+]
+assert _split("123..145,complement(one-of(200,203)..one-of(209,211)),300")[1::2] == [
+    "123..145",
+    "complement(one-of(200,203)..one-of(209,211))",
+    "300",
+]
+assert _split("123..145,200..one-of(209,211),300")[1::2] == [
+    "123..145",
+    "200..one-of(209,211)",
+    "300",
+]
+assert _split("123..145,200..one-of(209,211)")[1::2] == [
+    "123..145",
+    "200..one-of(209,211)",
+]
+assert _split(
+    "complement(149815..150200),complement(293787..295573),NC_016402.1:6618..6676,181647..181905"
+)[1::2] == [
+    "complement(149815..150200)",
+    "complement(293787..295573)",
+    "NC_016402.1:6618..6676",
+    "181647..181905",
+]
+
+_pair_location = r"[<>]?-?\d+\.\.[<>]?-?\d+"
+
+_between_location = r"\d+\^\d+"
+
+_within_position = r"\(\d+\.\d+\)"
+_within_location = r"([<>]?\d+|%s)\.\.([<>]?\d+|%s)" % (
+    _within_position,
+    _within_position,
+)
+_within_position = r"\((\d+)\.(\d+)\)"
+_re_within_position = re.compile(_within_position)
+assert _re_within_position.match("(3.9)")
+
+_oneof_location = r"([<>]?\d+|%s)\.\.([<>]?\d+|%s)" % (_oneof_position, _oneof_position)
+_oneof_position = r"one\-of\((\d+[,\d+]+)\)"
+_re_oneof_position = re.compile(_oneof_position)
+assert _re_oneof_position.match("one-of(6,9)")
+assert not _re_oneof_position.match("one-of(3)")
+assert _re_oneof_position.match("one-of(3,6)")
+assert _re_oneof_position.match("one-of(3,6,9)")
+
+_solo_location = r"[<>]?\d+"
+_solo_bond = r"bond\(%s\)" % _solo_location
+
+_re_location_category = re.compile(
+    r"^(?P<pair>%s)|(?P<between>%s)|(?P<within>%s)|(?P<oneof>%s)|(?P<bond>%s)|(?P<solo>%s)$"
+    % (
+        _pair_location,
+        _between_location,
+        _within_location,
+        _oneof_location,
+        _solo_bond,
+        _solo_location,
+    )
+)
+
+
+class LocationParserError(ValueError):
+    """Could not parse a feature location string."""
+
+
+class SeqFeature:
+    """Represent a Sequence Feature on an object.
+
+    Attributes:
+     - location - the location of the feature on the sequence (SimpleLocation)
+     - type - the specified type of the feature (ie. CDS, exon, repeat...)
+     - id - A string identifier for the feature.
+     - qualifiers - A dictionary of qualifiers on the feature. These are
+       analogous to the qualifiers from a GenBank feature table. The keys of
+       the dictionary are qualifier names, the values are the qualifier
+       values.
+
+    """
+
+    def __init__(
+        self,
+        location=None,
+        type="",
+        id="<unknown id>",
+        qualifiers=None,
+        sub_features=None,
+    ):
+        """Initialize a SeqFeature on a sequence.
+
+        location can either be a SimpleLocation (with strand argument also
+        given if required), or None.
+
+        e.g. With no strand, on the forward strand, and on the reverse strand:
+
+        >>> from Bio.SeqFeature import SeqFeature, SimpleLocation
+        >>> f1 = SeqFeature(SimpleLocation(5, 10), type="domain")
+        >>> f1.location.strand == None
+        True
+        >>> f2 = SeqFeature(SimpleLocation(7, 110, strand=1), type="CDS")
+        >>> f2.location.strand == +1
+        True
+        >>> f3 = SeqFeature(SimpleLocation(9, 108, strand=-1), type="CDS")
+        >>> f3.location.strand == -1
+        True
+
+        For exact start/end positions, an integer can be used (as shown above)
+        as shorthand for the ExactPosition object. For non-exact locations, the
+        SimpleLocation must be specified via the appropriate position objects.
+        """
+        if (
+            location is not None
+            and not isinstance(location, SimpleLocation)
+            and not isinstance(location, CompoundLocation)
+        ):
+            raise TypeError(
+                "SimpleLocation, CompoundLocation (or None) required for the location"
+            )
+        self.location = location
+        self.type = type
+        self.id = id
+        self.qualifiers = {}
+        if qualifiers is not None:
+            self.qualifiers.update(qualifiers)
+        if sub_features is not None:
+            raise TypeError("Rather than sub_features, use a CompoundLocation")
+
+    def __eq__(self, other):
+        """Check if two SeqFeature objects should be considered equal."""
+        return (
+            isinstance(other, SeqFeature)
+            and self.id == other.id
+            and self.type == other.type
+            and self.location == other.location
+            and self.qualifiers == other.qualifiers
+        )
+
+    def __repr__(self):
+        """Represent the feature as a string for debugging."""
+        answer = f"{self.__class__.__name__}({self.location!r}"
+        if self.type:
+            answer += f", type={self.type!r}"
+        if self.id and self.id != "<unknown id>":
+            answer += f", id={self.id!r}"
+        if self.qualifiers:
+            answer += ", qualifiers=..."
+        answer += ")"
+        return answer
+
+    def __str__(self):
+        """Return the full feature as a python string."""
+        out = f"type: {self.type}\n"
+        out += f"location: {self.location}\n"
+        if self.id and self.id != "<unknown id>":
+            out += f"id: {self.id}\n"
+        out += "qualifiers:\n"
+        for qual_key in sorted(self.qualifiers):
+            out += f"    Key: {qual_key}, Value: {self.qualifiers[qual_key]}\n"
+        return out
+
+    def _shift(self, offset):
+        """Return a copy of the feature with its location shifted (PRIVATE).
+
+        The annotation qualifiers are copied.
+        """
+        return SeqFeature(
+            location=self.location._shift(offset),
+            type=self.type,
+            id=self.id,
+            qualifiers=self.qualifiers.copy(),
+        )
+
+    def _flip(self, length):
+        """Return a copy of the feature with its location flipped (PRIVATE).
+
+        The argument length gives the length of the parent sequence. For
+        example a location 0..20 (+1 strand) with parent length 30 becomes
+        after flipping 10..30 (-1 strand). Strandless (None) or unknown
+        strand (0) remain like that - just their end points are changed.
+
+        The annotation qualifiers are copied.
+        """
+        return SeqFeature(
+            location=self.location._flip(length),
+            type=self.type,
+            id=self.id,
+            qualifiers=self.qualifiers.copy(),
+        )
+
+    def extract(self, parent_sequence, references=None):
+        """Extract the feature's sequence from supplied parent sequence.
+
+        The parent_sequence can be a Seq like object or a string, and will
+        generally return an object of the same type. The exception to this is
+        a MutableSeq as the parent sequence will return a Seq object.
+
+        This should cope with complex locations including complements, joins
+        and fuzzy positions. Even mixed strand features should work! This
+        also covers features on protein sequences (e.g. domains), although
+        here reverse strand features are not permitted. If the
+        location refers to other records, they must be supplied in the
+        optional dictionary references.
+
+        >>> from Bio.Seq import Seq
+        >>> from Bio.SeqFeature import SeqFeature, SimpleLocation
+        >>> seq = Seq("MKQHKAMIVALIVICITAVVAAL")
+        >>> f = SeqFeature(SimpleLocation(8, 15), type="domain")
+        >>> f.extract(seq)
+        Seq('VALIVIC')
+
+        If the SimpleLocation is None, e.g. when parsing invalid locus
+        locations in the GenBank parser, extract() will raise a ValueError.
+
+        >>> from Bio.Seq import Seq
+        >>> from Bio.SeqFeature import SeqFeature
+        >>> seq = Seq("MKQHKAMIVALIVICITAVVAAL")
+        >>> f = SeqFeature(None, type="domain")
+        >>> f.extract(seq)
+        Traceback (most recent call last):
+           ...
+        ValueError: The feature's .location is None. Check the sequence file for a valid location.
+
+        Note - currently only compound features of type "join" are supported.
+        """
+        if self.location is None:
+            raise ValueError(
+                "The feature's .location is None. Check the "
+                "sequence file for a valid location."
+            )
+        return self.location.extract(parent_sequence, references=references)
+
+    def translate(
+        self,
+        parent_sequence,
+        table="Standard",
+        start_offset=None,
+        stop_symbol="*",
+        to_stop=False,
+        cds=None,
+        gap=None,
+    ):
+        """Get a translation of the feature's sequence.
+
+        This method is intended for CDS or other features that code proteins
+        and is a shortcut that will both extract the feature and
+        translate it, taking into account the codon_start and transl_table
+        qualifiers, if they are present. If they are not present the
+        value of the arguments "table" and "start_offset" are used.
+
+        The "cds" parameter is set to "True" if the feature is of type
+        "CDS" but can be overridden by giving an explicit argument.
+
+        The arguments stop_symbol, to_stop and gap have the same meaning
+        as Seq.translate, refer to that documentation for further information.
+
+        Arguments:
+         - parent_sequence - A DNA or RNA sequence.
+         - table - Which codon table to use if there is no transl_table
+           qualifier for this feature. This can be either a name
+           (string), an NCBI identifier (integer), or a CodonTable
+           object (useful for non-standard genetic codes).  This
+           defaults to the "Standard" table.
+         - start_offset - offset at which the first complete codon of a
+           coding feature can be found, relative to the first base of
+           that feature. Has a valid value of 0, 1 or 2. NOTE: this
+           uses python's 0-based numbering whereas the codon_start
+           qualifier in files from NCBI use 1-based numbering.
+           Will override a codon_start qualifier
+
+        >>> from Bio.Seq import Seq
+        >>> from Bio.SeqFeature import SeqFeature, SimpleLocation
+        >>> seq = Seq("GGTTACACTTACCGATAATGTCTCTGATGA")
+        >>> f = SeqFeature(SimpleLocation(0, 30), type="CDS")
+        >>> f.qualifiers['transl_table'] = [11]
+
+        Note that features of type CDS are subject to the usual
+        checks at translation. But you can override this behavior
+        by giving explicit arguments:
+
+        >>> f.translate(seq, cds=False)
+        Seq('GYTYR*CL**')
+
+        Now use the start_offset argument to change the frame. Note
+        this uses python 0-based numbering.
+
+        >>> f.translate(seq, start_offset=1, cds=False)
+        Seq('VTLTDNVSD')
+
+        Alternatively use the codon_start qualifier to do the same
+        thing. Note: this uses 1-based numbering, which is found
+        in files from NCBI.
+
+        >>> f.qualifiers['codon_start'] = [2]
+        >>> f.translate(seq, cds=False)
+        Seq('VTLTDNVSD')
+        """
+        # see if this feature should be translated in a different
+        # frame using the "codon_start" qualifier
+        if start_offset is None:
+            try:
+                start_offset = int(self.qualifiers["codon_start"][0]) - 1
+            except KeyError:
+                start_offset = 0
+
+        if start_offset not in [0, 1, 2]:
+            raise ValueError(
+                "The start_offset must be 0, 1, or 2. "
+                f"The supplied value is {start_offset}. "
+                "Check the value of either the codon_start qualifier "
+                "or the start_offset argument"
+            )
+
+        feat_seq = self.extract(parent_sequence)[start_offset:]
+        codon_table = self.qualifiers.get("transl_table", [table])[0]
+
+        if cds is None:
+            cds = self.type == "CDS"
+
+        return feat_seq.translate(
+            table=codon_table,
+            stop_symbol=stop_symbol,
+            to_stop=to_stop,
+            cds=cds,
+            gap=gap,
+        )
+
+    def __bool__(self):
+        """Boolean value of an instance of this class (True).
+
+        This behavior is for backwards compatibility, since until the
+        __len__ method was added, a SeqFeature always evaluated as True.
+
+        Note that in comparison, Seq objects, strings, lists, etc, will all
+        evaluate to False if they have length zero.
+
+        WARNING: The SeqFeature may in future evaluate to False when its
+        length is zero (in order to better match normal python behavior)!
+        """
+        return True
+
+    def __len__(self):
+        """Return the length of the region where the feature is located.
+
+        >>> from Bio.Seq import Seq
+        >>> from Bio.SeqFeature import SeqFeature, SimpleLocation
+        >>> seq = Seq("MKQHKAMIVALIVICITAVVAAL")
+        >>> f = SeqFeature(SimpleLocation(8, 15), type="domain")
+        >>> len(f)
+        7
+        >>> f.extract(seq)
+        Seq('VALIVIC')
+        >>> len(f.extract(seq))
+        7
+
+        This is a proxy for taking the length of the feature's location:
+
+        >>> len(f.location)
+        7
+
+        For simple features this is the same as the region spanned (end
+        position minus start position using Pythonic counting). However, for
+        a compound location (e.g. a CDS as the join of several exons) the
+        gaps are not counted (e.g. introns). This ensures that len(f) matches
+        len(f.extract(parent_seq)), and also makes sure things work properly
+        with features wrapping the origin etc.
+        """
+        return len(self.location)
+
+    def __iter__(self):
+        """Iterate over the parent positions within the feature.
+
+        The iteration order is strand aware, and can be thought of as moving
+        along the feature using the parent sequence coordinates:
+
+        >>> from Bio.SeqFeature import SeqFeature, SimpleLocation
+        >>> f = SeqFeature(SimpleLocation(5, 10, strand=-1), type="domain")
+        >>> len(f)
+        5
+        >>> for i in f: print(i)
+        9
+        8
+        7
+        6
+        5
+        >>> list(f)
+        [9, 8, 7, 6, 5]
+
+        This is a proxy for iterating over the location,
+
+        >>> list(f.location)
+        [9, 8, 7, 6, 5]
+        """
+        return iter(self.location)
+
+    def __contains__(self, value):
+        """Check if an integer position is within the feature.
+
+        >>> from Bio.SeqFeature import SeqFeature, SimpleLocation
+        >>> f = SeqFeature(SimpleLocation(5, 10, strand=-1), type="domain")
+        >>> len(f)
+        5
+        >>> [i for i in range(15) if i in f]
+        [5, 6, 7, 8, 9]
+
+        For example, to see which features include a SNP position, you could
+        use this:
+
+        >>> from Bio import SeqIO
+        >>> record = SeqIO.read("GenBank/NC_000932.gb", "gb")
+        >>> for f in record.features:
+        ...     if 1750 in f:
+        ...         print("%s %s" % (f.type, f.location))
+        source [0:154478](+)
+        gene [1716:4347](-)
+        tRNA join{[4310:4347](-), [1716:1751](-)}
+
+        Note that for a feature defined as a join of several subfeatures (e.g.
+        the union of several exons) the gaps are not checked (e.g. introns).
+        In this example, the tRNA location is defined in the GenBank file as
+        complement(join(1717..1751,4311..4347)), so that position 1760 falls
+        in the gap:
+
+        >>> for f in record.features:
+        ...     if 1760 in f:
+        ...         print("%s %s" % (f.type, f.location))
+        source [0:154478](+)
+        gene [1716:4347](-)
+
+        Note that additional care may be required with fuzzy locations, for
+        example just before a BeforePosition:
+
+        >>> from Bio.SeqFeature import SeqFeature, SimpleLocation
+        >>> from Bio.SeqFeature import BeforePosition
+        >>> f = SeqFeature(SimpleLocation(BeforePosition(3), 8), type="domain")
+        >>> len(f)
+        5
+        >>> [i for i in range(10) if i in f]
+        [3, 4, 5, 6, 7]
+
+        Note that is is a proxy for testing membership on the location.
+
+        >>> [i for i in range(10) if i in f.location]
+        [3, 4, 5, 6, 7]
+        """
+        return value in self.location
+
+
+# --- References
+
+
+# TODO -- Will this hold PubMed and Medline information decently?
+class Reference:
+    """Represent a Generic Reference object.
+
+    Attributes:
+     - location - A list of Location objects specifying regions of
+       the sequence that the references correspond to. If no locations are
+       specified, the entire sequence is assumed.
+     - authors - A big old string, or a list split by author, of authors
+       for the reference.
+     - title - The title of the reference.
+     - journal - Journal the reference was published in.
+     - medline_id - A medline reference for the article.
+     - pubmed_id - A pubmed reference for the article.
+     - comment - A place to stick any comments about the reference.
+
+    """
+
+    def __init__(self):
+        """Initialize the class."""
+        self.location = []
+        self.authors = ""
+        self.consrtm = ""
+        self.title = ""
+        self.journal = ""
+        self.medline_id = ""
+        self.pubmed_id = ""
+        self.comment = ""
+
+    def __str__(self):
+        """Return the full Reference object as a python string."""
+        out = ""
+        for single_location in self.location:
+            out += f"location: {single_location}\n"
+        out += f"authors: {self.authors}\n"
+        if self.consrtm:
+            out += f"consrtm: {self.consrtm}\n"
+        out += f"title: {self.title}\n"
+        out += f"journal: {self.journal}\n"
+        out += f"medline id: {self.medline_id}\n"
+        out += f"pubmed id: {self.pubmed_id}\n"
+        out += f"comment: {self.comment}\n"
+        return out
+
+    def __repr__(self):
+        """Represent the Reference object as a string for debugging."""
+        # TODO - Update this is __init__ later accepts values
+        return f"{self.__class__.__name__}(title={self.title!r}, ...)"
+
+    def __eq__(self, other):
+        """Check if two Reference objects should be considered equal.
+
+        Note prior to Biopython 1.70 the location was not compared, as
+        until then __eq__ for the SimpleLocation class was not defined.
+        """
+        return (
+            self.authors == other.authors
+            and self.consrtm == other.consrtm
+            and self.title == other.title
+            and self.journal == other.journal
+            and self.medline_id == other.medline_id
+            and self.pubmed_id == other.pubmed_id
+            and self.comment == other.comment
+            and self.location == other.location
+        )
+
+
+# --- Handling feature locations
+
+
+class Location(ABC):
+    """Abstract base class representing a location."""
+
+    @abstractmethod
+    def __repr__(self):
+        """Represent the Location object as a string for debugging."""
+        return f"{self.__class__.__name__}(...)"
+
+    @staticmethod
+    def fromstring(text, length=None, circular=False, stranded=True):
+        """Create a Location object from a string.
+
+        This should accept any valid location string in the INSDC Feature Table
+        format (https://www.insdc.org/submitting-standards/feature-table/) as
+        used in GenBank, DDBJ and EMBL files.
+
+        Simple examples:
+
+        >>> Location.fromstring("123..456", 1000)
+        SimpleLocation(ExactPosition(122), ExactPosition(456), strand=1)
+        >>> Location.fromstring("complement(<123..>456)", 1000)
+        SimpleLocation(BeforePosition(122), AfterPosition(456), strand=-1)
+
+        A more complex location using within positions,
+
+        >>> Location.fromstring("(9.10)..(20.25)", 1000)
+        SimpleLocation(WithinPosition(8, left=8, right=9), WithinPosition(25, left=20, right=25), strand=1)
+
+        Notice how that will act as though it has overall start 8 and end 25.
+
+        Zero length between feature,
+
+        >>> Location.fromstring("123^124", 1000)
+        SimpleLocation(ExactPosition(123), ExactPosition(123), strand=1)
+
+        The expected sequence length is needed for a special case, a between
+        position at the start/end of a circular genome:
+
+        >>> Location.fromstring("1000^1", 1000)
+        SimpleLocation(ExactPosition(1000), ExactPosition(1000), strand=1)
+
+        Apart from this special case, between positions P^Q must have P+1==Q,
+
+        >>> Location.fromstring("123^456", 1000)
+        Traceback (most recent call last):
+           ...
+        Bio.SeqFeature.LocationParserError: invalid feature location '123^456'
+
+        You can optionally provide a reference name:
+
+        >>> Location.fromstring("AL391218.9:105173..108462", 2000000)
+        SimpleLocation(ExactPosition(105172), ExactPosition(108462), strand=1, ref='AL391218.9')
+
+        >>> Location.fromstring("<2644..159", 2868, "circular")
+        CompoundLocation([SimpleLocation(BeforePosition(2643), ExactPosition(2868), strand=1), SimpleLocation(ExactPosition(0), ExactPosition(159), strand=1)], 'join')
+        """
+        if text.startswith("complement("):
+            if text[-1] != ")":
+                raise ValueError(f"closing bracket missing in '{text}'")
+            text = text[11:-1]
+            strand = -1
+        elif stranded:
+            strand = 1
+        else:
+            strand = None
+
+        # Determine if we have a simple location or a compound location
+        if text.startswith("join("):
+            operator = "join"
+            parts = _split(text[5:-1])[1::2]
+            # assert parts[0] == "" and parts[-1] == ""
+        elif text.startswith("order("):
+            operator = "order"
+            parts = _split(text[6:-1])[1::2]
+            # assert parts[0] == "" and parts[-1] == ""
+        elif text.startswith("bond("):
+            operator = "bond"
+            parts = _split(text[5:-1])[1::2]
+            # assert parts[0] == "" and parts[-1] == ""
+        else:
+            loc = SimpleLocation.fromstring(text, length, circular)
+            loc.strand = strand
+            if strand == -1:
+                loc.parts.reverse()
+            return loc
+        locs = []
+        for part in parts:
+            loc = SimpleLocation.fromstring(part, length, circular)
+            if loc is None:
+                break
+            if loc.strand == -1:
+                if strand == -1:
+                    raise LocationParserError("double complement in '{text}'?")
+            else:
+                loc.strand = strand
+            locs.extend(loc.parts)
+        else:
+            if len(locs) == 1:
+                return loc
+            # Historically a join on the reverse strand has been represented
+            # in Biopython with both the parent SeqFeature and its children
+            # (the exons for a CDS) all given a strand of -1.  Likewise, for
+            # a join feature on the forward strand they all have strand +1.
+            # However, we must also consider evil mixed strand examples like
+            # this, join(complement(69611..69724),139856..140087,140625..140650)
+            if strand == -1:
+                # Whole thing was wrapped in complement(...)
+                for loc in locs:
+                    assert loc.strand == -1
+                # Reverse the backwards order used in GenBank files
+                # with complement(join(...))
+                locs = locs[::-1]
+            return CompoundLocation(locs, operator=operator)
+        # Not recognized
+        if "order" in text and "join" in text:
+            # See Bug 3197
+            raise LocationParserError(
+                f"failed to parse feature location '{text}' containing a combination of 'join' and 'order' (nested operators) are illegal"
+            )
+
+        # See issue #937. Note that NCBI has already fixed this record.
+        if ",)" in text:
+            warnings.warn(
+                "Dropping trailing comma in malformed feature location",
+                BiopythonParserWarning,
+            )
+            text = text.replace(",)", ")")
+            return Location.fromstring(text)
+
+        raise LocationParserError(f"failed to parse feature location '{text}'")
+
+
+class SimpleLocation(Location):
+    """Specify the location of a feature along a sequence.
+
+    The SimpleLocation is used for simple continuous features, which can
+    be described as running from a start position to and end position
+    (optionally with a strand and reference information).  More complex
+    locations made up from several non-continuous parts (e.g. a coding
+    sequence made up of several exons) are described using a SeqFeature
+    with a CompoundLocation.
+
+    Note that the start and end location numbering follow Python's scheme,
+    thus a GenBank entry of 123..150 (one based counting) becomes a location
+    of [122:150] (zero based counting).
+
+    >>> from Bio.SeqFeature import SimpleLocation
+    >>> f = SimpleLocation(122, 150)
+    >>> print(f)
+    [122:150]
+    >>> print(f.start)
+    122
+    >>> print(f.end)
+    150
+    >>> print(f.strand)
+    None
+
+    Note the strand defaults to None. If you are working with nucleotide
+    sequences you'd want to be explicit if it is the forward strand:
+
+    >>> from Bio.SeqFeature import SimpleLocation
+    >>> f = SimpleLocation(122, 150, strand=+1)
+    >>> print(f)
+    [122:150](+)
+    >>> print(f.strand)
+    1
+
+    Note that for a parent sequence of length n, the SimpleLocation
+    start and end must satisfy the inequality 0 <= start <= end <= n.
+    This means even for features on the reverse strand of a nucleotide
+    sequence, we expect the 'start' coordinate to be less than the
+    'end'.
+
+    >>> from Bio.SeqFeature import SimpleLocation
+    >>> r = SimpleLocation(122, 150, strand=-1)
+    >>> print(r)
+    [122:150](-)
+    >>> print(r.start)
+    122
+    >>> print(r.end)
+    150
+    >>> print(r.strand)
+    -1
+
+    i.e. Rather than thinking of the 'start' and 'end' biologically in a
+    strand aware manner, think of them as the 'left most' or 'minimum'
+    boundary, and the 'right most' or 'maximum' boundary of the region
+    being described. This is particularly important with compound
+    locations describing non-continuous regions.
+
+    In the example above we have used standard exact positions, but there
+    are also specialised position objects used to represent fuzzy positions
+    as well, for example a GenBank location like complement(<123..150)
+    would use a BeforePosition object for the start.
+    """
+
+    def __init__(self, start, end, strand=None, ref=None, ref_db=None):
+        """Initialize the class.
+
+        start and end arguments specify the values where the feature begins
+        and ends. These can either by any of the ``*Position`` objects that
+        inherit from Position, or can just be integers specifying the position.
+        In the case of integers, the values are assumed to be exact and are
+        converted in ExactPosition arguments. This is meant to make it easy
+        to deal with non-fuzzy ends.
+
+        i.e. Short form:
+
+        >>> from Bio.SeqFeature import SimpleLocation
+        >>> loc = SimpleLocation(5, 10, strand=-1)
+        >>> print(loc)
+        [5:10](-)
+
+        Explicit form:
+
+        >>> from Bio.SeqFeature import SimpleLocation, ExactPosition
+        >>> loc = SimpleLocation(ExactPosition(5), ExactPosition(10), strand=-1)
+        >>> print(loc)
+        [5:10](-)
+
+        Other fuzzy positions are used similarly,
+
+        >>> from Bio.SeqFeature import SimpleLocation
+        >>> from Bio.SeqFeature import BeforePosition, AfterPosition
+        >>> loc2 = SimpleLocation(BeforePosition(5), AfterPosition(10), strand=-1)
+        >>> print(loc2)
+        [<5:>10](-)
+
+        For nucleotide features you will also want to specify the strand,
+        use 1 for the forward (plus) strand, -1 for the reverse (negative)
+        strand, 0 for stranded but strand unknown (? in GFF3), or None for
+        when the strand does not apply (dot in GFF3), e.g. features on
+        proteins.
+
+        >>> loc = SimpleLocation(5, 10, strand=+1)
+        >>> print(loc)
+        [5:10](+)
+        >>> print(loc.strand)
+        1
+
+        Normally feature locations are given relative to the parent
+        sequence you are working with, but an explicit accession can
+        be given with the optional ref and db_ref strings:
+
+        >>> loc = SimpleLocation(105172, 108462, ref="AL391218.9", strand=1)
+        >>> print(loc)
+        AL391218.9[105172:108462](+)
+        >>> print(loc.ref)
+        AL391218.9
+
+        """
+        # TODO - Check 0 <= start <= end (<= length of reference)
+        if isinstance(start, Position):
+            self._start = start
+        elif isinstance(start, int):
+            self._start = ExactPosition(start)
+        else:
+            raise TypeError(f"start={start!r} {type(start)}")
+        if isinstance(end, Position):
+            self._end = end
+        elif isinstance(end, int):
+            self._end = ExactPosition(end)
+        else:
+            raise TypeError(f"end={end!r} {type(end)}")
+        if (
+            isinstance(self.start, int)
+            and isinstance(self.end, int)
+            and self.start > self.end
+        ):
+            raise ValueError(
+                f"End location ({self.end}) must be greater than "
+                f"or equal to start location ({self.start})"
+            )
+        self.strand = strand
+        self.ref = ref
+        self.ref_db = ref_db
+
+    @staticmethod
+    def fromstring(text, length=None, circular=False):
+        """Create a SimpleLocation object from a string."""
+        if text.startswith("complement("):
+            text = text[11:-1]
+            strand = -1
+        else:
+            strand = None
+        # Try simple cases first for speed
+        try:
+            s, e = text.split("..")
+            s = int(s) - 1
+            e = int(e)
+        except ValueError:
+            pass
+        else:
+            if 0 <= s < e:
+                return SimpleLocation(s, e, strand)
+        # Try general case
+        try:
+            ref, text = text.split(":")
+        except ValueError:
+            ref = None
+        m = _re_location_category.match(text)
+        if m is None:
+            raise LocationParserError(f"Could not parse feature location '{text}'")
+        for key, value in m.groupdict().items():
+            if value is not None:
+                break
+        assert value == text
+        if key == "bond":
+            # e.g. bond(196)
+            warnings.warn(
+                "Dropping bond qualifier in feature location",
+                BiopythonParserWarning,
+            )
+            text = text[5:-1]
+            s_pos = Position.fromstring(text, -1)
+            e_pos = Position.fromstring(text)
+        elif key == "solo":
+            # e.g. "123"
+            s_pos = Position.fromstring(text, -1)
+            e_pos = Position.fromstring(text)
+        elif key in ("pair", "within", "oneof"):
+            s, e = text.split("..")
+            # Attempt to fix features that span the origin
+            s_pos = Position.fromstring(s, -1)
+            e_pos = Position.fromstring(e)
+            # We have seen Ensembl data in "GenBank Format" with length zero in the LOCUS
+            # and variation features with s_pos >= e_pos - they are not origin wrapping!
+            if e_pos <= s_pos and length and s_pos < length:
+                # Assuming this is meant to be origin wrapping.
+                # Create a CompoundLocation of the wrapped feature,
+                # consisting of two SimpleLocation objects to extend to
+                # the list of feature locations.
+                if not circular:
+                    raise LocationParserError(
+                        f"it appears that '{text}' is a feature that spans the"
+                        " origin, but the sequence topology is undefined"
+                    )
+                warnings.warn(
+                    f"Attempting to fix invalid location {text!r} as it looks"
+                    " like incorrect origin wrapping. Please fix input file,"
+                    " this could have unintended behavior.",
+                    BiopythonParserWarning,
+                )
+
+                f1 = SimpleLocation(s_pos, length, strand)
+                f2 = SimpleLocation(0, e_pos, strand)
+
+                if strand == -1:
+                    # For complementary features spanning the origin
+                    return f2 + f1
+                else:
+                    return f1 + f2
+        elif key == "between":
+            # A between location like "67^68" (one based counting) is a
+            # special case (note it has zero length). In python slice
+            # notation this is 67:67, a zero length slice.  See Bug 2622
+            # Further more, on a circular genome of length N you can have
+            # a location N^1 meaning the junction at the origin. See Bug 3098.
+            # NOTE - We can imagine between locations like "2^4", but this
+            # is just "3".  Similarly, "2^5" is just "3..4"
+            s, e = text.split("^")
+            s = int(s)
+            e = int(e)
+            if s + 1 == e or (s == length and e == 1):
+                s_pos = ExactPosition(s)
+                e_pos = s_pos
+            else:
+                raise LocationParserError(f"invalid feature location '{text}'")
+        if s_pos < 0:
+            raise LocationParserError(
+                f"negative starting position in feature location '{text}'"
+            )
+        return SimpleLocation(s_pos, e_pos, strand, ref=ref)
+
+    def _get_strand(self):
+        """Get function for the strand property (PRIVATE)."""
+        return self._strand
+
+    def _set_strand(self, value):
+        """Set function for the strand property (PRIVATE)."""
+        if value not in [+1, -1, 0, None]:
+            raise ValueError(f"Strand should be +1, -1, 0 or None, not {value!r}")
+        self._strand = value
+
+    strand = property(
+        fget=_get_strand,
+        fset=_set_strand,
+        doc="Strand of the location (+1, -1, 0 or None).",
+    )
+
+    def __str__(self):
+        """Return a representation of the SimpleLocation object (with python counting).
+
+        For the simple case this uses the python splicing syntax, [122:150]
+        (zero based counting) which GenBank would call 123..150 (one based
+        counting).
+        """
+        answer = f"[{self._start}:{self._end}]"
+        if self.ref and self.ref_db:
+            answer = f"{self.ref_db}:{self.ref}{answer}"
+        elif self.ref:
+            answer = self.ref + answer
+        # Is ref_db without ref meaningful?
+        if self.strand is None:
+            return answer
+        elif self.strand == +1:
+            return answer + "(+)"
+        elif self.strand == -1:
+            return answer + "(-)"
+        else:
+            # strand = 0, stranded but strand unknown, ? in GFF3
+            return answer + "(?)"
+
+    def __repr__(self):
+        """Represent the SimpleLocation object as a string for debugging."""
+        optional = ""
+        if self.strand is not None:
+            optional += f", strand={self.strand!r}"
+        if self.ref is not None:
+            optional += f", ref={self.ref!r}"
+        if self.ref_db is not None:
+            optional += f", ref_db={self.ref_db!r}"
+        return f"{self.__class__.__name__}({self.start!r}, {self.end!r}{optional})"
+
+    def __add__(self, other):
+        """Combine location with another SimpleLocation object, or shift it.
+
+        You can add two feature locations to make a join CompoundLocation:
+
+        >>> from Bio.SeqFeature import SimpleLocation
+        >>> f1 = SimpleLocation(5, 10)
+        >>> f2 = SimpleLocation(20, 30)
+        >>> combined = f1 + f2
+        >>> print(combined)
+        join{[5:10], [20:30]}
+
+        This is thus equivalent to:
+
+        >>> from Bio.SeqFeature import CompoundLocation
+        >>> join = CompoundLocation([f1, f2])
+        >>> print(join)
+        join{[5:10], [20:30]}
+
+        You can also use sum(...) in this way:
+
+        >>> join = sum([f1, f2])
+        >>> print(join)
+        join{[5:10], [20:30]}
+
+        Furthermore, you can combine a SimpleLocation with a CompoundLocation
+        in this way.
+
+        Separately, adding an integer will give a new SimpleLocation with
+        its start and end offset by that amount. For example:
+
+        >>> print(f1)
+        [5:10]
+        >>> print(f1 + 100)
+        [105:110]
+        >>> print(200 + f1)
+        [205:210]
+
+        This can be useful when editing annotation.
+        """
+        if isinstance(other, SimpleLocation):
+            return CompoundLocation([self, other])
+        elif isinstance(other, int):
+            return self._shift(other)
+        else:
+            # This will allow CompoundLocation's __radd__ to be called:
+            return NotImplemented
+
+    def __radd__(self, other):
+        """Return a SimpleLocation object by shifting the location by an integer amount."""
+        if isinstance(other, int):
+            return self._shift(other)
+        else:
+            return NotImplemented
+
+    def __sub__(self, other):
+        """Subtracting an integer will shift the start and end by that amount.
+
+        >>> from Bio.SeqFeature import SimpleLocation
+        >>> f1 = SimpleLocation(105, 150)
+        >>> print(f1)
+        [105:150]
+        >>> print(f1 - 100)
+        [5:50]
+
+        This can be useful when editing annotation. You can also add an integer
+        to a feature location (which shifts in the opposite direction).
+        """
+        if isinstance(other, int):
+            return self._shift(-other)
+        else:
+            return NotImplemented
+
+    def __nonzero__(self):
+        """Return True regardless of the length of the feature.
+
+        This behavior is for backwards compatibility, since until the
+        __len__ method was added, a SimpleLocation always evaluated as True.
+
+        Note that in comparison, Seq objects, strings, lists, etc, will all
+        evaluate to False if they have length zero.
+
+        WARNING: The SimpleLocation may in future evaluate to False when its
+        length is zero (in order to better match normal python behavior)!
+        """
+        return True
+
+    def __len__(self):
+        """Return the length of the region described by the SimpleLocation object.
+
+        Note that extra care may be needed for fuzzy locations, e.g.
+
+        >>> from Bio.SeqFeature import SimpleLocation
+        >>> from Bio.SeqFeature import BeforePosition, AfterPosition
+        >>> loc = SimpleLocation(BeforePosition(5), AfterPosition(10))
+        >>> len(loc)
+        5
+        """
+        return int(self._end) - int(self._start)
+
+    def __contains__(self, value):
+        """Check if an integer position is within the SimpleLocation object.
+
+        Note that extra care may be needed for fuzzy locations, e.g.
+
+        >>> from Bio.SeqFeature import SimpleLocation
+        >>> from Bio.SeqFeature import BeforePosition, AfterPosition
+        >>> loc = SimpleLocation(BeforePosition(5), AfterPosition(10))
+        >>> len(loc)
+        5
+        >>> [i for i in range(15) if i in loc]
+        [5, 6, 7, 8, 9]
+        """
+        if not isinstance(value, int):
+            raise ValueError(
+                "Currently we only support checking for integer "
+                "positions being within a SimpleLocation."
+            )
+        if value < self._start or value >= self._end:
+            return False
+        else:
+            return True
+
+    def __iter__(self):
+        """Iterate over the parent positions within the SimpleLocation object.
+
+        >>> from Bio.SeqFeature import SimpleLocation
+        >>> from Bio.SeqFeature import BeforePosition, AfterPosition
+        >>> loc = SimpleLocation(BeforePosition(5), AfterPosition(10))
+        >>> len(loc)
+        5
+        >>> for i in loc: print(i)
+        5
+        6
+        7
+        8
+        9
+        >>> list(loc)
+        [5, 6, 7, 8, 9]
+        >>> [i for i in range(15) if i in loc]
+        [5, 6, 7, 8, 9]
+
+        Note this is strand aware:
+
+        >>> loc = SimpleLocation(BeforePosition(5), AfterPosition(10), strand = -1)
+        >>> list(loc)
+        [9, 8, 7, 6, 5]
+        """
+        if self.strand == -1:
+            yield from range(self._end - 1, self._start - 1, -1)
+        else:
+            yield from range(self._start, self._end)
+
+    def __eq__(self, other):
+        """Implement equality by comparing all the location attributes."""
+        if not isinstance(other, SimpleLocation):
+            return False
+        return (
+            self._start == other.start
+            and self._end == other.end
+            and self._strand == other.strand
+            and self.ref == other.ref
+            and self.ref_db == other.ref_db
+        )
+
+    def _shift(self, offset):
+        """Return a copy of the SimpleLocation shifted by an offset (PRIVATE).
+
+        Returns self when location is relative to an external reference.
+        """
+        # TODO - What if offset is a fuzzy position?
+        if self.ref or self.ref_db:
+            return self
+        return SimpleLocation(
+            start=self._start + offset,
+            end=self._end + offset,
+            strand=self.strand,
+        )
+
+    def _flip(self, length):
+        """Return a copy of the location after the parent is reversed (PRIVATE).
+
+        Returns self when location is relative to an external reference.
+        """
+        if self.ref or self.ref_db:
+            return self
+        # Note this will flip the start and end too!
+        if self.strand == +1:
+            flip_strand = -1
+        elif self.strand == -1:
+            flip_strand = +1
+        else:
+            # 0 or None
+            flip_strand = self.strand
+        return SimpleLocation(
+            start=self._end._flip(length),
+            end=self._start._flip(length),
+            strand=flip_strand,
+        )
+
+    @property
+    def parts(self):
+        """Read only list of sections (always one, the SimpleLocation object).
+
+        This is a convenience property allowing you to write code handling
+        both SimpleLocation objects (with one part) and more complex
+        CompoundLocation objects (with multiple parts) interchangeably.
+        """
+        return [self]
+
+    @property
+    def start(self):
+        """Start location - left most (minimum) value, regardless of strand.
+
+        Read only, returns an integer like position object, possibly a fuzzy
+        position.
+        """
+        return self._start
+
+    @property
+    def end(self):
+        """End location - right most (maximum) value, regardless of strand.
+
+        Read only, returns an integer like position object, possibly a fuzzy
+        position.
+        """
+        return self._end
+
+    def extract(self, parent_sequence, references=None):
+        """Extract the sequence from supplied parent sequence using the SimpleLocation object.
+
+        The parent_sequence can be a Seq like object or a string, and will
+        generally return an object of the same type. The exception to this is
+        a MutableSeq as the parent sequence will return a Seq object.
+        If the location refers to other records, they must be supplied
+        in the optional dictionary references.
+
+        >>> from Bio.Seq import Seq
+        >>> from Bio.SeqFeature import SimpleLocation
+        >>> seq = Seq("MKQHKAMIVALIVICITAVVAAL")
+        >>> feature_loc = SimpleLocation(8, 15)
+        >>> feature_loc.extract(seq)
+        Seq('VALIVIC')
+
+        """
+        if self.ref or self.ref_db:
+            if not references:
+                raise ValueError(
+                    f"Feature references another sequence ({self.ref}),"
+                    " references mandatory"
+                )
+            elif self.ref not in references:
+                # KeyError?
+                raise ValueError(
+                    f"Feature references another sequence ({self.ref}),"
+                    " not found in references"
+                )
+            parent_sequence = references[self.ref]
+        f_seq = parent_sequence[int(self.start) : int(self.end)]
+        if isinstance(f_seq, MutableSeq):
+            f_seq = Seq(f_seq)
+        if self.strand == -1:
+            f_seq = reverse_complement(f_seq)
+        return f_seq
+
+
+FeatureLocation = SimpleLocation  # OBSOLETE; for backward compatibility only.
+
+
+class CompoundLocation(Location):
+    """For handling joins etc where a feature location has several parts."""
+
+    def __init__(self, parts, operator="join"):
+        """Initialize the class.
+
+        >>> from Bio.SeqFeature import SimpleLocation, CompoundLocation
+        >>> f1 = SimpleLocation(10, 40, strand=+1)
+        >>> f2 = SimpleLocation(50, 59, strand=+1)
+        >>> f = CompoundLocation([f1, f2])
+        >>> len(f) == len(f1) + len(f2) == 39 == len(list(f))
+        True
+        >>> print(f.operator)
+        join
+        >>> 5 in f
+        False
+        >>> 15 in f
+        True
+        >>> f.strand
+        1
+
+        Notice that the strand of the compound location is computed
+        automatically - in the case of mixed strands on the sub-locations
+        the overall strand is set to None.
+
+        >>> f = CompoundLocation([SimpleLocation(3, 6, strand=+1),
+        ...                       SimpleLocation(10, 13, strand=-1)])
+        >>> print(f.strand)
+        None
+        >>> len(f)
+        6
+        >>> list(f)
+        [3, 4, 5, 12, 11, 10]
+
+        The example above doing list(f) iterates over the coordinates within the
+        feature. This allows you to use max and min on the location, to find the
+        range covered:
+
+        >>> min(f)
+        3
+        >>> max(f)
+        12
+
+        More generally, you can use the compound location's start and end which
+        give the full span covered, 0 <= start <= end <= full sequence length.
+
+        >>> f.start == min(f)
+        True
+        >>> f.end == max(f) + 1
+        True
+
+        This is consistent with the behavior of the SimpleLocation for a single
+        region, where again the 'start' and 'end' do not necessarily give the
+        biological start and end, but rather the 'minimal' and 'maximal'
+        coordinate boundaries.
+
+        Note that adding locations provides a more intuitive method of
+        construction:
+
+        >>> f = SimpleLocation(3, 6, strand=+1) + SimpleLocation(10, 13, strand=-1)
+        >>> len(f)
+        6
+        >>> list(f)
+        [3, 4, 5, 12, 11, 10]
+        """
+        self.operator = operator
+        self.parts = list(parts)
+        for loc in self.parts:
+            if not isinstance(loc, SimpleLocation):
+                raise ValueError(
+                    "CompoundLocation should be given a list of "
+                    "SimpleLocation objects, not %s" % loc.__class__
+                )
+        if len(parts) < 2:
+            raise ValueError(
+                f"CompoundLocation should have at least 2 parts, not {parts!r}"
+            )
+
+    def __str__(self):
+        """Return a representation of the CompoundLocation object (with python counting)."""
+        return "%s{%s}" % (self.operator, ", ".join(str(loc) for loc in self.parts))
+
+    def __repr__(self):
+        """Represent the CompoundLocation object as string for debugging."""
+        return f"{self.__class__.__name__}({self.parts!r}, {self.operator!r})"
+
+    def _get_strand(self):
+        """Get function for the strand property (PRIVATE)."""
+        # Historically a join on the reverse strand has been represented
+        # in Biopython with both the parent SeqFeature and its children
+        # (the exons for a CDS) all given a strand of -1.  Likewise, for
+        # a join feature on the forward strand they all have strand +1.
+        # However, we must also consider evil mixed strand examples like
+        # this, join(complement(69611..69724),139856..140087,140625..140650)
+        if len({loc.strand for loc in self.parts}) == 1:
+            return self.parts[0].strand
+        else:
+            return None  # i.e. mixed strands
+
+    def _set_strand(self, value):
+        """Set function for the strand property (PRIVATE)."""
+        # Should this be allowed/encouraged?
+        for loc in self.parts:
+            loc.strand = value
+
+    strand = property(
+        fget=_get_strand,
+        fset=_set_strand,
+        doc="""Overall strand of the compound location.
+
+        If all the parts have the same strand, that is returned. Otherwise
+        for mixed strands, this returns None.
+
+        >>> from Bio.SeqFeature import SimpleLocation, CompoundLocation
+        >>> f1 = SimpleLocation(15, 17, strand=1)
+        >>> f2 = SimpleLocation(20, 30, strand=-1)
+        >>> f = f1 + f2
+        >>> f1.strand
+        1
+        >>> f2.strand
+        -1
+        >>> f.strand
+        >>> f.strand is None
+        True
+
+        If you set the strand of a CompoundLocation, this is applied to
+        all the parts - use with caution:
+
+        >>> f.strand = 1
+        >>> f1.strand
+        1
+        >>> f2.strand
+        1
+        >>> f.strand
+        1
+
+        """,
+    )
+
+    def __add__(self, other):
+        """Combine locations, or shift the location by an integer offset.
+
+        >>> from Bio.SeqFeature import SimpleLocation
+        >>> f1 = SimpleLocation(15, 17) + SimpleLocation(20, 30)
+        >>> print(f1)
+        join{[15:17], [20:30]}
+
+        You can add another SimpleLocation:
+
+        >>> print(f1 + SimpleLocation(40, 50))
+        join{[15:17], [20:30], [40:50]}
+        >>> print(SimpleLocation(5, 10) + f1)
+        join{[5:10], [15:17], [20:30]}
+
+        You can also add another CompoundLocation:
+
+        >>> f2 = SimpleLocation(40, 50) + SimpleLocation(60, 70)
+        >>> print(f2)
+        join{[40:50], [60:70]}
+        >>> print(f1 + f2)
+        join{[15:17], [20:30], [40:50], [60:70]}
+
+        Also, as with the SimpleLocation, adding an integer shifts the
+        location's coordinates by that offset:
+
+        >>> print(f1 + 100)
+        join{[115:117], [120:130]}
+        >>> print(200 + f1)
+        join{[215:217], [220:230]}
+        >>> print(f1 + (-5))
+        join{[10:12], [15:25]}
+        """
+        if isinstance(other, SimpleLocation):
+            return CompoundLocation(self.parts + [other], self.operator)
+        elif isinstance(other, CompoundLocation):
+            if self.operator != other.operator:
+                # Handle join+order -> order as a special case?
+                raise ValueError(
+                    f"Mixed operators {self.operator} and {other.operator}"
+                )
+            return CompoundLocation(self.parts + other.parts, self.operator)
+        elif isinstance(other, int):
+            return self._shift(other)
+        else:
+            raise NotImplementedError
+
+    def __radd__(self, other):
+        """Add a feature to the left."""
+        if isinstance(other, SimpleLocation):
+            return CompoundLocation([other] + self.parts, self.operator)
+        elif isinstance(other, int):
+            return self._shift(other)
+        else:
+            raise NotImplementedError
+
+    def __contains__(self, value):
+        """Check if an integer position is within the CompoundLocation object."""
+        for loc in self.parts:
+            if value in loc:
+                return True
+        return False
+
+    def __nonzero__(self):
+        """Return True regardless of the length of the feature.
+
+        This behavior is for backwards compatibility, since until the
+        __len__ method was added, a SimpleLocation always evaluated as True.
+
+        Note that in comparison, Seq objects, strings, lists, etc, will all
+        evaluate to False if they have length zero.
+
+        WARNING: The SimpleLocation may in future evaluate to False when its
+        length is zero (in order to better match normal python behavior)!
+        """
+        return True
+
+    def __len__(self):
+        """Return the length of the CompoundLocation object."""
+        return sum(len(loc) for loc in self.parts)
+
+    def __iter__(self):
+        """Iterate over the parent positions within the CompoundLocation object."""
+        for loc in self.parts:
+            yield from loc
+
+    def __eq__(self, other):
+        """Check if all parts of CompoundLocation are equal to all parts of other CompoundLocation."""
+        if not isinstance(other, CompoundLocation):
+            return False
+        if len(self.parts) != len(other.parts):
+            return False
+        if self.operator != other.operator:
+            return False
+        for self_part, other_part in zip(self.parts, other.parts):
+            if self_part != other_part:
+                return False
+        return True
+
+    def _shift(self, offset):
+        """Return a copy of the CompoundLocation shifted by an offset (PRIVATE)."""
+        return CompoundLocation(
+            [loc._shift(offset) for loc in self.parts], self.operator
+        )
+
+    def _flip(self, length):
+        """Return a copy of the locations after the parent is reversed (PRIVATE).
+
+        Note that the order of the parts is NOT reversed unless all parts
+        have strand=None, since the order has meaning for stranded features.
+        Consider a CDS on the forward strand with exons small, medium
+        and large (in length). Once we change the frame of reference
+        to the reverse complement strand, the start codon is still part of
+        the small exon, and the stop codon still part of the large exon -
+        so the part order remains the same!
+
+        Here is an artificial example, were the features map to the two upper
+        case regions and the lower case runs of n are not used:
+
+        >>> from Bio.Seq import Seq
+        >>> from Bio.SeqFeature import SimpleLocation
+        >>> dna = Seq("nnnnnAGCATCCTGCTGTACnnnnnnnnGAGAMTGCCATGCCCCTGGAGTGAnnnnn")
+        >>> small = SimpleLocation(5, 20, strand=1)
+        >>> large = SimpleLocation(28, 52, strand=1)
+        >>> location = small + large
+        >>> print(small)
+        [5:20](+)
+        >>> print(large)
+        [28:52](+)
+        >>> print(location)
+        join{[5:20](+), [28:52](+)}
+        >>> for part in location.parts:
+        ...     print(len(part))
+        ...
+        15
+        24
+
+        As you can see, this is a silly example where each "exon" is a word:
+
+        >>> print(small.extract(dna).translate())
+        SILLY
+        >>> print(large.extract(dna).translate())
+        EXAMPLE*
+        >>> print(location.extract(dna).translate())
+        SILLYEXAMPLE*
+        >>> for part in location.parts:
+        ...     print(part.extract(dna).translate())
+        ...
+        SILLY
+        EXAMPLE*
+
+        Now, let's look at this from the reverse strand frame of reference:
+
+        >>> flipped_dna = dna.reverse_complement()
+        >>> flipped_location = location._flip(len(dna))
+        >>> print(flipped_location.extract(flipped_dna).translate())
+        SILLYEXAMPLE*
+        >>> for part in flipped_location.parts:
+        ...     print(part.extract(flipped_dna).translate())
+        ...
+        SILLY
+        EXAMPLE*
+
+        The key point here is the first part of the CompoundFeature is still the
+        small exon, while the second part is still the large exon:
+
+        >>> for part in flipped_location.parts:
+        ...     print(len(part))
+        ...
+        15
+        24
+        >>> print(flipped_location)
+        join{[37:52](-), [5:29](-)}
+
+        Notice the parts are not reversed. However, there was a bug here in older
+        versions of Biopython which would have given join{[5:29](-), [37:52](-)}
+        and the translation would have wrongly been "EXAMPLE*SILLY" instead.
+
+        When all the parts have strand None, the order of the parts is reversed.
+        In principle this does not change the meaning of the location, but improves
+        the representation of feature locations spanning the origin in circular
+        molecules.
+
+        >>> loc = SimpleLocation(4, 6, None) + SimpleLocation(0, 1, None)
+        >>> print(loc)
+        join{[4:6], [0:1]}
+        >>> print(loc._flip(6))
+        join{[5:6], [0:2]}
+
+        join{[0:2], [5:6]} would not be properly represented in SnapGene, Benchling, etc.
+        """
+        if all(loc.strand is None for loc in self.parts):
+            return CompoundLocation(
+                [loc._flip(length) for loc in self.parts[::-1]], self.operator
+            )
+        else:
+            return CompoundLocation(
+                [loc._flip(length) for loc in self.parts], self.operator
+            )
+
+    @property
+    def start(self):
+        """Start location - left most (minimum) value, regardless of strand.
+
+        Read only, returns an integer like position object, possibly a fuzzy
+        position.
+
+        For the special case of a CompoundLocation wrapping the origin of a
+        circular genome, this will return zero.
+        """
+        return min(loc.start for loc in self.parts)
+
+    @property
+    def end(self):
+        """End location - right most (maximum) value, regardless of strand.
+
+        Read only, returns an integer like position object, possibly a fuzzy
+        position.
+
+        For the special case of a CompoundLocation wrapping the origin of
+        a circular genome this will match the genome length.
+        """
+        return max(loc.end for loc in self.parts)
+
+    @property
+    def ref(self):
+        """Not present in CompoundLocation, dummy method for API compatibility."""
+        return None
+
+    @property
+    def ref_db(self):
+        """Not present in CompoundLocation, dummy method for API compatibility."""
+        return None
+
+    def extract(self, parent_sequence, references=None):
+        """Extract the sequence from supplied parent sequence using the CompoundLocation object.
+
+        The parent_sequence can be a Seq like object or a string, and will
+        generally return an object of the same type. The exception to this is
+        a MutableSeq as the parent sequence will return a Seq object.
+        If the location refers to other records, they must be supplied
+        in the optional dictionary references.
+
+        >>> from Bio.Seq import Seq
+        >>> from Bio.SeqFeature import SimpleLocation, CompoundLocation
+        >>> seq = Seq("MKQHKAMIVALIVICITAVVAAL")
+        >>> fl1 = SimpleLocation(2, 8)
+        >>> fl2 = SimpleLocation(10, 15)
+        >>> fl3 = CompoundLocation([fl1,fl2])
+        >>> fl3.extract(seq)
+        Seq('QHKAMILIVIC')
+
+        """
+        # This copes with mixed strand features & all on reverse:
+        parts = [
+            loc.extract(parent_sequence, references=references) for loc in self.parts
+        ]
+        f_seq = functools.reduce(lambda x, y: x + y, parts)
+        return f_seq
+
+
+class Position(ABC):
+    """Abstract base class representing a position."""
+
+    @abstractmethod
+    def __repr__(self):
+        """Represent the Position object as a string for debugging."""
+        return f"{self.__class__.__name__}(...)"
+
+    @staticmethod
+    def fromstring(text, offset=0):
+        """Build a Position object from the text string.
+
+        For an end position, leave offset as zero (default):
+
+        >>> Position.fromstring("5")
+        ExactPosition(5)
+
+        For a start position, set offset to minus one (for Python counting):
+
+        >>> Position.fromstring("5", -1)
+        ExactPosition(4)
+
+        This also covers fuzzy positions:
+
+        >>> p = Position.fromstring("<5")
+        >>> p
+        BeforePosition(5)
+        >>> print(p)
+        <5
+        >>> int(p)
+        5
+
+        >>> Position.fromstring(">5")
+        AfterPosition(5)
+
+        By default assumes an end position, so note the integer behavior:
+
+        >>> p = Position.fromstring("one-of(5,8,11)")
+        >>> p
+        OneOfPosition(11, choices=[ExactPosition(5), ExactPosition(8), ExactPosition(11)])
+        >>> print(p)
+        one-of(5,8,11)
+        >>> int(p)
+        11
+
+        >>> Position.fromstring("(8.10)")
+        WithinPosition(10, left=8, right=10)
+
+        Fuzzy start positions:
+
+        >>> p = Position.fromstring("<5", -1)
+        >>> p
+        BeforePosition(4)
+        >>> print(p)
+        <4
+        >>> int(p)
+        4
+
+        Notice how the integer behavior changes too!
+
+        >>> p = Position.fromstring("one-of(5,8,11)", -1)
+        >>> p
+        OneOfPosition(4, choices=[ExactPosition(4), ExactPosition(7), ExactPosition(10)])
+        >>> print(p)
+        one-of(4,7,10)
+        >>> int(p)
+        4
+
+        """
+        if offset != 0 and offset != -1:
+            raise ValueError(
+                "To convert one-based indices to zero-based indices, offset must be either 0 (for end positions) or -1 (for start positions)."
+            )
+        if text == "?":
+            return UnknownPosition()
+        if text.startswith("?"):
+            return UncertainPosition(int(text[1:]) + offset)
+        if text.startswith("<"):
+            return BeforePosition(int(text[1:]) + offset)
+        if text.startswith(">"):
+            return AfterPosition(int(text[1:]) + offset)
+        m = _re_within_position.match(text)
+        if m is not None:
+            s, e = m.groups()
+            s = int(s) + offset
+            e = int(e) + offset
+            if offset == -1:
+                default = s
+            else:
+                default = e
+            return WithinPosition(default, left=s, right=e)
+        m = _re_oneof_position.match(text)
+        if m is not None:
+            positions = m.groups()[0]
+            parts = [ExactPosition(int(pos) + offset) for pos in positions.split(",")]
+            if offset == -1:
+                default = min(int(pos) for pos in parts)
+            else:
+                default = max(int(pos) for pos in parts)
+            return OneOfPosition(default, choices=parts)
+        return ExactPosition(int(text) + offset)
+
+
+class ExactPosition(int, Position):
+    """Specify the specific position of a boundary.
+
+    Arguments:
+     - position - The position of the boundary.
+     - extension - An optional argument which must be zero since we don't
+       have an extension. The argument is provided so that the same number
+       of arguments can be passed to all position types.
+
+    In this case, there is no fuzziness associated with the position.
+
+    >>> p = ExactPosition(5)
+    >>> p
+    ExactPosition(5)
+    >>> print(p)
+    5
+
+    >>> isinstance(p, Position)
+    True
+    >>> isinstance(p, int)
+    True
+
+    Integer comparisons and operations should work as expected:
+
+    >>> p == 5
+    True
+    >>> p < 6
+    True
+    >>> p <= 5
+    True
+    >>> p + 10
+    ExactPosition(15)
+
+    """
+
+    def __new__(cls, position, extension=0):
+        """Create an ExactPosition object."""
+        if extension != 0:
+            raise AttributeError(f"Non-zero extension {extension} for exact position.")
+        return int.__new__(cls, position)
+
+    # Must define this on Python 3.8 onwards because we redefine __repr__
+    def __str__(self):
+        """Return a representation of the ExactPosition object (with python counting)."""
+        return str(int(self))
+
+    def __repr__(self):
+        """Represent the ExactPosition object as a string for debugging."""
+        return "%s(%i)" % (self.__class__.__name__, int(self))
+
+    def __add__(self, offset):
+        """Return a copy of the position object with its location shifted (PRIVATE)."""
+        # By default preserve any subclass
+        return self.__class__(int(self) + offset)
+
+    def _flip(self, length):
+        """Return a copy of the location after the parent is reversed (PRIVATE)."""
+        # By default preserve any subclass
+        return self.__class__(length - int(self))
+
+
+class UncertainPosition(ExactPosition):
+    """Specify a specific position which is uncertain.
+
+    This is used in UniProt, e.g. ?222 for uncertain position 222, or in the
+    XML format explicitly marked as uncertain. Does not apply to GenBank/EMBL.
+    """
+
+
+class UnknownPosition(Position):
+    """Specify a specific position which is unknown (has no position).
+
+    This is used in UniProt, e.g. ? or in the XML as unknown.
+    """
+
+    def __repr__(self):
+        """Represent the UnknownPosition object as a string for debugging."""
+        return f"{self.__class__.__name__}()"
+
+    def __hash__(self):
+        """Return the hash value of the UnknownPosition object."""
+        return hash(None)
+
+    def __add__(self, offset):
+        """Return a copy of the position object with its location shifted (PRIVATE)."""
+        return self
+
+    def _flip(self, length):
+        """Return a copy of the location after the parent is reversed (PRIVATE)."""
+        return self
+
+
+class WithinPosition(int, Position):
+    """Specify the position of a boundary within some coordinates.
+
+    Arguments:
+    - position - The default integer position
+    - left - The start (left) position of the boundary
+    - right - The end (right) position of the boundary
+
+    This allows dealing with a location like ((11.14)..100). This
+    indicates that the start of the sequence is somewhere between 11
+    and 14. Since this is a start coordinate, it should act like
+    it is at position 11 (or in Python counting, 10).
+
+    >>> p = WithinPosition(10, 10, 13)
+    >>> p
+    WithinPosition(10, left=10, right=13)
+    >>> print(p)
+    (10.13)
+    >>> int(p)
+    10
+
+    Basic integer comparisons and operations should work as though
+    this were a plain integer:
+
+    >>> p == 10
+    True
+    >>> p in [9, 10, 11]
+    True
+    >>> p < 11
+    True
+    >>> p + 10
+    WithinPosition(20, left=20, right=23)
+
+    >>> isinstance(p, WithinPosition)
+    True
+    >>> isinstance(p, Position)
+    True
+    >>> isinstance(p, int)
+    True
+
+    Note this also applies for comparison to other position objects,
+    where again the integer behavior is used:
+
+    >>> p == 10
+    True
+    >>> p == ExactPosition(10)
+    True
+    >>> p == BeforePosition(10)
+    True
+    >>> p == AfterPosition(10)
+    True
+
+    If this were an end point, you would want the position to be 13
+    (the right/larger value, not the left/smaller value as above):
+
+    >>> p2 = WithinPosition(13, 10, 13)
+    >>> p2
+    WithinPosition(13, left=10, right=13)
+    >>> print(p2)
+    (10.13)
+    >>> int(p2)
+    13
+    >>> p2 == 13
+    True
+    >>> p2 == ExactPosition(13)
+    True
+
+    """
+
+    def __new__(cls, position, left, right):
+        """Create a WithinPosition object."""
+        if not (position == left or position == right):
+            raise RuntimeError(
+                "WithinPosition: %r should match left %r or "
+                "right %r" % (position, left, right)
+            )
+        obj = int.__new__(cls, position)
+        obj._left = left
+        obj._right = right
+        return obj
+
+    def __getnewargs__(self):
+        """Return the arguments accepted by __new__.
+
+        Necessary to allow pickling and unpickling of class instances.
+        """
+        return (int(self), self._left, self._right)
+
+    def __repr__(self):
+        """Represent the WithinPosition object as a string for debugging."""
+        return "%s(%i, left=%i, right=%i)" % (
+            self.__class__.__name__,
+            int(self),
+            self._left,
+            self._right,
+        )
+
+    def __str__(self):
+        """Return a representation of the WithinPosition object (with python counting)."""
+        return f"({self._left}.{self._right})"
+
+    def __add__(self, offset):
+        """Return a copy of the position object with its location shifted."""
+        return self.__class__(
+            int(self) + offset, self._left + offset, self._right + offset
+        )
+
+    def _flip(self, length):
+        """Return a copy of the location after the parent is reversed (PRIVATE)."""
+        return self.__class__(
+            length - int(self), length - self._right, length - self._left
+        )
+
+
+class BetweenPosition(int, Position):
+    """Specify the position of a boundary between two coordinates (OBSOLETE?).
+
+    Arguments:
+     - position - The default integer position
+     - left - The start (left) position of the boundary
+     - right - The end (right) position of the boundary
+
+    This allows dealing with a position like 123^456. This
+    indicates that the start of the sequence is somewhere between
+    123 and 456. It is up to the parser to set the position argument
+    to either boundary point (depending on if this is being used as
+    a start or end of the feature). For example as a feature end:
+
+    >>> p = BetweenPosition(456, 123, 456)
+    >>> p
+    BetweenPosition(456, left=123, right=456)
+    >>> print(p)
+    (123^456)
+    >>> int(p)
+    456
+
+    Integer equality and comparison use the given position,
+
+    >>> p == 456
+    True
+    >>> p in [455, 456, 457]
+    True
+    >>> p > 300
+    True
+
+    The old legacy properties of position and extension give the
+    starting/lower/left position as an integer, and the distance
+    to the ending/higher/right position as an integer. Note that
+    the position object will act like either the left or the right
+    end-point depending on how it was created:
+
+    >>> p2 = BetweenPosition(123, left=123, right=456)
+    >>> int(p) == int(p2)
+    False
+    >>> p == 456
+    True
+    >>> p2 == 123
+    True
+
+    Note this potentially surprising behavior:
+
+    >>> BetweenPosition(123, left=123, right=456) == ExactPosition(123)
+    True
+    >>> BetweenPosition(123, left=123, right=456) == BeforePosition(123)
+    True
+    >>> BetweenPosition(123, left=123, right=456) == AfterPosition(123)
+    True
+
+    i.e. For equality (and sorting) the position objects behave like
+    integers.
+
+    """
+
+    def __new__(cls, position, left, right):
+        """Create a new instance in BetweenPosition object."""
+        assert position == left or position == right
+        # TODO - public API for getting left/right, especially the unknown one
+        obj = int.__new__(cls, position)
+        obj._left = left
+        obj._right = right
+        return obj
+
+    def __getnewargs__(self):
+        """Return the arguments accepted by __new__.
+
+        Necessary to allow pickling and unpickling of class instances.
+        """
+        return (int(self), self._left, self._right)
+
+    def __repr__(self):
+        """Represent the BetweenPosition object as a string for debugging."""
+        return "%s(%i, left=%i, right=%i)" % (
+            self.__class__.__name__,
+            int(self),
+            self._left,
+            self._right,
+        )
+
+    def __str__(self):
+        """Return a representation of the BetweenPosition object (with python counting)."""
+        return f"({self._left}^{self._right})"
+
+    def __add__(self, offset):
+        """Return a copy of the position object with its location shifted (PRIVATE)."""
+        return self.__class__(
+            int(self) + offset, self._left + offset, self._right + offset
+        )
+
+    def _flip(self, length):
+        """Return a copy of the location after the parent is reversed (PRIVATE)."""
+        return self.__class__(
+            length - int(self), length - self._right, length - self._left
+        )
+
+
+class BeforePosition(int, Position):
+    """Specify a position where the actual location occurs before it.
+
+    Arguments:
+     - position - The upper boundary of where the location can occur.
+     - extension - An optional argument which must be zero since we don't
+       have an extension. The argument is provided so that the same number
+       of arguments can be passed to all position types.
+
+    This is used to specify positions like (<10..100) where the location
+    occurs somewhere before position 10.
+
+    >>> p = BeforePosition(5)
+    >>> p
+    BeforePosition(5)
+    >>> print(p)
+    <5
+    >>> int(p)
+    5
+    >>> p + 10
+    BeforePosition(15)
+
+    Note this potentially surprising behavior:
+
+    >>> p == ExactPosition(5)
+    True
+    >>> p == AfterPosition(5)
+    True
+
+    Just remember that for equality and sorting the position objects act
+    like integers.
+    """
+
+    # Subclasses int so can't use __init__
+    def __new__(cls, position, extension=0):
+        """Create a new instance in BeforePosition object."""
+        if extension != 0:
+            raise AttributeError(f"Non-zero extension {extension} for exact position.")
+        return int.__new__(cls, position)
+
+    def __repr__(self):
+        """Represent the location as a string for debugging."""
+        return "%s(%i)" % (self.__class__.__name__, int(self))
+
+    def __str__(self):
+        """Return a representation of the BeforePosition object (with python counting)."""
+        return f"<{int(self)}"
+
+    def __add__(self, offset):
+        """Return a copy of the position object with its location shifted (PRIVATE)."""
+        return self.__class__(int(self) + offset)
+
+    def _flip(self, length):
+        """Return a copy of the location after the parent is reversed (PRIVATE)."""
+        return AfterPosition(length - int(self))
+
+
+class AfterPosition(int, Position):
+    """Specify a position where the actual location is found after it.
+
+    Arguments:
+     - position - The lower boundary of where the location can occur.
+     - extension - An optional argument which must be zero since we don't
+       have an extension. The argument is provided so that the same number
+       of arguments can be passed to all position types.
+
+    This is used to specify positions like (>10..100) where the location
+    occurs somewhere after position 10.
+
+    >>> p = AfterPosition(7)
+    >>> p
+    AfterPosition(7)
+    >>> print(p)
+    >7
+    >>> int(p)
+    7
+    >>> p + 10
+    AfterPosition(17)
+
+    >>> isinstance(p, AfterPosition)
+    True
+    >>> isinstance(p, Position)
+    True
+    >>> isinstance(p, int)
+    True
+
+    Note this potentially surprising behavior:
+
+    >>> p == ExactPosition(7)
+    True
+    >>> p == BeforePosition(7)
+    True
+
+    Just remember that for equality and sorting the position objects act
+    like integers.
+    """
+
+    # Subclasses int so can't use __init__
+    def __new__(cls, position, extension=0):
+        """Create a new instance of the AfterPosition object."""
+        if extension != 0:
+            raise AttributeError(f"Non-zero extension {extension} for exact position.")
+        return int.__new__(cls, position)
+
+    def __repr__(self):
+        """Represent the location as a string for debugging."""
+        return "%s(%i)" % (self.__class__.__name__, int(self))
+
+    def __str__(self):
+        """Return a representation of the AfterPosition object (with python counting)."""
+        return f">{int(self)}"
+
+    def __add__(self, offset):
+        """Return a copy of the position object with its location shifted (PRIVATE)."""
+        return self.__class__(int(self) + offset)
+
+    def _flip(self, length):
+        """Return a copy of the location after the parent is reversed (PRIVATE)."""
+        return BeforePosition(length - int(self))
+
+
+class OneOfPosition(int, Position):
+    """Specify a position where the location can be multiple positions.
+
+    This models the GenBank 'one-of(1888,1901)' function, and tries
+    to make this fit within the Biopython Position models. If this was
+    a start position it should act like 1888, but as an end position 1901.
+
+    >>> p = OneOfPosition(1888, [ExactPosition(1888), ExactPosition(1901)])
+    >>> p
+    OneOfPosition(1888, choices=[ExactPosition(1888), ExactPosition(1901)])
+    >>> int(p)
+    1888
+
+    Integer comparisons and operators act like using int(p),
+
+    >>> p == 1888
+    True
+    >>> p <= 1888
+    True
+    >>> p > 1888
+    False
+    >>> p + 100
+    OneOfPosition(1988, choices=[ExactPosition(1988), ExactPosition(2001)])
+
+    >>> isinstance(p, OneOfPosition)
+    True
+    >>> isinstance(p, Position)
+    True
+    >>> isinstance(p, int)
+    True
+
+    """
+
+    def __new__(cls, position, choices):
+        """Initialize with a set of possible positions.
+
+        choices is a list of Position derived objects, specifying possible
+        locations.
+
+        position is an integer specifying the default behavior.
+        """
+        if position not in choices:
+            raise ValueError(
+                f"OneOfPosition: {position!r} should match one of {choices!r}"
+            )
+        obj = int.__new__(cls, position)
+        obj.position_choices = choices
+        return obj
+
+    def __getnewargs__(self):
+        """Return the arguments accepted by __new__.
+
+        Necessary to allow pickling and unpickling of class instances.
+        """
+        return (int(self), self.position_choices)
+
+    def __repr__(self):
+        """Represent the OneOfPosition object as a string for debugging."""
+        return "%s(%i, choices=%r)" % (
+            self.__class__.__name__,
+            int(self),
+            self.position_choices,
+        )
+
+    def __str__(self):
+        """Return a representation of the OneOfPosition object (with python counting)."""
+        out = "one-of("
+        for position in self.position_choices:
+            out += f"{position},"
+        # replace the last comma with the closing parenthesis
+        return out[:-1] + ")"
+
+    def __add__(self, offset):
+        """Return a copy of the position object with its location shifted (PRIVATE)."""
+        return self.__class__(
+            int(self) + offset, [p + offset for p in self.position_choices]
+        )
+
+    def _flip(self, length):
+        """Return a copy of the location after the parent is reversed (PRIVATE)."""
+        return self.__class__(
+            length - int(self), [p._flip(length) for p in self.position_choices[::-1]]
+        )
+
+
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()