Add files using upload-large-folder tool

.venv_haddock/lib/python3.12/site-packages/BioSQL/BioSeq.py

@@ -0,0 +1,592 @@
+# Copyright 2002 by Andrew Dalke.  All rights reserved.
+# Revisions 2007-2016 copyright by Peter Cock.  All rights reserved.
+# Revisions 2008-2009 copyright by Cymon J. Cox.  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.
+#
+# Note that BioSQL (including the database schema and scripts) is
+# available and licensed separately.  Please consult www.biosql.org
+"""Implementations of Biopython-like Seq objects on top of BioSQL.
+
+This allows retrieval of items stored in a BioSQL database using
+a biopython-like SeqRecord and Seq interface.
+
+Note: Currently we do not support recording per-letter-annotations
+(like quality scores) in BioSQL.
+"""
+
+from Bio import SeqFeature
+from Bio.Seq import Seq
+from Bio.Seq import SequenceDataAbstractBaseClass
+from Bio.SeqRecord import _RestrictedDict
+from Bio.SeqRecord import SeqRecord
+
+
+class _BioSQLSequenceData(SequenceDataAbstractBaseClass):
+    """Retrieves sequence data from a BioSQL database (PRIVATE)."""
+
+    __slots__ = ("primary_id", "adaptor", "_length", "start")
+
+    def __init__(self, primary_id, adaptor, start=0, length=0):
+        """Create a new _BioSQLSequenceData object referring to a BioSQL entry.
+
+        You wouldn't normally create a _BioSQLSequenceData object yourself,
+        this is done for you when retrieving a DBSeqRecord object from the
+        database, which creates a Seq object using a _BioSQLSequenceData
+        instance as the data provider.
+        """
+        self.primary_id = primary_id
+        self.adaptor = adaptor
+        self._length = length
+        self.start = start
+        super().__init__()
+
+    def __len__(self):
+        """Return the length of the sequence."""
+        return self._length
+
+    def __getitem__(self, key):
+        """Return a subsequence as a bytes or a _BioSQLSequenceData object."""
+        if isinstance(key, slice):
+            start, end, step = key.indices(self._length)
+            size = len(range(start, end, step))
+            if size == 0:
+                return b""
+        else:
+            # Return a single letter as an integer (consistent with bytes)
+            i = key
+            if i < 0:
+                i += self._length
+                if i < 0:
+                    raise IndexError(key)
+            elif i >= self._length:
+                raise IndexError(key)
+            c = self.adaptor.get_subseq_as_string(
+                self.primary_id, self.start + i, self.start + i + 1
+            )
+            return ord(c)
+
+        if step == 1:
+            if start == 0 and size == self._length:
+                # Return the full sequence as bytes
+                sequence = self.adaptor.get_subseq_as_string(
+                    self.primary_id, self.start, self.start + self._length
+                )
+                return sequence.encode("ASCII")
+            else:
+                # Return a _BioSQLSequenceData with the start and end adjusted
+                return _BioSQLSequenceData(
+                    self.primary_id, self.adaptor, self.start + start, size
+                )
+        else:
+            # Will have to extract the sequence because of the stride
+            full = self.adaptor.get_subseq_as_string(
+                self.primary_id, self.start + start, self.start + end
+            )
+            return full[::step].encode("ASCII")
+
+
+def _retrieve_seq_len(adaptor, primary_id):
+    # The database schema ensures there will be only one matching row
+    seqs = adaptor.execute_and_fetchall(
+        "SELECT length FROM biosequence WHERE bioentry_id = %s", (primary_id,)
+    )
+    if not seqs:
+        return None
+    if len(seqs) != 1:
+        raise ValueError(f"Expected 1 response, got {len(seqs)}.")
+    (given_length,) = seqs[0]
+    return int(given_length)
+
+
+def _retrieve_seq(adaptor, primary_id):
+    # The database schema ensures there will be only one matching
+    # row in the table.
+
+    # If an undefined sequence was recorded, seq will be NULL,
+    # but length will be populated.  This means length(seq)
+    # will return None.
+    seqs = adaptor.execute_and_fetchall(
+        "SELECT alphabet, length, length(seq) FROM biosequence WHERE bioentry_id = %s",
+        (primary_id,),
+    )
+    if not seqs:
+        return
+    if len(seqs) != 1:
+        raise ValueError(f"Expected 1 response, got {len(seqs)}.")
+    moltype, given_length, length = seqs[0]
+
+    try:
+        length = int(length)
+        given_length = int(given_length)
+        if length != given_length:
+            raise ValueError(
+                f"'length' differs from sequence length, {given_length}, {length}"
+            )
+        have_seq = True
+    except TypeError:
+        if length is not None:
+            raise ValueError(f"Expected 'length' to be 'None', got {length}.")
+        seqs = adaptor.execute_and_fetchall(
+            "SELECT alphabet, length, seq FROM biosequence WHERE bioentry_id = %s",
+            (primary_id,),
+        )
+        if len(seqs) != 1:
+            raise ValueError(f"Expected 1 response, got {len(seqs)}.")
+        moltype, given_length, seq = seqs[0]
+        if seq:
+            raise ValueError(f"Expected 'seq' to have a falsy value, got {seq}.")
+        length = int(given_length)
+        have_seq = False
+        del seq
+    del given_length
+
+    if have_seq:
+        data = _BioSQLSequenceData(primary_id, adaptor, start=0, length=length)
+        return Seq(data)
+    else:
+        return Seq(None, length=length)
+
+
+def _retrieve_dbxrefs(adaptor, primary_id):
+    """Retrieve the database cross references for the sequence (PRIVATE)."""
+    _dbxrefs = []
+    dbxrefs = adaptor.execute_and_fetchall(
+        "SELECT dbname, accession, version"
+        " FROM bioentry_dbxref join dbxref using (dbxref_id)"
+        " WHERE bioentry_id = %s"
+        ' ORDER BY "rank"',
+        (primary_id,),
+    )
+    for dbname, accession, version in dbxrefs:
+        if version and version != "0":
+            v = f"{accession}.{version}"
+        else:
+            v = accession
+        _dbxrefs.append(f"{dbname}:{v}")
+    return _dbxrefs
+
+
+def _retrieve_features(adaptor, primary_id):
+    sql = (
+        'SELECT seqfeature_id, type.name, "rank"'
+        " FROM seqfeature join term type on (type_term_id = type.term_id)"
+        " WHERE bioentry_id = %s"
+        ' ORDER BY "rank"'
+    )
+    results = adaptor.execute_and_fetchall(sql, (primary_id,))
+    seq_feature_list = []
+    for seqfeature_id, seqfeature_type, seqfeature_rank in results:
+        # Get qualifiers [except for db_xref which is stored separately]
+        qvs = adaptor.execute_and_fetchall(
+            "SELECT name, value"
+            " FROM seqfeature_qualifier_value  join term using (term_id)"
+            " WHERE seqfeature_id = %s"
+            ' ORDER BY "rank"',
+            (seqfeature_id,),
+        )
+        qualifiers = {}
+        for qv_name, qv_value in qvs:
+            qualifiers.setdefault(qv_name, []).append(qv_value)
+        # Get db_xrefs [special case of qualifiers]
+        qvs = adaptor.execute_and_fetchall(
+            "SELECT dbxref.dbname, dbxref.accession"
+            " FROM dbxref join seqfeature_dbxref using (dbxref_id)"
+            " WHERE seqfeature_dbxref.seqfeature_id = %s"
+            ' ORDER BY "rank"',
+            (seqfeature_id,),
+        )
+        for qv_name, qv_value in qvs:
+            value = f"{qv_name}:{qv_value}"
+            qualifiers.setdefault("db_xref", []).append(value)
+        # Get locations
+        results = adaptor.execute_and_fetchall(
+            "SELECT location_id, start_pos, end_pos, strand"
+            " FROM location"
+            " WHERE seqfeature_id = %s"
+            ' ORDER BY "rank"',
+            (seqfeature_id,),
+        )
+        locations = []
+        # convert to Python standard form
+        # Convert strand = 0 to strand = None
+        # re: comment in Loader.py:
+        # Biopython uses None when we don't know strand information but
+        # BioSQL requires something (non null) and sets this as zero
+        # So we'll use the strand or 0 if Biopython spits out None
+        for location_id, start, end, strand in results:
+            if start:
+                start -= 1
+            if strand == 0:
+                strand = None
+            if strand not in (+1, -1, None):
+                raise ValueError(
+                    "Invalid strand %s found in database for "
+                    "seqfeature_id %s" % (strand, seqfeature_id)
+                )
+            if start is not None and end is not None and end < start:
+                import warnings
+
+                from Bio import BiopythonWarning
+
+                warnings.warn(
+                    "Inverted location start/end (%i and %i) for "
+                    "seqfeature_id %s" % (start, end, seqfeature_id),
+                    BiopythonWarning,
+                )
+
+            # For SwissProt unknown positions (?)
+            if start is None:
+                start = SeqFeature.UnknownPosition()
+            if end is None:
+                end = SeqFeature.UnknownPosition()
+
+            locations.append((location_id, start, end, strand))
+        # Get possible remote reference information
+        remote_results = adaptor.execute_and_fetchall(
+            "SELECT location_id, dbname, accession, version"
+            " FROM location join dbxref using (dbxref_id)"
+            " WHERE seqfeature_id = %s",
+            (seqfeature_id,),
+        )
+        lookup = {}
+        for location_id, dbname, accession, version in remote_results:
+            if version and version != "0":
+                v = f"{accession}.{version}"
+            else:
+                v = accession
+            # subfeature remote location db_ref are stored as a empty string
+            # when not present
+            if dbname == "":
+                dbname = None
+            lookup[location_id] = (dbname, v)
+
+        feature = SeqFeature.SeqFeature(type=seqfeature_type)
+        # Store the key as a private property
+        feature._seqfeature_id = seqfeature_id
+        feature.qualifiers = qualifiers
+        if len(locations) == 0:
+            pass
+        elif len(locations) == 1:
+            location_id, start, end, strand = locations[0]
+            # See Bug 2677, we currently don't record the location_operator
+            # For consistency with older versions Biopython, default to "".
+            feature.location_operator = _retrieve_location_qualifier_value(
+                adaptor, location_id
+            )
+            dbname, version = lookup.get(location_id, (None, None))
+            feature.location = SeqFeature.SimpleLocation(start, end)
+            feature.location.strand = strand
+            feature.location.ref_db = dbname
+            feature.location.ref = version
+        else:
+            locs = []
+            for location in locations:
+                location_id, start, end, strand = location
+                dbname, version = lookup.get(location_id, (None, None))
+                locs.append(
+                    SeqFeature.SimpleLocation(
+                        start, end, strand=strand, ref=version, ref_db=dbname
+                    )
+                )
+            # Locations are typically in biological in order (see negative
+            # strands below), but because of remote locations for
+            # sub-features they are not necessarily in numerical order:
+            strands = {_.strand for _ in locs}
+            if len(strands) == 1 and -1 in strands:
+                # Evil hack time for backwards compatibility
+                # TODO - Check if BioPerl and (old) Biopython did the same,
+                # we may have an existing incompatibility lurking here...
+                locs = locs[::-1]
+            feature.location = SeqFeature.CompoundLocation(locs, "join")
+            # TODO - See Bug 2677 - we don't yet record location operator,
+            # so for consistency with older versions of Biopython default
+            # to assuming its a join.
+        seq_feature_list.append(feature)
+    return seq_feature_list
+
+
+def _retrieve_location_qualifier_value(adaptor, location_id):
+    value = adaptor.execute_and_fetch_col0(
+        "SELECT value FROM location_qualifier_value WHERE location_id = %s",
+        (location_id,),
+    )
+    try:
+        return value[0]
+    except IndexError:
+        return ""
+
+
+def _retrieve_annotations(adaptor, primary_id, taxon_id):
+    annotations = {}
+    annotations.update(_retrieve_alphabet(adaptor, primary_id))
+    annotations.update(_retrieve_qualifier_value(adaptor, primary_id))
+    annotations.update(_retrieve_reference(adaptor, primary_id))
+    annotations.update(_retrieve_taxon(adaptor, primary_id, taxon_id))
+    annotations.update(_retrieve_comment(adaptor, primary_id))
+    return annotations
+
+
+def _retrieve_alphabet(adaptor, primary_id):
+    results = adaptor.execute_and_fetchall(
+        "SELECT alphabet FROM biosequence WHERE bioentry_id = %s", (primary_id,)
+    )
+    if len(results) != 1:
+        raise ValueError(f"Expected 1 response, got {len(results)}.")
+    alphabets = results[0]
+    if len(alphabets) != 1:
+        raise ValueError(f"Expected 1 alphabet in response, got {len(alphabets)}.")
+    alphabet = alphabets[0]
+    if alphabet == "dna":
+        molecule_type = "DNA"
+    elif alphabet == "rna":
+        molecule_type = "RNA"
+    elif alphabet == "protein":
+        molecule_type = "protein"
+    else:
+        molecule_type = None
+    if molecule_type is not None:
+        return {"molecule_type": molecule_type}
+    else:
+        return {}
+
+
+def _retrieve_qualifier_value(adaptor, primary_id):
+    qvs = adaptor.execute_and_fetchall(
+        "SELECT name, value"
+        " FROM bioentry_qualifier_value JOIN term USING (term_id)"
+        " WHERE bioentry_id = %s"
+        ' ORDER BY "rank"',
+        (primary_id,),
+    )
+    qualifiers = {}
+    for name, value in qvs:
+        if name == "keyword":
+            name = "keywords"
+        # See handling of "date" in Loader.py
+        elif name == "date_changed":
+            name = "date"
+        elif name == "secondary_accession":
+            name = "accessions"
+        qualifiers.setdefault(name, []).append(value)
+    return qualifiers
+
+
+def _retrieve_reference(adaptor, primary_id):
+    # XXX dbxref_qualifier_value
+
+    refs = adaptor.execute_and_fetchall(
+        "SELECT start_pos, end_pos, "
+        " location, title, authors,"
+        " dbname, accession"
+        " FROM bioentry_reference"
+        " JOIN reference USING (reference_id)"
+        " LEFT JOIN dbxref USING (dbxref_id)"
+        " WHERE bioentry_id = %s"
+        ' ORDER BY "rank"',
+        (primary_id,),
+    )
+    references = []
+    for start, end, location, title, authors, dbname, accession in refs:
+        reference = SeqFeature.Reference()
+        # If the start/end are missing, reference.location is an empty list
+        if (start is not None) or (end is not None):
+            if start is not None:
+                start -= 1  # python counting
+            reference.location = [SeqFeature.SimpleLocation(start, end)]
+        # Don't replace the default "" with None.
+        if authors:
+            reference.authors = authors
+        if title:
+            reference.title = title
+        reference.journal = location
+        if dbname == "PUBMED":
+            reference.pubmed_id = accession
+        elif dbname == "MEDLINE":
+            reference.medline_id = accession
+        references.append(reference)
+    if references:
+        return {"references": references}
+    else:
+        return {}
+
+
+def _retrieve_taxon(adaptor, primary_id, taxon_id):
+    a = {}
+    common_names = adaptor.execute_and_fetch_col0(
+        "SELECT name FROM taxon_name WHERE taxon_id = %s"
+        " AND name_class = 'genbank common name'",
+        (taxon_id,),
+    )
+    if common_names:
+        a["source"] = common_names[0]
+    scientific_names = adaptor.execute_and_fetch_col0(
+        "SELECT name FROM taxon_name WHERE taxon_id = %s"
+        " AND name_class = 'scientific name'",
+        (taxon_id,),
+    )
+    if scientific_names:
+        a["organism"] = scientific_names[0]
+    ncbi_taxids = adaptor.execute_and_fetch_col0(
+        "SELECT ncbi_taxon_id FROM taxon WHERE taxon_id = %s", (taxon_id,)
+    )
+    if ncbi_taxids and ncbi_taxids[0] and ncbi_taxids[0] != "0":
+        a["ncbi_taxid"] = ncbi_taxids[0]
+
+    # Old code used the left/right values in the taxon table to get the
+    # taxonomy lineage in one SQL command.  This was actually very slow,
+    # and would fail if the (optional) left/right values were missing.
+    #
+    # The following code is based on a contribution from Eric Gibert, and
+    # relies on the taxon table's parent_taxon_id field only (ignoring the
+    # optional left/right values).  This means that it has to make a
+    # separate SQL query for each entry in the lineage, but it does still
+    # appear to be *much* faster.  See Bug 2494.
+    taxonomy = []
+    while taxon_id:
+        name, rank, parent_taxon_id = adaptor.execute_one(
+            "SELECT taxon_name.name, taxon.node_rank, taxon.parent_taxon_id"
+            " FROM taxon, taxon_name"
+            " WHERE taxon.taxon_id=taxon_name.taxon_id"
+            " AND taxon_name.name_class='scientific name'"
+            " AND taxon.taxon_id = %s",
+            (taxon_id,),
+        )
+        if taxon_id == parent_taxon_id:
+            # If the taxon table has been populated by the BioSQL script
+            # load_ncbi_taxonomy.pl this is how top parent nodes are stored.
+            # Personally, I would have used a NULL parent_taxon_id here.
+            break
+
+        taxonomy.insert(0, name)
+        taxon_id = parent_taxon_id
+
+    if taxonomy:
+        a["taxonomy"] = taxonomy
+    return a
+
+
+def _retrieve_comment(adaptor, primary_id):
+    qvs = adaptor.execute_and_fetchall(
+        'SELECT comment_text FROM comment WHERE bioentry_id=%s ORDER BY "rank"',
+        (primary_id,),
+    )
+    comments = [comm[0] for comm in qvs]
+    # Don't want to add an empty list...
+    if comments:
+        return {"comment": comments}
+    else:
+        return {}
+
+
+class DBSeqRecord(SeqRecord):
+    """BioSQL equivalent of the Biopython SeqRecord object."""
+
+    def __init__(self, adaptor, primary_id):
+        """Create a DBSeqRecord object.
+
+        Arguments:
+         - adaptor - A BioSQL.BioSeqDatabase.Adaptor object
+         - primary_id - An internal integer ID used by BioSQL
+
+        You wouldn't normally create a DBSeqRecord object yourself,
+        this is done for you when using a BioSeqDatabase object
+        """
+        self._adaptor = adaptor
+        self._primary_id = primary_id
+
+        (
+            self._biodatabase_id,
+            self._taxon_id,
+            self.name,
+            accession,
+            version,
+            self._identifier,
+            self._division,
+            self.description,
+        ) = self._adaptor.execute_one(
+            "SELECT biodatabase_id, taxon_id, name, accession, version,"
+            " identifier, division, description"
+            " FROM bioentry"
+            " WHERE bioentry_id = %s",
+            (self._primary_id,),
+        )
+        if version and version != "0":
+            self.id = f"{accession}.{version}"
+        else:
+            self.id = accession
+        # We don't yet record any per-letter-annotations in the
+        # BioSQL database, but we should set this property up
+        # for completeness (and the __str__ method).
+        # We do NOT want to load the sequence from the DB here!
+        length = _retrieve_seq_len(adaptor, primary_id)
+        self._per_letter_annotations = _RestrictedDict(length=length)
+
+    def __get_seq(self):
+        if not hasattr(self, "_seq"):
+            self._seq = _retrieve_seq(self._adaptor, self._primary_id)
+        return self._seq
+
+    def __set_seq(self, seq):
+        # TODO - Check consistent with self._per_letter_annotations
+        self._seq = seq
+
+    def __del_seq(self):
+        del self._seq
+
+    seq = property(__get_seq, __set_seq, __del_seq, "Seq object")  # type: ignore
+
+    @property
+    def dbxrefs(self) -> list[str]:
+        """Database cross references."""
+        if not hasattr(self, "_dbxrefs"):
+            self._dbxrefs = _retrieve_dbxrefs(self._adaptor, self._primary_id)
+        return self._dbxrefs
+
+    @dbxrefs.setter
+    def dbxrefs(self, value: list[str]) -> None:
+        self._dbxrefs = value
+
+    @dbxrefs.deleter
+    def dbxrefs(self) -> None:
+        del self._dbxrefs
+
+    def __get_features(self):
+        if not hasattr(self, "_features"):
+            self._features = _retrieve_features(self._adaptor, self._primary_id)
+        return self._features
+
+    def __set_features(self, features):
+        self._features = features
+
+    def __del_features(self):
+        del self._features
+
+    features = property(__get_features, __set_features, __del_features, "Features")
+
+    @property
+    def annotations(self) -> SeqRecord._AnnotationsDict:
+        """Annotations."""
+        if not hasattr(self, "_annotations"):
+            self._annotations = _retrieve_annotations(
+                self._adaptor, self._primary_id, self._taxon_id
+            )
+            if self._identifier:
+                self._annotations["gi"] = self._identifier
+            if self._division:
+                self._annotations["data_file_division"] = self._division
+        return self._annotations
+
+    @annotations.setter
+    def annotations(self, value: SeqRecord._AnnotationsDict | None) -> None:
+        if value:
+            self._annotations = value
+        else:
+            self._annotations = {}
+
+    @annotations.deleter
+    def annotations(self) -> None:
+        del self._annotations

.venv_haddock/lib/python3.12/site-packages/BioSQL/Loader.py

@@ -0,0 +1,1260 @@
+# Copyright 2002 by Andrew Dalke.  All rights reserved.
+# Revisions 2007-2016 copyright by Peter Cock.  All rights reserved.
+# Revisions 2008 copyright by Cymon J. Cox.  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.
+#
+# Note that BioSQL (including the database schema and scripts) is
+# available and licensed separately.  Please consult www.biosql.org
+
+"""Load biopython objects into a BioSQL database for persistent storage.
+
+This code makes it possible to store biopython objects in a relational
+database and then retrieve them back. You shouldn't use any of the
+classes in this module directly. Rather, call the load() method on
+a database object.
+"""
+
+# standard modules
+from time import gmtime
+from time import strftime
+
+from Bio import Entrez
+from Bio.Seq import UndefinedSequenceError
+from Bio.SeqFeature import UnknownPosition
+
+# biopython
+from Bio.SeqUtils.CheckSum import crc64
+
+
+class DatabaseLoader:
+    """Object used to load SeqRecord objects into a BioSQL database."""
+
+    def __init__(self, adaptor, dbid, fetch_NCBI_taxonomy=False):
+        """Initialize with connection information for the database.
+
+        Creating a DatabaseLoader object is normally handled via the
+        BioSeqDatabase DBServer object, for example::
+
+            from BioSQL import BioSeqDatabase
+            server = BioSeqDatabase.open_database(driver="MySQLdb",
+                                                  user="gbrowse",
+                                                  passwd="biosql",
+                                                  host="localhost",
+                                                  db="test_biosql")
+            try:
+                db = server["test"]
+            except KeyError:
+                db = server.new_database("test",
+                description="For testing GBrowse")
+
+        """
+        self.adaptor = adaptor
+        self.dbid = dbid
+        self.fetch_NCBI_taxonomy = fetch_NCBI_taxonomy
+
+    def load_seqrecord(self, record):
+        """Load a Biopython SeqRecord into the database."""
+        bioentry_id = self._load_bioentry_table(record)
+        self._load_bioentry_date(record, bioentry_id)
+        self._load_biosequence(record, bioentry_id)
+        self._load_comment(record, bioentry_id)
+        self._load_dbxrefs(record, bioentry_id)
+        references = record.annotations.get("references", ())
+        for reference, rank in zip(references, list(range(len(references)))):
+            self._load_reference(reference, rank, bioentry_id)
+        self._load_annotations(record, bioentry_id)
+        for seq_feature_num in range(len(record.features)):
+            seq_feature = record.features[seq_feature_num]
+            self._load_seqfeature(seq_feature, seq_feature_num, bioentry_id)
+
+    def _get_ontology_id(self, name, definition=None):
+        """Return identifier for the named ontology (PRIVATE).
+
+        This looks through the onotology table for a the given entry name.
+        If it is not found, a row is added for this ontology (using the
+        definition if supplied).  In either case, the id corresponding to
+        the provided name is returned, so that you can reference it in
+        another table.
+        """
+        oids = self.adaptor.execute_and_fetch_col0(
+            "SELECT ontology_id FROM ontology WHERE name = %s", (name,)
+        )
+        if oids:
+            return oids[0]
+        self.adaptor.execute(
+            "INSERT INTO ontology(name, definition) VALUES (%s, %s)", (name, definition)
+        )
+        return self.adaptor.last_id("ontology")
+
+    def _get_term_id(self, name, ontology_id=None, definition=None, identifier=None):
+        """Get the id that corresponds to a term (PRIVATE).
+
+        This looks through the term table for a the given term. If it
+        is not found, a new id corresponding to this term is created.
+        In either case, the id corresponding to that term is returned, so
+        that you can reference it in another table.
+
+        The ontology_id should be used to disambiguate the term.
+        """
+        # try to get the term id
+        sql = "SELECT term_id FROM term WHERE name = %s"
+        fields = [name]
+        if ontology_id:
+            sql += " AND ontology_id = %s"
+            fields.append(ontology_id)
+        id_results = self.adaptor.execute_and_fetchall(sql, fields)
+        # something is wrong
+        if len(id_results) > 1:
+            raise ValueError(f"Multiple term ids for {name}: {id_results!r}")
+        elif len(id_results) == 1:
+            return id_results[0][0]
+        else:
+            sql = (
+                "INSERT INTO term (name, definition,"
+                " identifier, ontology_id)"
+                " VALUES (%s, %s, %s, %s)"
+            )
+            self.adaptor.execute(sql, (name, definition, identifier, ontology_id))
+            return self.adaptor.last_id("term")
+
+    def _add_dbxref(self, dbname, accession, version):
+        """Insert a dbxref and return its id (PRIVATE)."""
+        self.adaptor.execute(
+            "INSERT INTO dbxref(dbname, accession, version) VALUES (%s, %s, %s)",
+            (dbname, accession, version),
+        )
+        return self.adaptor.last_id("dbxref")
+
+    def _get_taxon_id(self, record):
+        """Get the taxon id for this record (PRIVATE).
+
+        Arguments:
+         - record - a SeqRecord object
+
+        This searches the taxon/taxon_name tables using the
+        NCBI taxon ID, scientific name and common name to find
+        the matching taxon table entry's id.
+
+        If the species isn't in the taxon table, and we have at
+        least the NCBI taxon ID, scientific name or common name,
+        at least a minimal stub entry is created in the table.
+
+        Returns the taxon id (database key for the taxon table,
+        not an NCBI taxon ID), or None if the taxonomy information
+        is missing.
+
+        See also the BioSQL script load_ncbi_taxonomy.pl which
+        will populate and update the taxon/taxon_name tables
+        with the latest information from the NCBI.
+        """
+        # To find the NCBI taxid, first check for a top level annotation
+        ncbi_taxon_id = None
+        if "ncbi_taxid" in record.annotations:
+            # Could be a list of IDs.
+            if isinstance(record.annotations["ncbi_taxid"], list):
+                if len(record.annotations["ncbi_taxid"]) == 1:
+                    ncbi_taxon_id = record.annotations["ncbi_taxid"][0]
+            else:
+                ncbi_taxon_id = record.annotations["ncbi_taxid"]
+        if not ncbi_taxon_id:
+            # Secondly, look for a source feature
+            for f in record.features:
+                if f.type == "source":
+                    quals = getattr(f, "qualifiers", {})
+                    if "db_xref" in quals:
+                        for db_xref in f.qualifiers["db_xref"]:
+                            if db_xref.startswith("taxon:"):
+                                ncbi_taxon_id = int(db_xref[6:])
+                                break
+                if ncbi_taxon_id:
+                    break
+
+        try:
+            scientific_name = record.annotations["organism"][:255]
+        except KeyError:
+            scientific_name = None
+        try:
+            common_name = record.annotations["source"][:255]
+        except KeyError:
+            common_name = None
+        # Note: The maximum length for taxon names in the schema is 255.
+        # Cropping it now should help in getting a match when searching,
+        # and avoids an error if we try and add these to the database.
+
+        if ncbi_taxon_id:
+            # Good, we have the NCBI taxon to go on - this is unambiguous :)
+            # Note that the scientific name and common name will only be
+            # used if we have to record a stub entry.
+            return self._get_taxon_id_from_ncbi_taxon_id(
+                ncbi_taxon_id, scientific_name, common_name
+            )
+
+        if not common_name and not scientific_name:
+            # Nothing to go on... and there is no point adding
+            # a new entry to the database.  We'll just leave this
+            # sequence's taxon as a NULL in the database.
+            return None
+
+        # Next, we'll try to find a match based on the species name
+        # (stored in GenBank files as the organism and/or the source).
+        if scientific_name:
+            taxa = self.adaptor.execute_and_fetch_col0(
+                "SELECT taxon_id FROM taxon_name"
+                " WHERE name_class = 'scientific name' AND name = %s",
+                (scientific_name,),
+            )
+            if taxa:
+                # Good, mapped the scientific name to a taxon table entry
+                return taxa[0]
+
+        # Last chance...
+        if common_name:
+            taxa = self.adaptor.execute_and_fetch_col0(
+                "SELECT DISTINCT taxon_id FROM taxon_name WHERE name = %s",
+                (common_name,),
+            )
+            # Its natural that several distinct taxa will have the same common
+            # name - in which case we can't resolve the taxon uniquely.
+            if len(taxa) > 1:
+                raise ValueError(
+                    "Taxa: %d species have name %r" % (len(taxa), common_name)
+                )
+            if taxa:
+                # Good, mapped the common name to a taxon table entry
+                return taxa[0]
+
+        # At this point, as far as we can tell, this species isn't
+        # in the taxon table already.  So we'll have to add it.
+        # We don't have an NCBI taxonomy ID, so if we do record just
+        # a stub entry, there is no simple way to fix this later.
+        #
+        # TODO - Should we try searching the NCBI taxonomy using the
+        # species name?
+        #
+        # OK, let's try inserting the species.
+        # Chances are we don't have enough information ...
+        # Furthermore, it won't be in the hierarchy.
+
+        lineage = []
+        for c in record.annotations.get("taxonomy", []):
+            lineage.append([None, None, c])
+        if lineage:
+            lineage[-1][1] = "genus"
+        lineage.append([None, "species", record.annotations["organism"]])
+        # XXX do we have them?
+        if "subspecies" in record.annotations:
+            lineage.append([None, "subspecies", record.annotations["subspecies"]])
+        if "variant" in record.annotations:
+            lineage.append([None, "varietas", record.annotations["variant"]])
+        lineage[-1][0] = ncbi_taxon_id
+
+        left_value = self.adaptor.execute_one("SELECT MAX(left_value) FROM taxon")[0]
+        if not left_value:
+            left_value = 0
+        left_value += 1
+
+        # XXX -- Brad: Fixing this for now in an ugly way because
+        # I am getting overlaps for right_values. I need to dig into this
+        # more to actually understand how it works. I'm not sure it is
+        # actually working right anyhow.
+        right_start_value = self.adaptor.execute_one(
+            "SELECT MAX(right_value) FROM taxon"
+        )[0]
+        if not right_start_value:
+            right_start_value = 0
+        right_value = right_start_value + 2 * len(lineage) - 1
+
+        parent_taxon_id = None
+        for taxon in lineage:
+            self.adaptor.execute(
+                "INSERT INTO taxon(parent_taxon_id, ncbi_taxon_id, node_rank,"
+                " left_value, right_value)"
+                " VALUES (%s, %s, %s, %s, %s)",
+                (parent_taxon_id, taxon[0], taxon[1], left_value, right_value),
+            )
+            taxon_id = self.adaptor.last_id("taxon")
+            self.adaptor.execute(
+                "INSERT INTO taxon_name(taxon_id, name, name_class)"
+                "VALUES (%s, %s, 'scientific name')",
+                (taxon_id, taxon[2][:255]),
+            )
+            # Note the name field is limited to 255, some SwissProt files
+            # have a multi-species name which can be longer.  So truncate this.
+            left_value += 1
+            right_value -= 1
+            parent_taxon_id = taxon_id
+        if common_name:
+            self.adaptor.execute(
+                "INSERT INTO taxon_name(taxon_id, name, name_class)"
+                "VALUES (%s, %s, 'common name')",
+                (taxon_id, common_name),
+            )
+
+        return taxon_id
+
+    def _fix_name_class(self, entrez_name):
+        """Map Entrez name terms to those used in taxdump (PRIVATE).
+
+        We need to make this conversion to match the taxon_name.name_class
+        values used by the BioSQL load_ncbi_taxonomy.pl script.
+
+        e.g.::
+
+            "ScientificName" -> "scientific name",
+            "EquivalentName" -> "equivalent name",
+            "Synonym" -> "synonym",
+
+        """
+        # Add any special cases here:
+        #
+        # known = {}
+        # try:
+        #     return known[entrez_name]
+        # except KeyError:
+        #     pass
+
+        # Try automatically by adding spaces before each capital
+        def add_space(letter):
+            """Add a space before a capital letter."""
+            if letter.isupper():
+                return " " + letter.lower()
+            else:
+                return letter
+
+        answer = "".join(add_space(letter) for letter in entrez_name).strip()
+        if answer != answer.lower():
+            raise ValueError(
+                f"Expected processed entrez_name, '{answer}' to only have lower case letters."
+            )
+        return answer
+
+    def _update_left_right_taxon_values(self, left_value):
+        """Update the left and right taxon values in the table (PRIVATE)."""
+        if not left_value:
+            return
+        # Due to the UNIQUE constraint on the left and right values in the taxon
+        # table we cannot simply update them through an SQL statement as we risk
+        # colliding values. Instead we must select all of the rows that we want to
+        # update, modify the values in python and then update the rows
+        # self.adaptor.execute("UPDATE taxon SET right_value = right_value + 2 "
+        #                      "WHERE right_value >= %s", (left_value,))
+        # self.adaptor.execute("UPDATE taxon SET left_value = left_value + 2 "
+        #                      "WHERE left_value > %s", (left_value,))
+
+        rows = self.adaptor.execute_and_fetchall(
+            "SELECT left_value, right_value, taxon_id FROM taxon "
+            "WHERE right_value >= %s or left_value > %s",
+            (left_value, left_value),
+        )
+
+        right_rows = []
+        left_rows = []
+        for row in rows:
+            new_right = row[1]
+            new_left = row[0]
+            if new_right >= left_value:
+                new_right += 2
+
+            if new_left > left_value:
+                new_left += 2
+            right_rows.append((new_right, row[2]))
+            left_rows.append((new_left, row[2]))
+
+        # sort the rows based on the value from largest to smallest
+        # should ensure no overlaps
+        right_rows = sorted(right_rows, key=lambda x: x[0], reverse=True)
+        left_rows = sorted(left_rows, key=lambda x: x[0], reverse=True)
+
+        self.adaptor.executemany(
+            "UPDATE taxon SET left_value = %s WHERE taxon_id = %s", left_rows
+        )
+        self.adaptor.executemany(
+            "UPDATE taxon SET right_value = %s WHERE taxon_id = %s", right_rows
+        )
+
+    def _get_taxon_id_from_ncbi_taxon_id(
+        self, ncbi_taxon_id, scientific_name=None, common_name=None
+    ):
+        """Get the taxon id for record from NCBI taxon ID (PRIVATE).
+
+        Arguments:
+         - ncbi_taxon_id - string containing an NCBI taxon id
+         - scientific_name - string, used if a stub entry is recorded
+         - common_name - string, used if a stub entry is recorded
+
+        This searches the taxon table using ONLY the NCBI taxon ID
+        to find the matching taxon table entry's ID (database key).
+
+        If the species isn't in the taxon table, and the fetch_NCBI_taxonomy
+        flag is true, Biopython will attempt to go online using Bio.Entrez
+        to fetch the official NCBI lineage, recursing up the tree until an
+        existing entry is found in the database or the full lineage has been
+        fetched.
+
+        Otherwise the NCBI taxon ID, scientific name and common name are
+        recorded as a minimal stub entry in the taxon and taxon_name tables.
+        Any partial information about the lineage from the SeqRecord is NOT
+        recorded.  This should mean that (re)running the BioSQL script
+        load_ncbi_taxonomy.pl can fill in the taxonomy lineage.
+
+        Returns the taxon id (database key for the taxon table, not
+        an NCBI taxon ID).
+        """
+        if not ncbi_taxon_id:
+            raise ValueError("Expected a non-empty value for ncbi_taxon_id.")
+
+        taxon_id = self.adaptor.execute_and_fetch_col0(
+            "SELECT taxon_id FROM taxon WHERE ncbi_taxon_id = %s", (int(ncbi_taxon_id),)
+        )
+        if taxon_id:
+            # Good, we have mapped the NCBI taxid to a taxon table entry
+            return taxon_id[0]
+
+        # At this point, as far as we can tell, this species isn't
+        # in the taxon table already.  So we'll have to add it.
+
+        parent_taxon_id = None
+        rank = "species"
+        genetic_code = None
+        mito_genetic_code = None
+        parent_left_value = None
+        parent_right_value = None
+        left_value = None
+        right_value = None
+        species_names = []
+        if scientific_name:
+            species_names.append(("scientific name", scientific_name))
+        if common_name:
+            species_names.append(("common name", common_name))
+
+        if self.fetch_NCBI_taxonomy:
+            # Go online to get the parent taxon ID!
+            handle = Entrez.efetch(db="taxonomy", id=ncbi_taxon_id, retmode="XML")
+            taxonomic_record = Entrez.read(handle)
+            if len(taxonomic_record) == 1:
+                if taxonomic_record[0]["TaxId"] != str(ncbi_taxon_id):
+                    raise ValueError(
+                        f"ncbi_taxon_id different from parent taxon id. {ncbi_taxon_id} versus {taxonomic_record[0]['TaxId']}"
+                    )
+
+                (
+                    parent_taxon_id,
+                    parent_left_value,
+                    parent_right_value,
+                ) = self._get_taxon_id_from_ncbi_lineage(
+                    taxonomic_record[0]["LineageEx"]
+                )
+
+                left_value = parent_right_value
+                right_value = parent_right_value + 1
+
+                rank = str(taxonomic_record[0]["Rank"])
+
+                genetic_code = int(taxonomic_record[0]["GeneticCode"]["GCId"])
+
+                mito_genetic_code = int(taxonomic_record[0]["MitoGeneticCode"]["MGCId"])
+
+                species_names = [
+                    ("scientific name", str(taxonomic_record[0]["ScientificName"]))
+                ]
+                try:
+                    for name_class, names in taxonomic_record[0]["OtherNames"].items():
+                        name_class = self._fix_name_class(name_class)
+                        if not isinstance(names, list):
+                            # The Entrez parser seems to return single entry
+                            # lists as just a string which is annoying.
+                            names = [names]
+                        for name in names:
+                            # Want to ignore complex things like ClassCDE
+                            # entries
+                            if isinstance(name, str):
+                                species_names.append((name_class, name))
+                except KeyError:
+                    # OtherNames isn't always present,
+                    # e.g. NCBI taxon 41205, Bromheadia finlaysoniana
+                    pass
+        else:
+            pass
+            # If we are not allowed to go online, we will record the bare minimum;
+            # as long as the NCBI taxon id is present, then (re)running
+            # load_ncbi_taxonomy.pl should fill in the taxonomomy lineage
+            # (and update the species names).
+            #
+            # I am NOT going to try and record the lineage, even if it
+            # is in the record annotation as a list of names, as we won't
+            # know the NCBI taxon IDs for these parent nodes.
+
+        self._update_left_right_taxon_values(left_value)
+
+        self.adaptor.execute(
+            "INSERT INTO taxon(parent_taxon_id, ncbi_taxon_id, node_rank,"
+            " genetic_code, mito_genetic_code, left_value, right_value)"
+            " VALUES (%s, %s, %s, %s, %s, %s, %s)",
+            (
+                parent_taxon_id,
+                ncbi_taxon_id,
+                rank,
+                genetic_code,
+                mito_genetic_code,
+                left_value,
+                right_value,
+            ),
+        )
+
+        taxon_id = self.adaptor.last_id("taxon")
+
+        # Record the scientific name, common name, etc
+        for name_class, name in species_names:
+            self.adaptor.execute(
+                "INSERT INTO taxon_name(taxon_id, name, name_class)"
+                " VALUES (%s, %s, %s)",
+                (taxon_id, name[:255], name_class),
+            )
+        return taxon_id
+
+    def _get_taxon_id_from_ncbi_lineage(self, taxonomic_lineage):
+        """Recursive method to get taxon ID from NCBI lineage (PRIVATE).
+
+        Arguments:
+         - taxonomic_lineage - list of taxonomy dictionaries from Bio.Entrez
+
+        First dictionary in list is the taxonomy root, highest would be
+        the species. Each dictionary includes:
+
+        - TaxID (string, NCBI taxon id)
+        - Rank (string, e.g. "species", "genus", ..., "phylum", ...)
+        - ScientificName (string)
+
+        (and that is all at the time of writing)
+
+        This method will record all the lineage given, returning the taxon id
+        (database key, not NCBI taxon id) of the final entry (the species).
+        """
+        ncbi_taxon_id = int(taxonomic_lineage[-1]["TaxId"])
+        left_value = None
+        right_value = None
+        parent_left_value = None
+        parent_right_value = None
+        # Is this in the database already?  Check the taxon table...
+        rows = self.adaptor.execute_and_fetchall(
+            "SELECT taxon_id, left_value, right_value FROM taxon"
+            " WHERE ncbi_taxon_id=%s" % ncbi_taxon_id
+        )
+        if rows:
+            # we could verify that the Scientific Name etc in the database
+            # is the same and update it or print a warning if not...
+            if len(rows) != 1:
+                raise ValueError(f"Expected 1 response, got {len(rows)}")
+            return rows[0]
+
+        # We have to record this.
+        if len(taxonomic_lineage) > 1:
+            # Use recursion to find out the taxon id (database key) of the
+            # parent.
+            (
+                parent_taxon_id,
+                parent_left_value,
+                parent_right_value,
+            ) = self._get_taxon_id_from_ncbi_lineage(taxonomic_lineage[:-1])
+            left_value = parent_right_value
+            right_value = parent_right_value + 1
+            if not isinstance(parent_taxon_id, int):
+                raise ValueError(
+                    f"Expected parent_taxon_id to be an int, got {parent_taxon_id}"
+                )
+        else:
+            # we have reached the top of the lineage but no current taxonomy
+            # id has been found
+            parent_taxon_id = None
+            left_value = self.adaptor.execute_one("SELECT MAX(left_value) FROM taxon")[
+                0
+            ]
+            if not left_value:
+                left_value = 0
+
+            right_value = left_value + 1
+
+        self._update_left_right_taxon_values(left_value)
+
+        # INSERT new taxon
+        rank = str(taxonomic_lineage[-1].get("Rank"))
+        self.adaptor.execute(
+            "INSERT INTO taxon(ncbi_taxon_id, parent_taxon_id, node_rank, "
+            "left_value, right_value) VALUES (%s, %s, %s, %s, %s)",
+            (ncbi_taxon_id, parent_taxon_id, rank, left_value, right_value),
+        )
+
+        taxon_id = self.adaptor.last_id("taxon")
+        # assert isinstance(taxon_id, int), repr(taxon_id)
+        # ... and its name in taxon_name
+        scientific_name = taxonomic_lineage[-1].get("ScientificName")
+        if scientific_name:
+            self.adaptor.execute(
+                "INSERT INTO taxon_name(taxon_id, name, name_class) "
+                "VALUES (%s, %s, 'scientific name')",
+                (taxon_id, scientific_name[:255]),
+            )
+        return taxon_id, left_value, right_value
+
+    def _load_bioentry_table(self, record):
+        """Fill the bioentry table with sequence information (PRIVATE).
+
+        Arguments:
+         - record - SeqRecord object to add to the database.
+
+        """
+        # get the pertinent info and insert it
+
+        if record.id.count(".") == 1:  # try to get a version from the id
+            # This assumes the string is something like "XXXXXXXX.123"
+            accession, version = record.id.split(".")
+            try:
+                version = int(version)
+            except ValueError:
+                accession = record.id
+                version = 0
+        else:  # otherwise just use a version of 0
+            accession = record.id
+            version = 0
+
+        if (
+            "accessions" in record.annotations
+            and isinstance(record.annotations["accessions"], list)
+            and record.annotations["accessions"]
+        ):
+            # Take the first accession (one if there is more than one)
+            accession = record.annotations["accessions"][0]
+
+        # Find the taxon id (this is not just the NCBI Taxon ID)
+        # NOTE - If the species isn't defined in the taxon table,
+        # a new minimal entry is created.
+        taxon_id = self._get_taxon_id(record)
+
+        if "gi" in record.annotations:
+            identifier = record.annotations["gi"]
+        else:
+            identifier = record.id
+
+        # Allow description and division to default to NULL as in BioPerl.
+        description = getattr(record, "description", None)
+        division = record.annotations.get("data_file_division")
+
+        sql = """
+        INSERT INTO bioentry (
+         biodatabase_id,
+         taxon_id,
+         name,
+         accession,
+         identifier,
+         division,
+         description,
+         version)
+        VALUES (
+         %s,
+         %s,
+         %s,
+         %s,
+         %s,
+         %s,
+         %s,
+         %s)"""
+        # print(self.dbid, taxon_id, record.name, accession, identifier, \
+        #        division, description, version)
+        self.adaptor.execute(
+            sql,
+            (
+                self.dbid,
+                taxon_id,
+                record.name,
+                accession,
+                identifier,
+                division,
+                description,
+                version,
+            ),
+        )
+        # now retrieve the id for the bioentry
+        return self.adaptor.last_id("bioentry")
+
+    def _load_bioentry_date(self, record, bioentry_id):
+        """Add the effective date of the entry into the database (PRIVATE).
+
+        record - a SeqRecord object with an annotated date
+        bioentry_id - corresponding database identifier
+        """
+        # dates are GenBank style, like:
+        # 14-SEP-2000
+        date = record.annotations.get("date", strftime("%d-%b-%Y", gmtime()).upper())
+        if isinstance(date, list):
+            date = date[0]
+        annotation_tags_id = self._get_ontology_id("Annotation Tags")
+        date_id = self._get_term_id("date_changed", annotation_tags_id)
+        sql = (
+            "INSERT INTO bioentry_qualifier_value"
+            ' (bioentry_id, term_id, value, "rank")'
+            " VALUES (%s, %s, %s, 1)"
+        )
+        self.adaptor.execute(sql, (bioentry_id, date_id, date))
+
+    def _load_biosequence(self, record, bioentry_id):
+        """Record SeqRecord's sequence and alphabet in DB (PRIVATE).
+
+        Arguments:
+         - record - a SeqRecord object with a seq property
+         - bioentry_id - corresponding database identifier
+
+        """
+        if record.seq is None:
+            # The biosequence table entry is optional, so if we haven't
+            # got a sequence, we don't need to write to the table.
+            return
+
+        molecule_type = record.annotations.get("molecule_type", "")
+        if "DNA" in molecule_type:
+            alphabet = "dna"
+        elif "RNA" in molecule_type:
+            alphabet = "rna"
+        elif "protein" in molecule_type:
+            alphabet = "protein"
+        else:
+            alphabet = "unknown"
+
+        try:
+            seq_str = str(record.seq)
+        except UndefinedSequenceError:
+            seq_str = None
+
+        sql = (
+            "INSERT INTO biosequence (bioentry_id, version, "
+            "length, seq, alphabet) "
+            "VALUES (%s, 0, %s, %s, %s)"
+        )
+        self.adaptor.execute(sql, (bioentry_id, len(record.seq), seq_str, alphabet))
+
+    def _load_comment(self, record, bioentry_id):
+        """Record a SeqRecord's annotated comment in the database (PRIVATE).
+
+        Arguments:
+         - record - a SeqRecord object with an annotated comment
+         - bioentry_id - corresponding database identifier
+
+        """
+        comments = record.annotations.get("comment")
+        if not comments:
+            return
+        if not isinstance(comments, list):
+            # It should be a string then...
+            comments = [comments]
+
+        for index, comment in enumerate(comments):
+            comment = comment.replace("\n", " ")
+            # TODO - Store each line as a separate entry?  This would preserve
+            # the newlines, but we should check BioPerl etc to be consistent.
+            sql = (
+                'INSERT INTO comment (bioentry_id, comment_text, "rank")'
+                " VALUES (%s, %s, %s)"
+            )
+            self.adaptor.execute(sql, (bioentry_id, comment, index + 1))
+
+    def _load_annotations(self, record, bioentry_id):
+        """Record a SeqRecord's misc annotations in the database (PRIVATE).
+
+        The annotation strings are recorded in the bioentry_qualifier_value
+        table, except for special cases like the reference, comment and
+        taxonomy which are handled with their own tables.
+
+        Arguments:
+         - record - a SeqRecord object with an annotations dictionary
+         - bioentry_id - corresponding database identifier
+
+        """
+        mono_sql = (
+            "INSERT INTO bioentry_qualifier_value"
+            "(bioentry_id, term_id, value)"
+            " VALUES (%s, %s, %s)"
+        )
+        many_sql = (
+            "INSERT INTO bioentry_qualifier_value"
+            '(bioentry_id, term_id, value, "rank")'
+            " VALUES (%s, %s, %s, %s)"
+        )
+        tag_ontology_id = self._get_ontology_id("Annotation Tags")
+        for key, value in record.annotations.items():
+            if key in ["molecule_type", "references", "comment", "ncbi_taxid", "date"]:
+                # Handled separately
+                continue
+            term_id = self._get_term_id(key, ontology_id=tag_ontology_id)
+            if isinstance(value, (list, tuple)):
+                rank = 0
+                for entry in value:
+                    if isinstance(entry, (str, int)):
+                        # Easy case
+                        rank += 1
+                        self.adaptor.execute(
+                            many_sql, (bioentry_id, term_id, str(entry), rank)
+                        )
+                    else:
+                        pass
+            elif isinstance(value, (str, int)):
+                # Have a simple single entry, leave rank as the DB default
+                self.adaptor.execute(mono_sql, (bioentry_id, term_id, str(value)))
+            else:
+                pass
+                # print("Ignoring annotation '%s' entry of type '%s'" \
+                #      % (key, type(value)))
+
+    def _load_reference(self, reference, rank, bioentry_id):
+        """Record SeqRecord's annotated references in the database (PRIVATE).
+
+        Arguments:
+         - record - a SeqRecord object with annotated references
+         - bioentry_id - corresponding database identifier
+
+        """
+        refs = None
+        if reference.medline_id:
+            refs = self.adaptor.execute_and_fetch_col0(
+                "SELECT reference_id"
+                " FROM reference JOIN dbxref USING (dbxref_id)"
+                " WHERE dbname = 'MEDLINE' AND accession = %s",
+                (reference.medline_id,),
+            )
+        if not refs and reference.pubmed_id:
+            refs = self.adaptor.execute_and_fetch_col0(
+                "SELECT reference_id"
+                " FROM reference JOIN dbxref USING (dbxref_id)"
+                " WHERE dbname = 'PUBMED' AND accession = %s",
+                (reference.pubmed_id,),
+            )
+        if not refs:
+            s = []
+            for f in reference.authors, reference.title, reference.journal:
+                s.append(f or "<undef>")
+            crc = crc64("".join(s))
+            refs = self.adaptor.execute_and_fetch_col0(
+                "SELECT reference_id FROM reference WHERE crc = %s", (crc,)
+            )
+        if not refs:
+            if reference.medline_id:
+                dbxref_id = self._add_dbxref("MEDLINE", reference.medline_id, 0)
+            elif reference.pubmed_id:
+                dbxref_id = self._add_dbxref("PUBMED", reference.pubmed_id, 0)
+            else:
+                dbxref_id = None
+            authors = reference.authors or None
+            title = reference.title or None
+            # The location/journal field cannot be Null, so default
+            # to an empty string rather than None:
+            journal = reference.journal or ""
+            self.adaptor.execute(
+                "INSERT INTO reference (dbxref_id, location,"
+                " title, authors, crc)"
+                " VALUES (%s, %s, %s, %s, %s)",
+                (dbxref_id, journal, title, authors, crc),
+            )
+            reference_id = self.adaptor.last_id("reference")
+        else:
+            reference_id = refs[0]
+
+        if reference.location:
+            start = 1 + int(str(reference.location[0].start))
+            end = int(str(reference.location[0].end))
+        else:
+            start = None
+            end = None
+
+        sql = (
+            "INSERT INTO bioentry_reference (bioentry_id, reference_id,"
+            ' start_pos, end_pos, "rank") VALUES (%s, %s, %s, %s, %s)'
+        )
+        self.adaptor.execute(sql, (bioentry_id, reference_id, start, end, rank + 1))
+
+    def _load_seqfeature(self, feature, feature_rank, bioentry_id):
+        """Load a biopython SeqFeature into the database (PRIVATE)."""
+        # records loaded from a gff file using BCBio.GFF will contain value
+        # of 2nd column of the gff as a feature qualifier. The BioSQL wiki
+        # suggests that the source should not go in with the other feature
+        # mappings but instead be put in the term table
+        # (http://www.biosql.org/wiki/Annotation_Mapping)
+        try:
+            source = feature.qualifiers["source"]
+            if isinstance(source, list):
+                source = source[0]
+            seqfeature_id = self._load_seqfeature_basic(
+                feature.type, feature_rank, bioentry_id, source=source
+            )
+        except KeyError:
+            seqfeature_id = self._load_seqfeature_basic(
+                feature.type, feature_rank, bioentry_id
+            )
+
+        self._load_seqfeature_locations(feature, seqfeature_id)
+        self._load_seqfeature_qualifiers(feature.qualifiers, seqfeature_id)
+
+    def _load_seqfeature_basic(
+        self, feature_type, feature_rank, bioentry_id, source="EMBL/GenBank/SwissProt"
+    ):
+        """Load the first tables of a seqfeature and returns the id (PRIVATE).
+
+        This loads the "key" of the seqfeature (ie. CDS, gene) and
+        the basic seqfeature table itself.
+        """
+        ontology_id = self._get_ontology_id("SeqFeature Keys")
+        seqfeature_key_id = self._get_term_id(feature_type, ontology_id=ontology_id)
+        source_cat_id = self._get_ontology_id("SeqFeature Sources")
+        source_term_id = self._get_term_id(source, ontology_id=source_cat_id)
+
+        sql = (
+            "INSERT INTO seqfeature (bioentry_id, type_term_id, "
+            'source_term_id, "rank") VALUES (%s, %s, %s, %s)'
+        )
+        self.adaptor.execute(
+            sql, (bioentry_id, seqfeature_key_id, source_term_id, feature_rank + 1)
+        )
+        return self.adaptor.last_id("seqfeature")
+
+    def _load_seqfeature_locations(self, feature, seqfeature_id):
+        """Load all of the locations for a SeqFeature into tables (PRIVATE).
+
+        This adds the locations related to the SeqFeature into the
+        seqfeature_location table. Fuzzies are not handled right now.
+        For a simple location, ie (1..2), we have a single table row
+        with seq_start = 1, seq_end = 2, location_rank = 1.
+
+        For split locations, ie (1..2, 3..4, 5..6) we would have three
+        row tables with::
+
+            start = 1, end = 2, rank = 1
+            start = 3, end = 4, rank = 2
+            start = 5, end = 6, rank = 3
+
+        """
+        # TODO - Record an ontology for the locations (using location.term_id)
+        # which for now as in BioPerl we leave defaulting to NULL.
+        try:
+            if feature.location.operator != "join":
+                # e.g. order locations... we don't record "order" so it
+                # will become a "join" on reloading. What does BioPerl do?
+                import warnings
+
+                from Bio import BiopythonWarning
+
+                warnings.warn(
+                    "%s location operators are not fully supported"
+                    % feature.location_operator,
+                    BiopythonWarning,
+                )
+        except AttributeError:
+            pass
+        # This will be a list of length one for a SimpleLocation:
+        parts = feature.location.parts
+        if parts and {loc.strand for loc in parts} == {-1}:
+            # To mimic prior behaviour of Biopython+BioSQL, reverse order
+            parts = parts[::-1]
+            # TODO - Check what BioPerl does; see also BioSeq.py code
+        for rank, loc in enumerate(parts):
+            self._insert_location(loc, rank + 1, seqfeature_id)
+
+    def _insert_location(self, location, rank, seqfeature_id):
+        """Add SeqFeature location to seqfeature_location table (PRIVATE).
+
+        TODO - Add location operator to location_qualifier_value?
+        """
+        # convert biopython locations to the 1-based location system
+        # used in bioSQL
+        # XXX This could also handle fuzzies
+
+        try:
+            start = int(location.start) + 1
+        except TypeError:
+            # Handle SwissProt unknown position (?)
+            if isinstance(location.start, UnknownPosition):
+                start = None
+            else:
+                raise
+
+        try:
+            end = int(location.end)
+        except TypeError:
+            # Handle SwissProt unknown position (?)
+            if isinstance(location.end, UnknownPosition):
+                end = None
+            else:
+                raise
+
+        # Biopython uses None when we don't know strand information but
+        # BioSQL requires something (non null) and sets this as zero
+        # So we'll use the strand or 0 if Biopython spits out None
+        strand = location.strand or 0
+
+        # TODO - Record an ontology term for the location (location.term_id)
+        # which for now like BioPerl we'll leave as NULL.
+        # This might allow us to record "between" positions properly, but I
+        # don't really see how it could work for before/after fuzzy positions
+        loc_term_id = None
+
+        if location.ref:
+            # sub_feature remote locations when they are in the same db as the
+            # current record do not have a value for ref_db, which SeqFeature
+            # object stores as None. BioSQL schema requires a varchar and is
+            # not NULL
+            dbxref_id = self._get_dbxref_id(location.ref_db or "", location.ref)
+        else:
+            dbxref_id = None
+
+        sql = (
+            "INSERT INTO location (seqfeature_id, dbxref_id, term_id,"
+            'start_pos, end_pos, strand, "rank") '
+            "VALUES (%s, %s, %s, %s, %s, %s, %s)"
+        )
+        self.adaptor.execute(
+            sql, (seqfeature_id, dbxref_id, loc_term_id, start, end, strand, rank)
+        )
+
+        """
+        # See Bug 2677
+        # TODO - Record the location_operator (e.g. "join" or "order")
+        # using the location_qualifier_value table (which we and BioPerl
+        # have historically left empty).
+        # Note this will need an ontology term for the location qualifier
+        # (location_qualifier_value.term_id) for which oddly the schema
+        # does not allow NULL.
+        if feature.location_operator:
+            #e.g. "join" (common),
+            #or "order" (see Tests/GenBank/protein_refseq2.gb)
+            location_id = self.adaptor.last_id('location')
+            loc_qual_term_id = None # Not allowed in BioSQL v1.0.1
+            sql = ("INSERT INTO location_qualifier_value"
+                   "(location_id, term_id, value) "
+                   "VALUES (%s, %s, %s)")
+            self.adaptor.execute(sql, (location_id, loc_qual_term_id,
+                                       feature.location_operator))
+        """
+
+    def _load_seqfeature_qualifiers(self, qualifiers, seqfeature_id):
+        """Insert feature's (key, value) pair qualifiers (PRIVATE).
+
+        Qualifiers should be a dictionary of the form::
+
+            {key : [value1, value2]}
+
+        """
+        tag_ontology_id = self._get_ontology_id("Annotation Tags")
+        for qualifier_key in qualifiers:
+            # Treat db_xref qualifiers differently to sequence annotation
+            # qualifiers by populating the seqfeature_dbxref and dbxref
+            # tables.  Other qualifiers go into the seqfeature_qualifier_value
+            # and (if new) term tables.
+            if qualifier_key != "db_xref":
+                qualifier_key_id = self._get_term_id(
+                    qualifier_key, ontology_id=tag_ontology_id
+                )
+                # now add all of the values to their table
+                entries = qualifiers[qualifier_key]
+                if not isinstance(entries, list):
+                    # Could be a plain string, or an int or a float.
+                    # However, we exect a list of strings here.
+                    entries = [entries]
+                for qual_value_rank in range(len(entries)):
+                    qualifier_value = entries[qual_value_rank]
+                    sql = (
+                        "INSERT INTO seqfeature_qualifier_value "
+                        ' (seqfeature_id, term_id, "rank", value) VALUES'
+                        " (%s, %s, %s, %s)"
+                    )
+                    self.adaptor.execute(
+                        sql,
+                        (
+                            seqfeature_id,
+                            qualifier_key_id,
+                            qual_value_rank + 1,
+                            qualifier_value,
+                        ),
+                    )
+            else:
+                # The dbxref_id qualifier/value sets go into the dbxref table
+                # as dbname, accession, version tuples, with dbxref.dbxref_id
+                # being automatically assigned, and into the seqfeature_dbxref
+                # table as seqfeature_id, dbxref_id, and rank tuples
+                self._load_seqfeature_dbxref(qualifiers[qualifier_key], seqfeature_id)
+
+    def _load_seqfeature_dbxref(self, dbxrefs, seqfeature_id):
+        """Add SeqFeature's DB cross-references to the database (PRIVATE).
+
+        Arguments:
+         - dbxrefs - List, dbxref data from the source file in the
+           format <database>:<accession>
+         - seqfeature_id - Int, the identifier for the seqfeature in the
+           seqfeature table
+
+        Insert dbxref qualifier data for a seqfeature into the
+        seqfeature_dbxref and, if required, dbxref tables.
+        The dbxref_id qualifier/value sets go into the dbxref table
+        as dbname, accession, version tuples, with dbxref.dbxref_id
+        being automatically assigned, and into the seqfeature_dbxref
+        table as seqfeature_id, dbxref_id, and rank tuples.
+        """
+        # NOTE - In older versions of Biopython, we would map the GenBank
+        # db_xref "name", for example "GI" to "GeneIndex", and give a warning
+        # for any unknown terms.  This was a long term maintenance problem,
+        # and differed from BioPerl and BioJava's implementation.  See bug 2405
+        for rank, value in enumerate(dbxrefs):
+            # Split the DB:accession format string at colons.  We have to
+            # account for multiple-line and multiple-accession entries
+            try:
+                dbxref_data = value.replace(" ", "").replace("\n", "").split(":")
+                db = dbxref_data[0]
+                accessions = dbxref_data[1:]
+            except Exception:
+                raise ValueError(f"Parsing of db_xref failed: '{value}'") from None
+            # Loop over all the grabbed accessions, and attempt to fill the
+            # table
+            for accession in accessions:
+                # Get the dbxref_id value for the dbxref data
+                dbxref_id = self._get_dbxref_id(db, accession)
+                # Insert the seqfeature_dbxref data
+                self._get_seqfeature_dbxref(seqfeature_id, dbxref_id, rank + 1)
+
+    def _get_dbxref_id(self, db, accession):
+        """Get DB cross-reference for accession (PRIVATE).
+
+        Arguments:
+         - db - String, the name of the external database containing
+           the accession number
+         - accession - String, the accession of the dbxref data
+
+        Finds and returns the dbxref_id for the passed data.  The method
+        attempts to find an existing record first, and inserts the data
+        if there is no record.
+        """
+        # Check for an existing record
+        sql = "SELECT dbxref_id FROM dbxref WHERE dbname = %s AND accession = %s"
+        dbxref_id = self.adaptor.execute_and_fetch_col0(sql, (db, accession))
+        # If there was a record, return the dbxref_id, else create the
+        # record and return the created dbxref_id
+        if dbxref_id:
+            return dbxref_id[0]
+        return self._add_dbxref(db, accession, 0)
+
+    def _get_seqfeature_dbxref(self, seqfeature_id, dbxref_id, rank):
+        """Get DB cross-reference, creating it if needed (PRIVATE).
+
+        Check for a pre-existing seqfeature_dbxref entry with the passed
+        seqfeature_id and dbxref_id.  If one does not exist, insert new
+        data.
+        """
+        # Check for an existing record
+        sql = (
+            "SELECT seqfeature_id, dbxref_id FROM seqfeature_dbxref "
+            "WHERE seqfeature_id = %s AND dbxref_id = %s"
+        )
+        result = self.adaptor.execute_and_fetch_col0(sql, (seqfeature_id, dbxref_id))
+        # If there was a record, return without executing anything, else create
+        # the record and return
+        if result:
+            return result
+        return self._add_seqfeature_dbxref(seqfeature_id, dbxref_id, rank)
+
+    def _add_seqfeature_dbxref(self, seqfeature_id, dbxref_id, rank):
+        """Add DB cross-reference (PRIVATE).
+
+        Insert a seqfeature_dbxref row and return the seqfeature_id and
+        dbxref_id
+        """
+        sql = (
+            "INSERT INTO seqfeature_dbxref "
+            '(seqfeature_id, dbxref_id, "rank") VALUES'
+            "(%s, %s, %s)"
+        )
+        self.adaptor.execute(sql, (seqfeature_id, dbxref_id, rank))
+        return (seqfeature_id, dbxref_id)
+
+    def _load_dbxrefs(self, record, bioentry_id):
+        """Load any sequence level cross references into the database (PRIVATE).
+
+        See table bioentry_dbxref.
+        """
+        for rank, value in enumerate(record.dbxrefs):
+            # Split the DB:accession string at first colon.
+            # We have to cope with things like:
+            # "MGD:MGI:892" (db="MGD", accession="MGI:892")
+            # "GO:GO:123" (db="GO", accession="GO:123")
+            #
+            # Annoyingly I have seen the NCBI use both the style
+            # "GO:GO:123" and "GO:123" in different vintages.
+            newline_escape_count = value.count("\n")
+            if newline_escape_count != 0:
+                raise ValueError(
+                    "Expected a single line in value, got {newline_escape_count}"
+                )
+            try:
+                db, accession = value.split(":", 1)
+                db = db.strip()
+                accession = accession.strip()
+            except Exception:
+                raise ValueError(f"Parsing of dbxrefs list failed: '{value}'") from None
+            # Get the dbxref_id value for the dbxref data
+            dbxref_id = self._get_dbxref_id(db, accession)
+            # Insert the bioentry_dbxref  data
+            self._get_bioentry_dbxref(bioentry_id, dbxref_id, rank + 1)
+
+    def _get_bioentry_dbxref(self, bioentry_id, dbxref_id, rank):
+        """Get pre-existing db-xref, or create and return it (PRIVATE).
+
+        Check for a pre-existing bioentry_dbxref entry with the passed
+        seqfeature_id and dbxref_id.  If one does not exist, insert new
+        data
+        """
+        # Check for an existing record
+        sql = (
+            "SELECT bioentry_id, dbxref_id FROM bioentry_dbxref "
+            "WHERE bioentry_id = %s AND dbxref_id = %s"
+        )
+        result = self.adaptor.execute_and_fetch_col0(sql, (bioentry_id, dbxref_id))
+        # If there was a record, return without executing anything, else create
+        # the record and return
+        if result:
+            return result
+        return self._add_bioentry_dbxref(bioentry_id, dbxref_id, rank)
+
+    def _add_bioentry_dbxref(self, bioentry_id, dbxref_id, rank):
+        """Insert a bioentry_dbxref row (PRIVATE).
+
+        Returns the seqfeature_id and dbxref_id (PRIVATE).
+        """
+        sql = (
+            "INSERT INTO bioentry_dbxref "
+            '(bioentry_id,dbxref_id,"rank") VALUES '
+            "(%s, %s, %s)"
+        )
+        self.adaptor.execute(sql, (bioentry_id, dbxref_id, rank))
+        return (bioentry_id, dbxref_id)
+
+
+class DatabaseRemover:
+    """Complement the Loader functionality by fully removing a database.
+
+    This probably isn't really useful for normal purposes, since you
+    can just do a::
+
+        DROP DATABASE db_name
+
+    and then recreate the database. But, it's really useful for testing
+    purposes.
+    """
+
+    def __init__(self, adaptor, dbid):
+        """Initialize with a database id and adaptor connection."""
+        self.adaptor = adaptor
+        self.dbid = dbid
+
+    def remove(self):
+        """Remove everything related to the given database id."""
+        sql = "DELETE FROM bioentry WHERE biodatabase_id = %s"
+        self.adaptor.execute(sql, (self.dbid,))
+        sql = "DELETE FROM biodatabase WHERE biodatabase_id = %s"
+        self.adaptor.execute(sql, (self.dbid,))

.venv_haddock/lib/python3.12/site-packages/_distutils_hack/__init__.py

@@ -0,0 +1,239 @@
+# don't import any costly modules
+import os
+import sys
+
+report_url = (
+    "https://github.com/pypa/setuptools/issues/new?template=distutils-deprecation.yml"
+)
+
+
+def warn_distutils_present():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn(
+        "Distutils was imported before Setuptools, but importing Setuptools "
+        "also replaces the `distutils` module in `sys.modules`. This may lead "
+        "to undesirable behaviors or errors. To avoid these issues, avoid "
+        "using distutils directly, ensure that setuptools is installed in the "
+        "traditional way (e.g. not an editable install), and/or make sure "
+        "that setuptools is always imported before distutils."
+    )
+
+
+def clear_distutils():
+    if 'distutils' not in sys.modules:
+        return
+    import warnings
+
+    warnings.warn(
+        "Setuptools is replacing distutils. Support for replacing "
+        "an already imported distutils is deprecated. In the future, "
+        "this condition will fail. "
+        f"Register concerns at {report_url}"
+    )
+    mods = [
+        name
+        for name in sys.modules
+        if name == "distutils" or name.startswith("distutils.")
+    ]
+    for name in mods:
+        del sys.modules[name]
+
+
+def enabled():
+    """
+    Allow selection of distutils by environment variable.
+    """
+    which = os.environ.get('SETUPTOOLS_USE_DISTUTILS', 'local')
+    if which == 'stdlib':
+        import warnings
+
+        warnings.warn(
+            "Reliance on distutils from stdlib is deprecated. Users "
+            "must rely on setuptools to provide the distutils module. "
+            "Avoid importing distutils or import setuptools first, "
+            "and avoid setting SETUPTOOLS_USE_DISTUTILS=stdlib. "
+            f"Register concerns at {report_url}"
+        )
+    return which == 'local'
+
+
+def ensure_local_distutils():
+    import importlib
+
+    clear_distutils()
+
+    # With the DistutilsMetaFinder in place,
+    # perform an import to cause distutils to be
+    # loaded from setuptools._distutils. Ref #2906.
+    with shim():
+        importlib.import_module('distutils')
+
+    # check that submodules load as expected
+    core = importlib.import_module('distutils.core')
+    assert '_distutils' in core.__file__, core.__file__
+    assert 'setuptools._distutils.log' not in sys.modules
+
+
+def do_override():
+    """
+    Ensure that the local copy of distutils is preferred over stdlib.
+
+    See https://github.com/pypa/setuptools/issues/417#issuecomment-392298401
+    for more motivation.
+    """
+    if enabled():
+        warn_distutils_present()
+        ensure_local_distutils()
+
+
+class _TrivialRe:
+    def __init__(self, *patterns) -> None:
+        self._patterns = patterns
+
+    def match(self, string):
+        return all(pat in string for pat in self._patterns)
+
+
+class DistutilsMetaFinder:
+    def find_spec(self, fullname, path, target=None):
+        # optimization: only consider top level modules and those
+        # found in the CPython test suite.
+        if path is not None and not fullname.startswith('test.'):
+            return None
+
+        method_name = 'spec_for_{fullname}'.format(**locals())
+        method = getattr(self, method_name, lambda: None)
+        return method()
+
+    def spec_for_distutils(self):
+        if self.is_cpython():
+            return None
+
+        import importlib
+        import importlib.abc
+        import importlib.util
+
+        try:
+            mod = importlib.import_module('setuptools._distutils')
+        except Exception:
+            # There are a couple of cases where setuptools._distutils
+            # may not be present:
+            # - An older Setuptools without a local distutils is
+            #   taking precedence. Ref #2957.
+            # - Path manipulation during sitecustomize removes
+            #   setuptools from the path but only after the hook
+            #   has been loaded. Ref #2980.
+            # In either case, fall back to stdlib behavior.
+            return None
+
+        class DistutilsLoader(importlib.abc.Loader):
+            def create_module(self, spec):
+                mod.__name__ = 'distutils'
+                return mod
+
+            def exec_module(self, module):
+                pass
+
+        return importlib.util.spec_from_loader(
+            'distutils', DistutilsLoader(), origin=mod.__file__
+        )
+
+    @staticmethod
+    def is_cpython():
+        """
+        Suppress supplying distutils for CPython (build and tests).
+        Ref #2965 and #3007.
+        """
+        return os.path.isfile('pybuilddir.txt')
+
+    def spec_for_pip(self):
+        """
+        Ensure stdlib distutils when running under pip.
+        See pypa/pip#8761 for rationale.
+        """
+        if sys.version_info >= (3, 12) or self.pip_imported_during_build():
+            return
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    @classmethod
+    def pip_imported_during_build(cls):
+        """
+        Detect if pip is being imported in a build script. Ref #2355.
+        """
+        import traceback
+
+        return any(
+            cls.frame_file_is_setup(frame) for frame, line in traceback.walk_stack(None)
+        )
+
+    @staticmethod
+    def frame_file_is_setup(frame):
+        """
+        Return True if the indicated frame suggests a setup.py file.
+        """
+        # some frames may not have __file__ (#2940)
+        return frame.f_globals.get('__file__', '').endswith('setup.py')
+
+    def spec_for_sensitive_tests(self):
+        """
+        Ensure stdlib distutils when running select tests under CPython.
+
+        python/cpython#91169
+        """
+        clear_distutils()
+        self.spec_for_distutils = lambda: None
+
+    sensitive_tests = (
+        [
+            'test.test_distutils',
+            'test.test_peg_generator',
+            'test.test_importlib',
+        ]
+        if sys.version_info < (3, 10)
+        else [
+            'test.test_distutils',
+        ]
+    )
+
+
+for name in DistutilsMetaFinder.sensitive_tests:
+    setattr(
+        DistutilsMetaFinder,
+        f'spec_for_{name}',
+        DistutilsMetaFinder.spec_for_sensitive_tests,
+    )
+
+
+DISTUTILS_FINDER = DistutilsMetaFinder()
+
+
+def add_shim():
+    DISTUTILS_FINDER in sys.meta_path or insert_shim()
+
+
+class shim:
+    def __enter__(self) -> None:
+        insert_shim()
+
+    def __exit__(self, exc: object, value: object, tb: object) -> None:
+        _remove_shim()
+
+
+def insert_shim():
+    sys.meta_path.insert(0, DISTUTILS_FINDER)
+
+
+def _remove_shim():
+    try:
+        sys.meta_path.remove(DISTUTILS_FINDER)
+    except ValueError:
+        pass
+
+
+if sys.version_info < (3, 12):
+    # DistutilsMetaFinder can only be disabled in Python < 3.12 (PEP 632)
+    remove_shim = _remove_shim

.venv_haddock/lib/python3.12/site-packages/_distutils_hack/override.py

@@ -0,0 +1 @@
+__import__('_distutils_hack').do_override()

.venv_haddock/lib/python3.12/site-packages/biopython-1.87.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

.venv_haddock/lib/python3.12/site-packages/biopython-1.87.dist-info/METADATA

@@ -0,0 +1,323 @@
+Metadata-Version: 2.4
+Name: biopython
+Version: 1.87
+Summary: Freely available tools for computational molecular biology.
+Author-email: The Biopython Contributors <biopython@biopython.org>
+License-Expression: LicenseRef-Biopython-License-Agreement
+Project-URL: Homepage, https://biopython.org/
+Project-URL: Documentation, https://biopython.org/wiki/Documentation
+Project-URL: Source, https://github.com/biopython/biopython/
+Project-URL: Tracker, https://github.com/biopython/biopython/issues
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/x-rst
+License-File: LICENSE.rst
+Requires-Dist: numpy
+Dynamic: license-file
+
+.. image:: https://img.shields.io/pypi/v/biopython.svg?logo=pypi
+   :alt: Biopython on the Python Package Index (PyPI)
+   :target: https://pypi.python.org/pypi/biopython
+.. image:: https://img.shields.io/conda/vn/conda-forge/biopython.svg?logo=conda-forge
+   :alt: Biopython on the Conda package conda-forge channel
+   :target: https://anaconda.org/conda-forge/biopython
+.. image:: https://results.pre-commit.ci/badge/github/biopython/biopython/master.svg
+   :target: https://results.pre-commit.ci/latest/github/biopython/biopython/master
+   :alt: pre-commit.ci status
+.. image:: https://img.shields.io/circleci/build/github/biopython/biopython.svg?logo=circleci
+   :alt: Linux testing with CircleCI
+   :target: https://app.circleci.com/pipelines/github/biopython/biopython
+.. image:: https://img.shields.io/appveyor/ci/biopython/biopython/master.svg?logo=appveyor
+   :alt: Windows testing with AppVeyor
+   :target: https://ci.appveyor.com/project/biopython/biopython/history
+.. image:: https://img.shields.io/github/actions/workflow/status/biopython/biopython/ci.yml?logo=github-actions
+   :alt: GitHub workflow status
+   :target: https://github.com/biopython/biopython/actions
+.. image:: https://img.shields.io/codecov/c/github/biopython/biopython/master.svg?logo=codecov
+   :alt: Test coverage on CodeCov
+   :target: https://codecov.io/github/biopython/biopython/
+.. image:: https://depsy.org/api/package/pypi/biopython/badge.svg
+   :alt: Research software impact on Depsy
+   :target: https://depsy.org/package/python/biopython
+
+.. image:: https://github.com/biopython/biopython/raw/master/Doc/images/biopython_logo_m.png
+   :alt: The Biopython Project
+   :target: https://biopython.org
+
+Biopython README file
+=====================
+
+The Biopython Project is an international association of developers of freely
+available Python tools for computational molecular biology.
+
+This README file is intended primarily for people interested in working
+with the Biopython source code, either one of the releases from the
+https://biopython.org website, or from our repository on GitHub
+https://github.com/biopython/biopython
+
+Our user-centric documentation, `The Biopython Tutorial and Cookbook, and API
+documentation <https://biopython.org/docs/latest/>`_, is generated from our
+repository using Sphinx.
+
+The `NEWS <https://github.com/biopython/biopython/blob/master/NEWS.rst>`_
+file summarises the changes in each release of Biopython, alongside the
+`DEPRECATED
+<https://github.com/biopython/biopython/blob/master/DEPRECATED.rst>`_
+file which notes API breakages.
+
+The Biopython package is open source software made available under generous
+terms. Please see the `LICENSE
+<https://github.com/biopython/biopython/blob/master/LICENSE.rst>`_ file for
+further details.
+
+If you use Biopython in work contributing to a scientific publication, we ask
+that you cite our application note (below) or one of the module specific
+publications (listed on our website):
+
+Cock, P.J.A. et al. Biopython: freely available Python tools for computational
+molecular biology and bioinformatics. Bioinformatics 2009 Jun 1; 25(11) 1422-3
+https://doi.org/10.1093/bioinformatics/btp163 pmid:19304878
+
+
+For the impatient
+=================
+
+Python includes the package management system "pip" which should allow you to
+install Biopython (and its dependency NumPy if needed), upgrade or uninstall
+with just one terminal command::
+
+    pip install biopython
+    pip install --upgrade biopython
+    pip uninstall biopython
+
+Since Biopython 1.70 we have provided pre-compiled binary wheel packages on
+PyPI for Linux, macOS and Windows. This means pip install should be quick,
+and not require a compiler.
+
+As a developer or potential contributor, you may wish to download, build and
+install Biopython yourself. This is described below.
+
+
+Python Requirements
+===================
+
+We currently recommend using Python 3.13 from https://www.python.org
+
+Biopython is currently supported and tested on the following Python
+implementations:
+
+- Python 3.10, 3.11, 3.12, 3.13 and 3.14 -- see https://www.python.org
+
+- PyPy3.10 v7.3.17 -- or later, see https://www.pypy.org
+
+
+Optional Dependencies
+=====================
+
+Biopython requires NumPy (see https://www.numpy.org) which will be installed
+automatically if you install Biopython with pip (see below for compiling
+Biopython yourself).
+
+Depending on which parts of Biopython you plan to use, there are a number of
+other optional Python dependencies, which can be installed later if needed:
+
+- ReportLab, see https://www.reportlab.com/opensource/ (optional)
+  This package is only used in ``Bio.Graphics``, so if you do not need this
+  functionality, you will not need to install this package.
+
+- matplotlib, see https://matplotlib.org/ (optional)
+  ``Bio.Phylo`` uses this package to plot phylogenetic trees.
+
+- networkx, see https://networkx.github.io/ (optional) and
+  pygraphviz or pydot, see https://pygraphviz.github.io/ and
+  https://code.google.com/p/pydot/ (optional)
+  These packages are used for certain niche functions in ``Bio.Phylo``.
+
+- rdflib, see https://github.com/RDFLib/rdflib (optional)
+  This package is used in the CDAO parser under ``Bio.Phylo``.
+
+- psycopg2, see https://initd.org/psycopg/ (optional) or
+  PyGreSQL (pgdb), see https://www.pygresql.org/ (optional)
+  These packages are used by ``BioSQL`` to access a PostgreSQL database.
+
+- MySQL Connector/Python, see https://dev.mysql.com/downloads/connector/python/
+  This package is used by ``BioSQL`` to access a MySQL database, and is
+  supported on PyPy too.
+
+- mysqlclient, see https://github.com/PyMySQL/mysqlclient-python (optional)
+  This is a fork of the older MySQLdb and is used by ``BioSQL`` to access a
+  MySQL database. It is supported by PyPy.
+
+In addition there are a number of useful third party tools you may wish to
+install such as standalone NCBI BLAST, EMBOSS or ClustalW.
+
+
+Installation From Source
+========================
+
+We recommend using the pre-compiled binary wheels available on PyPI using::
+
+    pip install biopython
+
+However, if you need to compile Biopython yourself, the following are required
+at compile time:
+
+- Python including development header files like ``python.h``, which on Linux
+  are often not installed by default (trying looking for and installing a
+  package named ``python-dev`` or ``python-devel`` as well as the ``python``
+  package).
+
+- Appropriate C compiler for your version of Python, for example GCC on Linux,
+  or MSVC on Windows. For Windows, you must install the 'Visual Studio Build Tools'
+  and select the 'Desktop development with C++' workload. For macOS, use Apple's
+  command line tools, which can be installed with the terminal command::
+
+      xcode-select --install
+
+  This will offer to install Apple's XCode development suite - you can, but it
+  is not needed and takes a lot of disk space.
+
+Then either download and decompress our source code, or fetch it using git.
+Now change directory to the Biopython source code folder and run::
+
+    pip install -e . --group dev
+    cd Tests
+    python run_tests.py
+
+Substitute ``python`` with your specific version if required, for example
+``python3``, or ``pypy3``.
+
+To exclude tests that require an internet connection (and which may take a
+long time), use the ``--offline`` option::
+
+    cd Tests
+    python run_tests.py --offline
+
+Testing
+=======
+
+Biopython includes a suite of regression tests to check if everything is
+running correctly. To run the tests, go to the biopython source code
+directory and type::
+
+    pip install -e . --group dev
+    cd Tests
+    python run_tests.py
+
+If you want to skip the online tests (which is recommended when doing repeated
+testing), use::
+
+    cd Tests
+    python run_tests.py --offline
+
+Do not panic if you see messages warning of skipped tests::
+
+    test_DocSQL ... skipping. Install MySQLdb if you want to use Bio.DocSQL.
+
+This most likely means that a package is not installed.  You can
+ignore this if it occurs in the tests for a module that you were not
+planning on using.  If you did want to use that module, please install
+the required dependency and re-run the tests.
+
+Some of the tests may fail due to network issues, this is often down to
+chance or a service outage. If the problem does not go away on
+re-running the tests, you can use the ``--offline`` option.
+
+There is more testing information in the Biopython Tutorial & Cookbook.
+
+
+Experimental code
+=================
+
+Biopython 1.61 introduced a new warning, ``Bio.BiopythonExperimentalWarning``,
+which is used to mark any experimental code included in the otherwise
+stable Biopython releases. Such 'beta' level code is ready for wider
+testing, but still likely to change, and should only be tried by early
+adopters in order to give feedback via the biopython-dev mailing list.
+
+We'd expect such experimental code to reach stable status within one or two
+releases, at which point our normal policies about trying to preserve
+backwards compatibility would apply.
+
+
+Bugs
+====
+
+While we try to ship a robust package, bugs inevitably pop up.  If you are
+having problems that might be caused by a bug in Biopython, it is possible
+that it has already been identified. Update to the latest release if you are
+not using it already, and retry. If the problem persists, please search our
+bug database and our mailing lists to see if it has already been reported
+(and hopefully fixed), and if not please do report the bug. We can't fix
+problems we don't know about ;)
+
+Issue tracker: https://github.com/biopython/biopython/issues
+
+If you suspect the problem lies within a parser, it is likely that the data
+format has changed and broken the parsing code.  (The text BLAST and GenBank
+formats seem to be particularly fragile.)  Thus, the parsing code in
+Biopython is sometimes updated faster than we can build Biopython releases.
+You can get the most recent parser by pulling the relevant files (e.g. the
+ones in ``Bio.SeqIO`` or ``Bio.Blast``) from our git repository. However, be
+careful when doing this, because the code in github is not as well-tested
+as released code, and may contain new dependencies.
+
+In any bug report, please let us know:
+
+1. Which operating system and hardware (32 bit or 64 bit) you are using
+2. Python version
+3. Biopython version (or git commit/date)
+4. Traceback that occurs (the full error message)
+
+And also ideally:
+
+5. Example code that breaks
+6. A data file that causes the problem
+
+
+Contributing, Bug Reports
+=========================
+
+Biopython is run by volunteers from all over the world, with many types of
+backgrounds. We are always looking for people interested in helping with code
+development, web-site management, documentation writing, technical
+administration, and whatever else comes up.
+
+If you wish to contribute, please first read `CONTRIBUTING.rst
+<https://github.com/biopython/biopython/blob/master/CONTRIBUTING.rst>`_ here,
+visit our web site https://biopython.org and join our mailing list:
+https://biopython.org/wiki/Mailing_lists
+
+
+Distribution Structure
+======================
+
+- ``README.rst``  -- This file.
+- ``NEWS.rst``    -- Release notes and news.
+- ``LICENSE.rst`` -- What you can do with the code.
+- ``CONTRIB.rst`` -- An (incomplete) list of people who helped Biopython in
+  one way or another.
+- ``CONTRIBUTING.rst`` -- An overview about how to contribute to Biopython.
+- ``DEPRECATED.rst`` -- Contains information about modules in Biopython that
+  were removed or no longer recommended for use, and how to update code that
+  uses those modules.
+- ``MANIFEST.in`` -- Configures which files to include in releases.
+- ``pyproject.toml`` -- Project metadata and build configuration.
+- ``Bio/``        -- The main code base code.
+- ``BioSQL/``     -- Code for using Biopython with BioSQL databases.
+- ``Doc/``        -- Documentation.
+- ``Scripts/``    -- Miscellaneous, possibly useful, standalone scripts.
+- ``Tests/``      -- Regression testing code including sample data files.

.venv_haddock/lib/python3.12/site-packages/biopython-1.87.dist-info/RECORD

@@ -0,0 +1,958 @@
+Bio/Affy/CelFile.py,sha256=-6lVGx7aOb7Re6fZUihtfoUSk0KGfdtTFvY7BvrIXS0,23598
+Bio/Affy/__init__.py,sha256=uM4tj7wOTHWfkae1s65HLs_FVthj_s1HZGpE1dAIUIM,296
+Bio/Affy/__pycache__/CelFile.cpython-312.pyc,,
+Bio/Affy/__pycache__/__init__.cpython-312.pyc,,
+Bio/Align/AlignInfo.py,sha256=z9F530E2KbSs6HAMtF2g-pE33Csor-eh3F2C6f3V3z4,1714
+Bio/Align/__init__.py,sha256=cl5F7qDBgJngolxpWPGGNJ0rPLaHxSR4v9ZQz89rneQ,196531
+Bio/Align/__pycache__/AlignInfo.cpython-312.pyc,,
+Bio/Align/__pycache__/__init__.cpython-312.pyc,,
+Bio/Align/__pycache__/a2m.cpython-312.pyc,,
+Bio/Align/__pycache__/analysis.cpython-312.pyc,,
+Bio/Align/__pycache__/bed.cpython-312.pyc,,
+Bio/Align/__pycache__/bigbed.cpython-312.pyc,,
+Bio/Align/__pycache__/bigmaf.cpython-312.pyc,,
+Bio/Align/__pycache__/bigpsl.cpython-312.pyc,,
+Bio/Align/__pycache__/chain.cpython-312.pyc,,
+Bio/Align/__pycache__/clustal.cpython-312.pyc,,
+Bio/Align/__pycache__/emboss.cpython-312.pyc,,
+Bio/Align/__pycache__/exonerate.cpython-312.pyc,,
+Bio/Align/__pycache__/fasta.cpython-312.pyc,,
+Bio/Align/__pycache__/hhr.cpython-312.pyc,,
+Bio/Align/__pycache__/interfaces.cpython-312.pyc,,
+Bio/Align/__pycache__/maf.cpython-312.pyc,,
+Bio/Align/__pycache__/mauve.cpython-312.pyc,,
+Bio/Align/__pycache__/msf.cpython-312.pyc,,
+Bio/Align/__pycache__/nexus.cpython-312.pyc,,
+Bio/Align/__pycache__/phylip.cpython-312.pyc,,
+Bio/Align/__pycache__/psl.cpython-312.pyc,,
+Bio/Align/__pycache__/sam.cpython-312.pyc,,
+Bio/Align/__pycache__/stockholm.cpython-312.pyc,,
+Bio/Align/__pycache__/tabular.cpython-312.pyc,,
+Bio/Align/_aligncore.c,sha256=XIFP1a7-IovM8IUSb2zFtqfvp1OISfK_lU4mAIS5huw,14084
+Bio/Align/_aligncore.cpython-312-darwin.so,sha256=CqgWKJ0dmdMz9nLE4AW4AuPsa6ckryUbP9-B7cVBKHc,52592
+Bio/Align/_alignmentcounts.c,sha256=OZzqyjbhB2f4wDYqJtBsGXl7HPEIDA7h2gr2kSRSufs,70159
+Bio/Align/_alignmentcounts.cpython-312-darwin.so,sha256=ZAx4hIxKXrYtszxKXo8F_dVCgWAUQpYOx4C6vfzjecE,62216
+Bio/Align/_codonaligner.c,sha256=Yq8HKUntswz7OI20b5sMKlW4YPI4c4nKLxS9TrzFRPc,33299
+Bio/Align/_codonaligner.cpython-312-darwin.so,sha256=w5vQsGg0wZgnigiaZo69R0LlHTadteOdLkldaTq8HXA,57840
+Bio/Align/_pairwisealigner.c,sha256=5kcA0dz-YI-pn_ZeJQDXxlSLTcaQOTkNMmyfuECTUU4,273667
+Bio/Align/_pairwisealigner.cpython-312-darwin.so,sha256=NFkrWHKNxEYXShwmZR-uEo9ZDrPmgBvPky8pqCQgqVY,191432
+Bio/Align/_pairwisealigner.h,sha256=b_VTM2cB46jSDCeEws70HvU2dP5XL7GV_VTILzyzXsw,1917
+Bio/Align/a2m.py,sha256=LMR8M-hMLn42kGjTf6RJe9UHhzsDFsXGS6MODo016ag,4523
+Bio/Align/analysis.py,sha256=HM0zy_rDcXD-zXtOe4SFTIpEGEE7Og2bg5S3rwOWHoA,46214
+Bio/Align/bed.py,sha256=8DPKzBfnQkoDfkHi2y_pTraYUZNmEQAICshbVa6-M68,9932
+Bio/Align/bigbed.py,sha256=cH5UxRqdM98LLjNy4cXLz8PaYOevxfJvzzWyFlpCrEc,81937
+Bio/Align/bigmaf.py,sha256=NUgveu9XTH8_xNhH8bl4N4fNU0iiCkvTsYAaqeNv4Zc,13708
+Bio/Align/bigpsl.py,sha256=bdPyWjvJo4zloR_aipbIENckQYw7zTbufgirKFCSX3g,23416
+Bio/Align/chain.py,sha256=e5vhCM0bu_k6egGhIsqMNBQvAVC_onMfz60p6FDsvZs,9448
+Bio/Align/clustal.py,sha256=MAbn8dfDqZblya_LGUsm0xxw5ycrVXnjU2ajN8zADks,9298
+Bio/Align/emboss.py,sha256=KIURqXKSAmD5a4etWkLt0HKI7BTm5lzCN0ceDvPJRO8,10387
+Bio/Align/exonerate.py,sha256=xJkeDnuVX-XbSn1fF6JnLXxx6_dAHnsHD35Gn_tpypo,26538
+Bio/Align/fasta.py,sha256=zkJ7TpdQunqs8n83YZWMgGHgKpND6BE5UnUJykLnxrk,3141
+Bio/Align/hhr.py,sha256=QySsXM_4Tu_2rrXNf0JGVomd5Ee9tY7t-ADib-I361A,9503
+Bio/Align/interfaces.py,sha256=NmSP7FwXmC7_WTk9Rk98Ie3qhSYpSDymD8IbWmf9kMc,12461
+Bio/Align/maf.py,sha256=qN51GXqk-7L38rsbgpdViNFRr2bP-jZC3NXPIJyJ774,18139
+Bio/Align/mauve.py,sha256=1SH9HSCXqSoOEGUSiKZ6mxZ1hW-RQz55X_F_DU2UvLo,10056
+Bio/Align/msf.py,sha256=UdoJ8cJlw0SWtP24oLi3NC2xZJ3YceqO50IJNzCuH6Y,9481
+Bio/Align/nexus.py,sha256=VxWzBEa7jLnHB_UjyfFpswK3CEuzAbSAH3n6jXfPv2E,7330
+Bio/Align/phylip.py,sha256=YoACjXqfB7aM_MJvhZM4UmLyoQGnzs5UniycGII6J9Y,6401
+Bio/Align/psl.py,sha256=F3aBFmusMF4TqJaojQAOiOSCIM3jfyrOj9ryJvlcAxg,22119
+Bio/Align/sam.py,sha256=0X6JI8-QxRs1QvWSefFyudBKWnDgB-eA-yvNMxUmj1Q,30565
+Bio/Align/stockholm.py,sha256=hIZ5RFxiMip8xPLFGol2x7MTiLlqLfcKQCeflMj4IIg,26134
+Bio/Align/substitution_matrices/__init__.py,sha256=jflADnCmma97h44cuazElfuYA19-LQm-yLxdCa_Oj4k,17563
+Bio/Align/substitution_matrices/__pycache__/__init__.cpython-312.pyc,,
+Bio/Align/substitution_matrices/_arraycore.c,sha256=wYyNgHpXhEB0Y3S1cud7rcot8ZEjbPPDvkWSOcRzmj0,7958
+Bio/Align/substitution_matrices/_arraycore.cpython-312-darwin.so,sha256=qXYdfIFK0QdwQojfT1XPjVn_27SQ715X6qJs2TXvxQE,52224
+Bio/Align/substitution_matrices/_arraycore.h,sha256=kHkxjHuShJGv6RUADE-KISnbenfO1c3jj5uldPAuPM0,102
+Bio/Align/substitution_matrices/data/BENNER22,sha256=pLCoTJDekvb473IF0amcjRMUsl8UVZvg3TZ5mmfdwLw,2387
+Bio/Align/substitution_matrices/data/BENNER6,sha256=80wckPQPTG6Tuxa-wn1uD8-PWj1gQB9HpZpzSiH-cjk,2387
+Bio/Align/substitution_matrices/data/BENNER74,sha256=XhMG7539bm3wQ7ELNKxYBDxr8hB5GlA-MXrIQJKXjZw,2387
+Bio/Align/substitution_matrices/data/BLASTN,sha256=Dbn4BDSPOvF09mpiAsnAquB6uAcmxNT8a24y8KnEHgA,1715
+Bio/Align/substitution_matrices/data/BLASTP,sha256=Y3PzICgVynftfFWSw1ljW2zHozHX5CXQ86L6E2ywnRc,4009
+Bio/Align/substitution_matrices/data/BLOSUM45,sha256=GaB31QYKlKYhKtYJ3zA6JARjhzppaU6fV2xXYvv_2wk,2122
+Bio/Align/substitution_matrices/data/BLOSUM50,sha256=oVLjC4r8q0IoH_hgS8UTWL6YJTFV_eYq4gcHgFoNPWc,2122
+Bio/Align/substitution_matrices/data/BLOSUM62,sha256=hVENOEbubV9HeOQlz42vbg27iJswby0TQ04SVHgO-0A,2122
+Bio/Align/substitution_matrices/data/BLOSUM80,sha256=LllxdrgJKAi6GZz8nYDcjWV7Wj5QFd-4HVVyhYGc4Yc,2124
+Bio/Align/substitution_matrices/data/BLOSUM90,sha256=TebOIl7Y7oTgQcT2PC2vL0Oqhs3RsSCGgHTchJXHIU8,2122
+Bio/Align/substitution_matrices/data/DAYHOFF,sha256=f-YLd7bROKNeBoi9hRO-CP4mMUwxRXB9MWt6QyccTyM,2451
+Bio/Align/substitution_matrices/data/FENG,sha256=G8s8SLX2aFQlUkZ7ZCjxSh4SToY3PSkcuiRK_HsF1m0,1120
+Bio/Align/substitution_matrices/data/GENETIC,sha256=6gpGJV6X2xl6rmBBqiFKQDGOWsiNfXE-9bia767Ci7I,2380
+Bio/Align/substitution_matrices/data/GONNET1992,sha256=JwpOMtw7Z9b4KSikBiuPzm_0ievvE4iJ-HRn7echzic,2351
+Bio/Align/substitution_matrices/data/HOXD70,sha256=gRhfiXDqmcnwCUYEKC2oOCaDI9La-1MM1m9lBa_KVA0,275
+Bio/Align/substitution_matrices/data/JOHNSON,sha256=PRZBltCi7f8QFWKFZvo4sMgTbzJ_VNA3aMa125BohME,2818
+Bio/Align/substitution_matrices/data/JONES,sha256=uUzz4ilD3P85EYrgnReDgmKiH0Jb84_XG_Gmh6jQBEw,2413
+Bio/Align/substitution_matrices/data/LEVIN,sha256=lHAFw0KjmBdDbvyy8_XUNWZ_pFdQ8MuAZ0y1--GlAsc,1542
+Bio/Align/substitution_matrices/data/MCLACHLAN,sha256=OAHsc-AezSkvUgZlTv8ikxXGoi-ePAQQNdf1EIBKJ18,1092
+Bio/Align/substitution_matrices/data/MDM78,sha256=tv145JMZpAo6wD0pUYd-bGMouv4gHqq6KEUKX3oqe-U,2859
+Bio/Align/substitution_matrices/data/MEGABLAST,sha256=vxn1KrNl43MAP29eNuBhpXOm8hMmgIRjlE6gilxhgq4,1730
+Bio/Align/substitution_matrices/data/NUC.4.4,sha256=xgPkb5oVn7RRYyzfn5xoe659qtsw-yZF9f0Jys5wdJA,1171
+Bio/Align/substitution_matrices/data/PAM250,sha256=k2zF7yPgJixf2vdNXYH1iEjrdMyg1b7w85bSexaJcE4,2068
+Bio/Align/substitution_matrices/data/PAM30,sha256=j8VojReY4jJuqzcZue6SmZUqIMlDTkxVKL9FMuRYbmM,2666
+Bio/Align/substitution_matrices/data/PAM70,sha256=0YDiLYDyWtpBLW62MHD-cifJVHxmc3Jykf2bLUUpRuU,2666
+Bio/Align/substitution_matrices/data/RAO,sha256=s3vlt4JrQenqxkgtEPYfKmZDxZpfMUGrQ279nLVe1l4,1581
+Bio/Align/substitution_matrices/data/RISLER,sha256=RcTVfz3ex_pS8P-7vhOBXyk3HtqeTP8hJa3mi2lC1s0,2456
+Bio/Align/substitution_matrices/data/SCHNEIDER,sha256=YCM7j6uEsY44G7VztWNWqRFbJ4GN92dlvYeHvewtfEk,25459
+Bio/Align/substitution_matrices/data/STR,sha256=0Nn1oAYAgB1uNfZh--Zh3wgq71ksh0DbED-JBO22Nsk,1543
+Bio/Align/substitution_matrices/data/TRANS,sha256=M2lqFdEQTolEvHho6h8yT_a79oN3Y_SKbs9eV12MTS0,402
+Bio/Align/tabular.py,sha256=mGGJMxaGuHif_DkDNZF1VK9X_gLuFUzG8UrxhW5Zngg,16525
+Bio/AlignIO/ClustalIO.py,sha256=B9VI8tsp9423ehMUQeyYH-0caAuX-wqG5O6PSJ-WQUc,12152
+Bio/AlignIO/EmbossIO.py,sha256=ZmqRN385EVqpCPZd8Il_68pXVLTv3Wqjv_GjYv100X4,8749
+Bio/AlignIO/FastaIO.py,sha256=NW_pTDRqLIpuj8Uqln-IwduoP278Lrl7msItgQTxfP4,13355
+Bio/AlignIO/Interfaces.py,sha256=KgbcHY8FscYiHZzqCsC6kaRWZC21fXXhUzXK67DFKPQ,5598
+Bio/AlignIO/MafIO.py,sha256=nWxfIWTNoApKks0kjqWwXFDhy6LBLbhX2ed1ChxYjAs,35258
+Bio/AlignIO/MauveIO.py,sha256=EFDGlFzbG4rdjXEkqIGYIyOICxy2LtqChVgtFxoczX4,13300
+Bio/AlignIO/MsfIO.py,sha256=nYDa0UogWSyHNRL9scivzipgttnigJkL9yhPq2RnR7s,14209
+Bio/AlignIO/NexusIO.py,sha256=NXaVyjNuGC2RF6WBHis6P4ho2Xr4u4klem6c5rEDd7k,6226
+Bio/AlignIO/PhylipIO.py,sha256=9dkxgR-Z6UjehL-QayqbUSEdMZq6yZUCu2zTsUYQbVw,17138
+Bio/AlignIO/StockholmIO.py,sha256=PslgEcwyFLaXmk2gxgvleNS6Tw_rwWLs_VviQda717I,26397
+Bio/AlignIO/__init__.py,sha256=H6m587Wlij96BjMY06G4x2Y2RgKoDkIbuojrlKFwKqk,18499
+Bio/AlignIO/__pycache__/ClustalIO.cpython-312.pyc,,
+Bio/AlignIO/__pycache__/EmbossIO.cpython-312.pyc,,
+Bio/AlignIO/__pycache__/FastaIO.cpython-312.pyc,,
+Bio/AlignIO/__pycache__/Interfaces.cpython-312.pyc,,
+Bio/AlignIO/__pycache__/MafIO.cpython-312.pyc,,
+Bio/AlignIO/__pycache__/MauveIO.cpython-312.pyc,,
+Bio/AlignIO/__pycache__/MsfIO.cpython-312.pyc,,
+Bio/AlignIO/__pycache__/NexusIO.cpython-312.pyc,,
+Bio/AlignIO/__pycache__/PhylipIO.cpython-312.pyc,,
+Bio/AlignIO/__pycache__/StockholmIO.cpython-312.pyc,,
+Bio/AlignIO/__pycache__/__init__.cpython-312.pyc,,
+Bio/Alphabet/__init__.py,sha256=dSLKJHXBnpVSwhn0CI4lngrjIbs40_dxTVkE5W4DnQg,1201
+Bio/Alphabet/__pycache__/__init__.cpython-312.pyc,,
+Bio/Blast/NCBIWWW.py,sha256=k8ObKV4kRbI2nAWEvYsAs_tZUA7kg7Q1lv_cNI7lPFI,14116
+Bio/Blast/NCBIXML.py,sha256=L52ZDPr62nO90Sh9d9gzxL4qGbNX1cswwWTAE5reccI,49592
+Bio/Blast/__init__.py,sha256=D-8BGE2SU2a2Os-HFnA133jn95Pgwuyfokt6pVi4Ukc,51446
+Bio/Blast/__pycache__/NCBIWWW.cpython-312.pyc,,
+Bio/Blast/__pycache__/NCBIXML.cpython-312.pyc,,
+Bio/Blast/__pycache__/__init__.cpython-312.pyc,,
+Bio/Blast/__pycache__/_parser.cpython-312.pyc,,
+Bio/Blast/__pycache__/_writers.cpython-312.pyc,,
+Bio/Blast/_parser.py,sha256=YYR-pSbWviWWVbIKcgtWdKlA42sYSruUn-6W2C5QRMQ,41609
+Bio/Blast/_writers.py,sha256=0pwXM4JQdV88zb_sIthZbjPJ3sxre49jpnaV2GzFRqc,39674
+Bio/CAPS/__init__.py,sha256=LyarDVqCzvIEsas4MsIVFyWWrbRDqf6K0bq7bUPWuss,4111
+Bio/CAPS/__pycache__/__init__.cpython-312.pyc,,
+Bio/Cluster/__init__.py,sha256=K9m6A-Yyh3UiA-VHNtGi66TXCu1KYe14hZvkyhjRDXg,50617
+Bio/Cluster/__pycache__/__init__.cpython-312.pyc,,
+Bio/Cluster/_cluster.cpython-312-darwin.so,sha256=bk_9F47SP0tJqR5odPEoBev1Au2QAKn-FTZd-gazOpA,145344
+Bio/Cluster/cluster.c,sha256=rImdaSesCaORbsowXmNQhjpSfh9SRJYTrpCRAjfxsos,169419
+Bio/Cluster/cluster.h,sha256=vjyDYtx1pHJzqM-Xz-kD7-h-nfaj3ncAhluusi6b6Nw,4135
+Bio/Cluster/clustermodule.c,sha256=1g0TlzhRenMPYaHiawzGRbT8B2bx2ud_ubYfLE7pntM,78475
+Bio/Compass/__init__.py,sha256=9erbso1s0178fUpE20wNxxRk4a6I3WkhvikNFima6ZE,6954
+Bio/Compass/__pycache__/__init__.cpython-312.pyc,,
+Bio/Data/CodonTable.py,sha256=gQKGwPyW3wqFPdEXiBRZXP8fOcsJYCn5VGRjdG8UkrQ,50509
+Bio/Data/IUPACData.py,sha256=iX-0LxvW4_g3vmkYrmxU535hATsoTLq9Tn38AXI-GpE,9223
+Bio/Data/PDBData.py,sha256=eg1XGcbzZKKzjYipAGg_Hu7Gf8ZBuVEcO2a5AKC-C4s,22894
+Bio/Data/__init__.py,sha256=O1j0QX2yYPYShUh2AkuTlamT0-p0fLWN9UqxB0nI10U,353
+Bio/Data/__pycache__/CodonTable.cpython-312.pyc,,
+Bio/Data/__pycache__/IUPACData.cpython-312.pyc,,
+Bio/Data/__pycache__/PDBData.cpython-312.pyc,,
+Bio/Data/__pycache__/__init__.cpython-312.pyc,,
+Bio/Emboss/Primer3.py,sha256=HSXIA9kRIBB3usGm3klOtKM--GmuuBMiYfmBvXX04UQ,5576
+Bio/Emboss/PrimerSearch.py,sha256=06js3szg1IXXvH_1KjiKOvNLv02yAmzS31j9sRPwhVE,2521
+Bio/Emboss/__init__.py,sha256=COuy4yEwiWplMnGIdXhrQlAIcxsnTA4NGQiHNf-sOH4,355
+Bio/Emboss/__pycache__/Primer3.cpython-312.pyc,,
+Bio/Emboss/__pycache__/PrimerSearch.cpython-312.pyc,,
+Bio/Emboss/__pycache__/__init__.cpython-312.pyc,,
+Bio/Entrez/DTDs/BITS-embedded-index2.ent,sha256=HdPxOSvsisukxE7_pma4EjFks-IyF7wIxM7w4PxMc3I,16498
+Bio/Entrez/DTDs/BITS-question-answer2.ent,sha256=AijL9jgSolxyUWIjrolhKCJyRbxzlUe__iHEMpRfgP4,26770
+Bio/Entrez/DTDs/Docsum_3_0.dtd,sha256=7ZGcRICWuGjRBLhEUfA3JLDyncXxzkM29-jFler0NSw,660
+Bio/Entrez/DTDs/Docsum_3_0.mod.dtd,sha256=jTAG4Mgbc1UMwUfjHfWHm1HmpANnD7MBfQFbmT6Yps8,33675
+Bio/Entrez/DTDs/Docsum_3_1.dtd,sha256=I8oC3ye63BK1LQHPF1tO_Hzf19lAjWYBpJr4ZnmYLvg,660
+Bio/Entrez/DTDs/Docsum_3_1.mod.dtd,sha256=CW-GuJb2W_SKpeAISZRPN_JDrL54AGwVV5pHF78AV10,33691
+Bio/Entrez/DTDs/Docsum_3_2.dtd,sha256=Y1Ar3m3bMggIlB1pAWi04mWSq7e9SeA9P2UBGbd68Sg,660
+Bio/Entrez/DTDs/Docsum_3_2.mod.dtd,sha256=xCXs81yq14ssk6YYPAdf3da_xdmarTkMweNlyIYtFSo,36007
+Bio/Entrez/DTDs/Docsum_3_3.dtd,sha256=7fpkqJthafb1WFmA84XzqGYURoblfd4x4AxyC9h8qOk,660
+Bio/Entrez/DTDs/Docsum_3_3.mod.dtd,sha256=TWoPWXJq_opkfQCMhKMDLPyCzh2EYALKPu2L2-1c0cA,41304
+Bio/Entrez/DTDs/Docsum_3_4.dtd,sha256=h2_g2ihfHHTZig0Uo7KX4hxLnxFPIexbtogTqfH_nwk,660
+Bio/Entrez/DTDs/Docsum_3_4.mod.dtd,sha256=IS9RllcI91GHGDnSrLn3sMrltu-RdpIWgwiTzyTM9cA,41537
+Bio/Entrez/DTDs/EMBL_General.dtd,sha256=Aq63w9Awp4caUK-H3ibEkX6L8_sNWNcyxTMQvPTqxC4,792
+Bio/Entrez/DTDs/EMBL_General.mod.dtd,sha256=7qr0rLYAFronVM0Ty1GZXHkEK1rGDjAf_hFkrp0Er94,2871
+Bio/Entrez/DTDs/GenBank_General.dtd,sha256=XhHIWzgaltizgo3j7DOvoF1h4phLjIZytcd0QTwOJq4,807
+Bio/Entrez/DTDs/GenBank_General.mod.dtd,sha256=pNW5YNvmpP9yHP4WTE0YzwUzrubtxQBsp6jJm8mwyI8,1743
+Bio/Entrez/DTDs/HomoloGene.dtd,sha256=B1d7yMAYc8rB37Rz2ZHKnDDbOiAoaIVwh3U-hAvpp5c,3500
+Bio/Entrez/DTDs/HomoloGene.mod.dtd,sha256=j4UTVS0E063j9Ua6J6xDLKq51MtP8UwwC9EyKpvK0ro,6460
+Bio/Entrez/DTDs/INSD_INSDSeq.dtd,sha256=bhpy5ifC60JR388lQzYuZ66SdQMEADaVCaxaoy-iJus,671
+Bio/Entrez/DTDs/INSD_INSDSeq.mod.dtd,sha256=j74Wtsl0pIV6uyYoTMclFsybwkoi6KtNEQqb16NVSv4,14705
+Bio/Entrez/DTDs/JATS-XHTMLtablesetup1-3.ent,sha256=mZdLRl62Vz55Lkw5SkaxR8QNk_ZQOJQGyxBG6v2iaVo,31246
+Bio/Entrez/DTDs/JATS-ali-namespace1-3.ent,sha256=BA2fFqwQ32iY1Jh6p60iXnJVFBvj7B9YOH5npwIM8jU,15260
+Bio/Entrez/DTDs/JATS-archivearticle1-3-mathml3.dtd,sha256=Og8oTSuf4-3NCCVTO_qsDVYL6QSIX7iWm9M5sPqX_SM,51353
+Bio/Entrez/DTDs/JATS-archivecustom-classes1-3.ent,sha256=Ntq3zOsyHpsSvqSg4girNzoLCc0MhvnwKzHTLMRv1qQ,20885
+Bio/Entrez/DTDs/JATS-archivecustom-mixes1-3.ent,sha256=tFeXpjQ6PcWo5AmvYY5L657LkEN0e6sd6QRUD_G0ADQ,31272
+Bio/Entrez/DTDs/JATS-archivecustom-models1-3.ent,sha256=G0DPDpzfyPRSWm_1ETVkCr9d8ua1eFi8SlaLiHL_nGk,78956
+Bio/Entrez/DTDs/JATS-archivecustom-modules1-3.ent,sha256=5WHlK7QhG0bFW-jSreT6ulwLaHgbVULjsy8Z1QtFZ5k,20899
+Bio/Entrez/DTDs/JATS-articlemeta1-3.ent,sha256=givPeJeH4FEJMLqHfezdx-LJaSvwlx7CAynwnPFFySQ,128551
+Bio/Entrez/DTDs/JATS-backmatter1-3.ent,sha256=6hXgTU5p9ZI9L5OTE3Twlt8HGdipwRlFXC0sBRSOkJQ,26909
+Bio/Entrez/DTDs/JATS-chars1-3.ent,sha256=Hhc9-54mfOrjh0otYtnqchrPW6Wj3dMKFtTISWn6fdo,35219
+Bio/Entrez/DTDs/JATS-common-atts1-3.ent,sha256=tfrDvJBBEWUdFrINXtfQ0F0mp75YDoMThy9D3biwQIw,18691
+Bio/Entrez/DTDs/JATS-common1-3.ent,sha256=U_8xp3x7efQ5XjNZT2M8uNWwGrR4_SxTom8VbRN8AJ4,237581
+Bio/Entrez/DTDs/JATS-default-classes1-3.ent,sha256=buWgECKx383aTQUjsEAzVFutSZRJ1BdexZcNmktIzf8,75822
+Bio/Entrez/DTDs/JATS-default-mixes1-3.ent,sha256=GnaB1wLbUTfHotkzi8oYdJFVmtpZ0E0SJDVNDXyRnTU,32971
+Bio/Entrez/DTDs/JATS-display1-3.ent,sha256=vrA3TnAcxKac18PJIWyygjD6v6vy5f5tmRTPW4Z-o88,65828
+Bio/Entrez/DTDs/JATS-format1-3.ent,sha256=fA8xHFkQVIDdgSZiqlHMWQrAIgC54LyoZDdtyo2pgoU,50729
+Bio/Entrez/DTDs/JATS-funding1-3.ent,sha256=9g9Oy82LEvU0VnDHAv8KvMr6oORqy5XgVWWDA5yNbfk,56436
+Bio/Entrez/DTDs/JATS-journalmeta1-3.ent,sha256=5oy_UmO8kcfA7zsLtFzHodrgbo7f1aBjkVsGPRj1e7Q,29732
+Bio/Entrez/DTDs/JATS-link1-3.ent,sha256=E4gdGlp828-WFUL0NXXtUExeljN295YDZVpls8tXnME,30254
+Bio/Entrez/DTDs/JATS-list1-3.ent,sha256=1Uz0L45ztFPb3zhM_7lKYAJ47mzSu4c5ENUH3J0H5cU,32721
+Bio/Entrez/DTDs/JATS-math1-3.ent,sha256=OwhtspWPZHD8m1vJfwlPMWDLY67nRIftGj6R4XenDSQ,27873
+Bio/Entrez/DTDs/JATS-mathml3-mathmlsetup1-3.ent,sha256=KBCPgQhY765S2Y2b1UuiKf-qJ8U3Lb9UfyLuWYoOw-w,23901
+Bio/Entrez/DTDs/JATS-mathml3-modules1-3.ent,sha256=cBkuhZJBL9lVM93WoDY_txtlBelpM7Zu4Yj3ufPiqvg,16430
+Bio/Entrez/DTDs/JATS-modules1-3.ent,sha256=9fAQVjLO00yN8VVGz9KMUI5qaIhMTkUehAhfsFgITQg,37192
+Bio/Entrez/DTDs/JATS-nlmcitation1-3.ent,sha256=vzO5DNSQHgKuMEaFWx9L3vgnjs3kRQTrabujXm-TFRI,21564
+Bio/Entrez/DTDs/JATS-notat1-3.ent,sha256=YSjM8iWIZxMZnNZU2ESeEpttH4NIN2Pv5bBcqM6gJZ8,20223
+Bio/Entrez/DTDs/JATS-para1-3.ent,sha256=zmfZO66wDCT0L3aEedWfGGE582YXcLtjEKLTCDaht0k,32349
+Bio/Entrez/DTDs/JATS-phrase1-3.ent,sha256=uAnwHD4M_BWYI3nlm0wEvN4t80xRO765zvdZj163exY,33583
+Bio/Entrez/DTDs/JATS-references1-3.ent,sha256=VOQLBPVFE-LBwIjQIqNvJHsDXDxWFq58qTBs3suQLJg,73018
+Bio/Entrez/DTDs/JATS-related-object1-3.ent,sha256=qiW_ere8_UPZC5NO2X5GRWReh4w0MDq-Ji2foz65_BU,21380
+Bio/Entrez/DTDs/JATS-section1-3.ent,sha256=uZFlQNek5V1HwkwQ2Pgz_hiOHza6pEK3afuL6HjBUIM,23664
+Bio/Entrez/DTDs/JATS-xmlspecchars1-3.ent,sha256=NV_F_YdYiVWkq1duVwKlUG2AgcdOgSCllXUQDBjpTLc,24007
+Bio/Entrez/DTDs/MMDB.dtd,sha256=8o_TklOQ25jAD9yjCIy6uDfstP8-XW9RoMPPRWQFlpk,3893
+Bio/Entrez/DTDs/MMDB.mod.dtd,sha256=H4DSNhGf-qKWKXnf5xuEOCklfMxDslvPw9NyLiNHuhM,9382
+Bio/Entrez/DTDs/MMDB_Chemical_graph.dtd,sha256=Yp9KueP5jPkYXwCSrp7vmJmwqfsA8fuVG78SkjTijxA,3908
+Bio/Entrez/DTDs/MMDB_Chemical_graph.mod.dtd,sha256=Q-4oVDmtOIVQ9LmDxUM2-K3Sbqm0D8-ZqeJh6-ucr20,17213
+Bio/Entrez/DTDs/MMDB_Features.dtd,sha256=ZnIklyKSjNpLBlva9FynGHTaTnzu2WtWq9ztwydkQUM,3902
+Bio/Entrez/DTDs/MMDB_Features.mod.dtd,sha256=IE-HX9S9Y3Gyn60rlWC-fh7CtKPLqbSD6LV_Osbres0,28680
+Bio/Entrez/DTDs/MMDB_Structural_model.dtd,sha256=wY_C4hHNch8U15uUdnkz-KfCAFVVmNicgAfcNRJi-RY,3910
+Bio/Entrez/DTDs/MMDB_Structural_model.mod.dtd,sha256=dnc8V4-Sl8FvHwkWSogB5fi7pP7sRp1JFjDn91-l9wk,25075
+Bio/Entrez/DTDs/NCBI_Access.dtd,sha256=aNyJgAUlVxBghaPmGYk7rCDIXVmq70ZP7gFRVLZtIyA,665
+Bio/Entrez/DTDs/NCBI_Access.mod.dtd,sha256=qKGcufgqJMxBImW6GSOW_tTaT1mi1qZgUURhBPvDfj4,1221
+Bio/Entrez/DTDs/NCBI_Biblio.dtd,sha256=4yEPk-cGVfNsPJenNS2pBAqSReVHM3AlNeS1linwaL4,785
+Bio/Entrez/DTDs/NCBI_Biblio.mod.dtd,sha256=YYKdqksAsjrAlJ2yh3nbEMazrHqCASSmnGzjBugih2k,15918
+Bio/Entrez/DTDs/NCBI_BioSource.dtd,sha256=cnHbtmIS-gasedMlLCGCeU3ZYtyCWqbvFbHEde0cdlY,925
+Bio/Entrez/DTDs/NCBI_BioSource.mod.dtd,sha256=pkvjkUm6yzLzgeAqBNdN-q1Kw8OOlMWxfCj-B5CHGLA,4641
+Bio/Entrez/DTDs/NCBI_BioTree.dtd,sha256=K1rYdVK9B6y5etOoIr7nMfTD8nkzL4SwshMBY9vgIiU,671
+Bio/Entrez/DTDs/NCBI_BioTree.mod.dtd,sha256=fmRrhBNPfzAota7-8azgpmSWGVll0_LHE9Jt4tbva3c,2444
+Bio/Entrez/DTDs/NCBI_Blast4.dtd,sha256=XE6zyvOLzcNIUxZRGqJNK3_U2irEHUB9pLYdTH2UtyY,3740
+Bio/Entrez/DTDs/NCBI_Blast4.mod.dtd,sha256=rEsskJxU9R8uJ8Y4fnIWWT2mU6PvgBOrT87r0CxUXoU,39597
+Bio/Entrez/DTDs/NCBI_BlastDL.dtd,sha256=C9GLe5fnXGyY_nikZvrPM56bDihl15k6NyynZxH-IrQ,3507
+Bio/Entrez/DTDs/NCBI_BlastDL.mod.dtd,sha256=zi2_S-CDfO452KQI4VVdAeAD-XLnhlh3oCTlnLOs5_w,4281
+Bio/Entrez/DTDs/NCBI_BlastOutput.dtd,sha256=cdvqJTUh_mkkbVosh_pNMlQtB7zAwhB5dheilvgc4RE,692
+Bio/Entrez/DTDs/NCBI_BlastOutput.mod.dtd,sha256=RqhaX3g_hua-nUpJDFJg-BgSioGZv9sNw-O2zQ7Fqms,6579
+Bio/Entrez/DTDs/NCBI_Cdd.dtd,sha256=CdiGbFqR-DV5tdc8wYh2uq7gXe2V-z9ZWHBsgQSkQRM,4347
+Bio/Entrez/DTDs/NCBI_Cdd.mod.dtd,sha256=5y3dtlMKYPglaz0eyYG4R2Evc56Z1lG6fsKMbEllHZA,28292
+Bio/Entrez/DTDs/NCBI_Cn3d.dtd,sha256=Gvmx4-FWSEv9Yuccw3wdAcQqLDN9kBv7qnlxJSpWwog,4005
+Bio/Entrez/DTDs/NCBI_Cn3d.mod.dtd,sha256=3M65R1gc7Mpmw2sU7KjOXwdZtW06gbexLzLYAVzjy-I,16758
+Bio/Entrez/DTDs/NCBI_Entity.mod.dtd,sha256=2xe54TA_By5tbMPPdFxcocMFUNiaoxK-MJFpfQiF3rY,410
+Bio/Entrez/DTDs/NCBI_Entrez2.dtd,sha256=i3aMulqQN3f3sMQE4dGE9DgdOKyf7HicJFHrb8DU70E,671
+Bio/Entrez/DTDs/NCBI_Entrez2.mod.dtd,sha256=4vIwr4XgQaZMDi_HErtpq2qQPSWRc_Wre4kHQ6nvXUo,21922
+Bio/Entrez/DTDs/NCBI_Entrezgene.dtd,sha256=4dr19jpGDBjYASME3hB3nuNefr3b6-0Yu13NQGZjIrU,3525
+Bio/Entrez/DTDs/NCBI_Entrezgene.mod.dtd,sha256=GO27Y6hhPHANlymRgNW9boI0Xc7Xt9602hG2oBFEVyc,10316
+Bio/Entrez/DTDs/NCBI_FeatDef.dtd,sha256=STKp93xHN6S9hAENQp2knyrDCOt15bFYLwodC6711h4,671
+Bio/Entrez/DTDs/NCBI_FeatDef.mod.dtd,sha256=BocJqizMjC-hxnfyiAUq45MCjHeeCFgUnIeABvyZ06g,2358
+Bio/Entrez/DTDs/NCBI_GBSeq.dtd,sha256=Rt8os_PzMrx1h5pzp_JTau4_480vgjxpmFvBEWcoevI,659
+Bio/Entrez/DTDs/NCBI_GBSeq.mod.dtd,sha256=8i-pBCxZbXUHT-FTRpznGQzXSFEBdjxDyThRFt78ipE,11502
+Bio/Entrez/DTDs/NCBI_Gene.dtd,sha256=lJ8t650BA1NONodHzpqwCmB3o5kL9bgb-wi4WSaSGV8,776
+Bio/Entrez/DTDs/NCBI_Gene.mod.dtd,sha256=H2T7ARAKtJrQEF9QzBXoiGB0pKT2CXAz0TDZ5YC23Vs,2381
+Bio/Entrez/DTDs/NCBI_General.dtd,sha256=tpy7lJG6xQOMqa0T3BJe-6JFZMM697YCM4j4Pj9Ejuk,671
+Bio/Entrez/DTDs/NCBI_General.mod.dtd,sha256=jLoXdJQ4E3nQ1TohN6yyeXuoWnUMruPLXX4md8Xi0gU,8215
+Bio/Entrez/DTDs/NCBI_ID1Access.dtd,sha256=MsUZrJscC5vRHo7Yp1B3mmNg7RwEUW8ImarKYh_kl2c,3629
+Bio/Entrez/DTDs/NCBI_ID1Access.mod.dtd,sha256=qieXojxAkci4Xb9DoODr8gDHJmzYqL3pNeY0rfn9Wa0,5733
+Bio/Entrez/DTDs/NCBI_ID2Access.dtd,sha256=t4yTR8qVNiLvTYYKcSCz7BWnbdTYomz5masiqrXcvMs,3757
+Bio/Entrez/DTDs/NCBI_ID2Access.mod.dtd,sha256=ROwJqyXoOX6vRvbEV2GgXQhMs99-dPVlL_OzzYqPEBc,23205
+Bio/Entrez/DTDs/NCBI_MedArchive.dtd,sha256=NkTQHe7O85nrerhqwtwqWv86XQscMH0x-rnJTJMPoj0,1378
+Bio/Entrez/DTDs/NCBI_MedArchive.mod.dtd,sha256=LocUWbGjILixCPx9R6ejdnkUqDf1mfN4U5S2sCDCAIw,6931
+Bio/Entrez/DTDs/NCBI_Medlars.dtd,sha256=RQg93Tgoex1uX_N-h_6DuUSj52BhJC6mTb80rP62qzA,907
+Bio/Entrez/DTDs/NCBI_Medlars.mod.dtd,sha256=kEb6kwItqxMaFX0EqqZiS5ZZ-00NsSbm2RsMYYysosw,1617
+Bio/Entrez/DTDs/NCBI_Medline.dtd,sha256=uNxb4wBqbRKcfXJpIl4uGX9iGxSCbMl8H1X3fZWoDBA,907
+Bio/Entrez/DTDs/NCBI_Medline.mod.dtd,sha256=8ig5vQcNkB-ewUBH87dL4eZ1jx7PfYBrD5Cu1I-khqc,5757
+Bio/Entrez/DTDs/NCBI_Mim.dtd,sha256=uIMYWrK7Vkz4KybpYIisCcjQasikRgHDb3ejlBjoiJc,647
+Bio/Entrez/DTDs/NCBI_Mim.mod.dtd,sha256=EKfBcoxMQslGMvtu-miMdKTXl4SbrTSt79kxeIUbp_c,8395
+Bio/Entrez/DTDs/NCBI_Mime.dtd,sha256=g5TECscn4CAgkQGhnN2dMYCGWaGEeBxSAbXe6nIemoQ,4461
+Bio/Entrez/DTDs/NCBI_Mime.mod.dtd,sha256=XNM01f8sKIvAjauudb_Sw5mvNuZiKV7LIh4-7sdK2yI,7270
+Bio/Entrez/DTDs/NCBI_ObjPrt.dtd,sha256=7Gq9WPyaC40Z32jSFI1mUSjlhpa4_MoU2j4gk_xKMXk,665
+Bio/Entrez/DTDs/NCBI_ObjPrt.mod.dtd,sha256=RnbU0oDsnOIGZF0BdztML0jQ1Q55wiK2r-8wRjZLmPQ,3131
+Bio/Entrez/DTDs/NCBI_Organism.dtd,sha256=IuGRTHZm4KQkFOpyG403aGfMu6XOJUExHyoJd9iKAtg,796
+Bio/Entrez/DTDs/NCBI_Organism.mod.dtd,sha256=80ahiOw_6ZGGx1Nid4bNeIaDF_Mi9xLkKBd_7MySIu4,5250
+Bio/Entrez/DTDs/NCBI_PCAssay.dtd,sha256=FeKjeUP0QTeI1hZSXetaF3ZVrf5H7K2UaZdrRBW80EA,1519
+Bio/Entrez/DTDs/NCBI_PCAssay.mod.dtd,sha256=y9liJr3Sn_e86C5Pj96wx30zhQbYZ16jUpRM58Ni0QE,31800
+Bio/Entrez/DTDs/NCBI_PCSubstance.dtd,sha256=Fs3zuVllU7A01hMiVIszL0jU8Lbwbt6G9wJ-LvuaJMU,1155
+Bio/Entrez/DTDs/NCBI_PCSubstance.mod.dtd,sha256=iTRVhiSo-ZUbvRRcJCATx61K6Zivll6JBsYEJA1Puhc,43623
+Bio/Entrez/DTDs/NCBI_Project.dtd,sha256=VMcguPNeuLZ1owpGOQJdFSefv1l2jp6sTn4l5wbj63Y,3736
+Bio/Entrez/DTDs/NCBI_Project.mod.dtd,sha256=641_UjWWjD7ZJplh3GeE-4mV0ckW3YvoKTDNgNadhA0,3769
+Bio/Entrez/DTDs/NCBI_Protein.dtd,sha256=XoSIPrbCwWUlr5Na7ErJBZuAzTuCAAZ_XVDOerrK-lU,791
+Bio/Entrez/DTDs/NCBI_Protein.mod.dtd,sha256=XJpQe9rFagTmn8rjm8s5m_pwItuQiHCJy0oO7fndYeo,1791
+Bio/Entrez/DTDs/NCBI_Pub.dtd,sha256=ZzB3n3MApCzPgQYieV3ZH5uTs2bzSHCvq6CUo5Zs6dY,1003
+Bio/Entrez/DTDs/NCBI_Pub.mod.dtd,sha256=pJ8PIYUpeCbYSfe21M2nokaDf8I9N1U3A1e-o6ANUqQ,2700
+Bio/Entrez/DTDs/NCBI_PubMed.dtd,sha256=jfXKsD32O_oU9OkWJ9SfYII1oBXFztsBKZod_z_rZBM,1021
+Bio/Entrez/DTDs/NCBI_PubMed.mod.dtd,sha256=hx45aYybW7oskwnK2glFb8utcYxMZ_TX2ABpNwEH694,1698
+Bio/Entrez/DTDs/NCBI_RNA.dtd,sha256=r9OFvk7A659wRiWVRNoArDnEaaTdtPRHBHQpKROL4vg,3383
+Bio/Entrez/DTDs/NCBI_RNA.mod.dtd,sha256=nmjKpennw3EMJjWoIwH2bmMB61omr6WxZ25RuqjD2Mw,3379
+Bio/Entrez/DTDs/NCBI_Remap.dtd,sha256=BSNg9ciSemrUMYRbhFzEPqCykkH5atXm02SdVTuZOIU,3495
+Bio/Entrez/DTDs/NCBI_Remap.mod.dtd,sha256=KGt0KiHjGCc1sUSD2-N5VpC5wHPrGEIy37p1SP7kLuI,4064
+Bio/Entrez/DTDs/NCBI_Rsite.dtd,sha256=sBQz31SvF5nV5tALDmRfyZs4yrnnc8uTpNvFxqpSfi8,781
+Bio/Entrez/DTDs/NCBI_Rsite.mod.dtd,sha256=5O2ab5claOg5Wf6JNcDaTuKXGIs5QViiymj0BkXwjZo,1044
+Bio/Entrez/DTDs/NCBI_ScoreMat.dtd,sha256=NmgfAx8RaUNGHBaR7DOmEMt2AU0yc7WG9K3tyuOsJSM,3629
+Bio/Entrez/DTDs/NCBI_ScoreMat.mod.dtd,sha256=9Gw8gKkTNFmGTi1584tZZBovlgBLGDWjHZd0a4k_aH4,19503
+Bio/Entrez/DTDs/NCBI_SeqCode.dtd,sha256=wsElBnAymD7ZRSv3ZvnbKjSgk8iGUq9XXuyGxapmJ3k,671
+Bio/Entrez/DTDs/NCBI_SeqCode.mod.dtd,sha256=uUxXZhHSTPAKKk0-4RptG-LRAeJafTscRoEhgBjLMIM,4231
+Bio/Entrez/DTDs/NCBI_SeqTable.dtd,sha256=3KTsu1iq8OItYeHtZjWrae3pvUsP9aGdNf0bbFFr798,3389
+Bio/Entrez/DTDs/NCBI_SeqTable.mod.dtd,sha256=RPllvGSZE0tO-2XEpCho53s9MD45WAnkyh3-JAWz6FE,9912
+Bio/Entrez/DTDs/NCBI_Seq_split.dtd,sha256=X16El8p5HwFPJ4CxEcua2N4SEpKOelWU_JFe67AK628,3634
+Bio/Entrez/DTDs/NCBI_Seq_split.mod.dtd,sha256=qUeN5WBuzbmu89QOz3F7JctUZyKtoPfRN_VGiqsKRUY,11475
+Bio/Entrez/DTDs/NCBI_Seqalign.dtd,sha256=RhPcqjot4vmAR9jSBnGbtJSbA2YTo4_bxaDMR8Ib6Rc,3389
+Bio/Entrez/DTDs/NCBI_Seqalign.mod.dtd,sha256=kT7uwFilHKjmrtXIKT-zrE5286yrYh6dPAoJL37dcVM,15026
+Bio/Entrez/DTDs/NCBI_Seqfeat.dtd,sha256=8KYy27sT11PRnsNSWnF2PZgxacG6Cv8OMi7d86sarpQ,3387
+Bio/Entrez/DTDs/NCBI_Seqfeat.mod.dtd,sha256=dCtWissG5XTffQFX-gthe5iPFDTnnqOGfT-InZYrqlM,19204
+Bio/Entrez/DTDs/NCBI_Seqloc.dtd,sha256=MMew861PLYRaQEIfaRMM-H756AvcCvL0o9HkQpH7s6I,3385
+Bio/Entrez/DTDs/NCBI_Seqloc.mod.dtd,sha256=IX528bn4S5ymU7j2hTz7Yx4jgQ6ElMcW9TX1OB1L-1c,7383
+Bio/Entrez/DTDs/NCBI_Seqres.dtd,sha256=9oAqimMEHPsqKoURtjYNaxgAHLTZtmd7vYzi_CjD3JE,3385
+Bio/Entrez/DTDs/NCBI_Seqres.mod.dtd,sha256=cQDPBXeSofBlWTCwu6uGyOW5G3YJevgaJOsQn9tGV-o,3149
+Bio/Entrez/DTDs/NCBI_Seqset.dtd,sha256=vskX5qkvEHsabozo5iqezsFAQcGQU6xcNXZ3qeeTAFo,3501
+Bio/Entrez/DTDs/NCBI_Seqset.mod.dtd,sha256=8xlQ9oG56eq2BYgKt1GCedpJCF4hWb-0aZEgTEnW8eY,3479
+Bio/Entrez/DTDs/NCBI_Sequence.dtd,sha256=cEI03PDqxwzgDlkMvk-yufxXOkxbmiLBdHfFP3lpAso,3384
+Bio/Entrez/DTDs/NCBI_Sequence.mod.dtd,sha256=ugzzX_6CJi9vDxu-rr-DS7TWRCD7P0nkogrO71SjhpY,26293
+Bio/Entrez/DTDs/NCBI_Submit.dtd,sha256=2jzCuajZbqJvPoTF22NYAqGlvEwWUJrqCwwj9zJw6JE,3617
+Bio/Entrez/DTDs/NCBI_Submit.mod.dtd,sha256=iunQK7Rdu_dJjAL57g9EtrVCeJgN6XBAs1YZBmhOcjc,4130
+Bio/Entrez/DTDs/NCBI_Systems.dtd,sha256=saQQjxO3-Ks3cUNKRQcuH6ohDk7B3pqeLBzwUisEZOY,3379
+Bio/Entrez/DTDs/NCBI_TSeq.dtd,sha256=LPbK2qwPbhLfzCXU7PPkmINBum2m4B4AlQ-eVoBI6Uc,656
+Bio/Entrez/DTDs/NCBI_TSeq.mod.dtd,sha256=zLhRDIfejxx9RPh45qlPjqwDRW3GG4-fwHMSX3kxHgo,1660
+Bio/Entrez/DTDs/NCBI_TxInit.dtd,sha256=vRmESYnpRfducIFeY0II8XETa9Ob7NI4TU2KTq6xVac,1138
+Bio/Entrez/DTDs/NCBI_TxInit.mod.dtd,sha256=tav_Ms5Qjq0gpvoOchuOXWJ60klKNE5oVDs1nw5xIwc,4625
+Bio/Entrez/DTDs/NCBI_Variation.dtd,sha256=eOKRTGIVa7CfavmYAUcIUTIATK22k-pv_VP9zU-ammY,3389
+Bio/Entrez/DTDs/NCBI_Variation.mod.dtd,sha256=jOApQ49K2X-F535-yGDGe6AEXKHwbgI1Xw6o1zW0b_E,27155
+Bio/Entrez/DTDs/NCBI_all.dtd,sha256=e7XeHIev6wThr8s_9uT6Sj7dF502nfGA4AgasRVLWaA,7893
+Bio/Entrez/DTDs/NSE.dtd,sha256=L3mgGXxnzx01qvIBuZOTjsC728XRdSMsCCXmYrh3UX8,625
+Bio/Entrez/DTDs/NSE.mod.dtd,sha256=a9BTqZurN6mGOvZlKNl8oitJrM6dQEugMmCR2-cUHGo,26853
+Bio/Entrez/DTDs/OMSSA.dtd,sha256=elWNHN0VKqkg863NvGWFO4VJOTXI6AosZA1bwQhF7HE,3470
+Bio/Entrez/DTDs/OMSSA.mod.dtd,sha256=zYCmIZ8CvtO1XstO-USMaLB3ncW-dc4Zw4XPYigMcFc,34917
+Bio/Entrez/DTDs/PDB_General.dtd,sha256=2_8JUKHvYtGc5MbAbyHjyFHMInGYJV6AEBDlR_aHxjg,787
+Bio/Entrez/DTDs/PDB_General.mod.dtd,sha256=1Xf6BTjyGHtvdyzp7XhkKzR7PbhjabjpCflNjeskbAw,1815
+Bio/Entrez/DTDs/PIR_General.dtd,sha256=-ud6dN3XRycgCzGBmFSCnq_Ho9hWQQMRZU4EEhdUTWM,3387
+Bio/Entrez/DTDs/PIR_General.mod.dtd,sha256=-6Jr11CVBrhoTEQNzFNNrdpvdNGxxr0HXI9Eu3am-DQ,2076
+Bio/Entrez/DTDs/PRF_General.dtd,sha256=F2YTtdyaRdvDRJwzl7fjtOOjQhLu-uGn6orG0QO2or8,667
+Bio/Entrez/DTDs/PRF_General.mod.dtd,sha256=o658lwkLDcTseWREFx4FNkYOw48KN2O4BMnwXSM2vAs,1535
+Bio/Entrez/DTDs/SP_General.dtd,sha256=pLIfpaLpOVA8MpuwMafaPZIpyDLgufZ3sgH5ZQlE4OY,3386
+Bio/Entrez/DTDs/SP_General.mod.dtd,sha256=DV5zmzP4a089dU9nmr9UoMN6vdsY4_E0zNKCKgus2Og,2375
+Bio/Entrez/DTDs/XHTMLtablesetup.ent,sha256=pMSlJTftz5OwjyC-_grm-L9Lt5SykBZ4K2y75qamIUo,17329
+Bio/Entrez/DTDs/archivearticle.dtd,sha256=MET5vcqH_9QEV5gRIurHth8T9TPNqzu4vJCm7nm5Lr8,51298
+Bio/Entrez/DTDs/archivecustom-classes.ent,sha256=jkaxy1V46gWHJaAPv_cURSxpeZ5GsRjJRC90dT-L_MU,8304
+Bio/Entrez/DTDs/archivecustom-mixes.ent,sha256=do9tIJzVSIakOmoPnqzpuh8Ff8n4SQtQ6MTQNrLM2_8,16646
+Bio/Entrez/DTDs/archivecustom-models.ent,sha256=J6c2_-uusjX9lF3_1BXufKGpUjFs-uowm2UWGY16E4s,38921
+Bio/Entrez/DTDs/archivecustom-modules.ent,sha256=eC_FFu2d1dccqSyqNlAsjC2QGquV5GltHbN7cq-qoeU,6412
+Bio/Entrez/DTDs/articlemeta.ent,sha256=uFAN9ouF3yNmbrDhMpZKyWyCEK6_Vdp92OXh-vYDQHY,98004
+Bio/Entrez/DTDs/backmatter.ent,sha256=9U5ZalynymL5Bnwn7BzEx2nf2A-I4rXn63C-WSRNXIs,15090
+Bio/Entrez/DTDs/bookdoc_100301.dtd,sha256=vFcHye_i6RW6WL4y1md-TCiqVpzGKN9c_-nczdCprys,2645
+Bio/Entrez/DTDs/bookdoc_110101.dtd,sha256=vFcHye_i6RW6WL4y1md-TCiqVpzGKN9c_-nczdCprys,2645
+Bio/Entrez/DTDs/bookdoc_120101.dtd,sha256=vFcHye_i6RW6WL4y1md-TCiqVpzGKN9c_-nczdCprys,2645
+Bio/Entrez/DTDs/bookdoc_130101.dtd,sha256=qPFrpOOa8kYltgzEfAgaQbbr8xQXP4pqPODUGYoDOJ0,2756
+Bio/Entrez/DTDs/bookdoc_140101.dtd,sha256=qPFrpOOa8kYltgzEfAgaQbbr8xQXP4pqPODUGYoDOJ0,2756
+Bio/Entrez/DTDs/bookdoc_150101.dtd,sha256=qPFrpOOa8kYltgzEfAgaQbbr8xQXP4pqPODUGYoDOJ0,2756
+Bio/Entrez/DTDs/chars.ent,sha256=L9fpP6AGUsz2Wo5U6LUb5MdbnhW1sZiC6L7V6XawdiM,21412
+Bio/Entrez/DTDs/common.ent,sha256=lYzWjlvFGDis2_4aZ5USQzbj82ke-0Eufkiq19rcyOI,152388
+Bio/Entrez/DTDs/default-classes.ent,sha256=bKFYECnPymhiNfGAvMzXC23PtCh6JfVOXCs_6DY-O88,33182
+Bio/Entrez/DTDs/default-mixes.ent,sha256=a4Jeda6RyIzAJocDYu8HIwmYGNjtPajAVROOzbNBKxg,19402
+Bio/Entrez/DTDs/display.ent,sha256=-Q_ZSQ6I2h1hyqCY4l5b5fzu-ysJ_ioTrFebMlLAmbw,82067
+Bio/Entrez/DTDs/eInfo_020511.dtd,sha256=aG7lBmF68KNsiNhllCUOq2xzmKPIMIaTDIIYqglQHu8,1655
+Bio/Entrez/DTDs/eLink_090910.dtd,sha256=Xd4mnBGw0Ca8OjCt0PA9kYtJbHMf0HvinZ-0TGS0YVo,2299
+Bio/Entrez/DTDs/eLink_101123.dtd,sha256=KZA8UxqTi-KrRbg7fG0oNYC6kTkP7ZEPl2mjR3GhdUo,2447
+Bio/Entrez/DTDs/ePost_020511.dtd,sha256=VwukI9A1PW-pcy4LB5RRdVGo5mD5DSzHuyBJlahe58g,520
+Bio/Entrez/DTDs/eSearch_020511.dtd,sha256=VsL7ZmztSk9zda9el2g1wyXmcAUycr0h05FIV5gS74c,2392
+Bio/Entrez/DTDs/eSpell.dtd,sha256=_yDVizsLoKjolPHON7ML7gwxLmy3o7XX2ukYe_ith74,736
+Bio/Entrez/DTDs/eSummary_041029.dtd,sha256=jug43errNhwuF6lbH-lN7MBveyaa-WyO1aoQc_z9lno,602
+Bio/Entrez/DTDs/egquery.dtd,sha256=vtauwIAeqdzXhi8fJqy6uf5d_zdFOzZuZvRxeL2uxnE,851
+Bio/Entrez/DTDs/einfo.dtd,sha256=flJk5s4yhvq2W46q0pD0IaUFxoWr2-tBnGdm9T992yg,1980
+Bio/Entrez/DTDs/elink.dtd,sha256=KZA8UxqTi-KrRbg7fG0oNYC6kTkP7ZEPl2mjR3GhdUo,2447
+Bio/Entrez/DTDs/elink_020122.dtd,sha256=rgPalXtmk1Rso0bdRQJ-BffTifYDIH8U4wrqMjV3ZHo,466
+Bio/Entrez/DTDs/epost.dtd,sha256=VwukI9A1PW-pcy4LB5RRdVGo5mD5DSzHuyBJlahe58g,520
+Bio/Entrez/DTDs/esearch.dtd,sha256=l70GlAyVx6cmllr64-CaHZ_hZarRHpjMgKlOfx-qLTg,3337
+Bio/Entrez/DTDs/esummary-v1.dtd,sha256=jug43errNhwuF6lbH-lN7MBveyaa-WyO1aoQc_z9lno,602
+Bio/Entrez/DTDs/esummary_clinvar.dtd,sha256=RP5QjEFbx2KWBmu416JXdLZY2AAmlzztsjoFnISfHUI,8040
+Bio/Entrez/DTDs/esummary_gene.dtd,sha256=C8f6fxR15cYmfhlXoV6PBfxDvUeNdEjQtADLDCfCED8,4163
+Bio/Entrez/DTDs/format.ent,sha256=mOa7_62TyBZK4MpJZg5uA1cf1Ct_npcIP_S-SdE038A,22746
+Bio/Entrez/DTDs/htmltable.dtd,sha256=Wsju2DzjtiVma4L6uHLIsWjgo33tI66XuGHFqPAjUcw,9849
+Bio/Entrez/DTDs/isoamsa.ent,sha256=GH1Jw-gM7KnbalbN-r9vURh8O5mUN6qXH2PNZP3XzXc,11589
+Bio/Entrez/DTDs/isoamsb.ent,sha256=vkg9B1QqbTGdi_k172ht9dPYe2P1fxe0bn-A_FHhp7k,9556
+Bio/Entrez/DTDs/isoamsc.ent,sha256=kkw1k-mOi7niKBtyXei8epMheTJFHDXtdp52KhuD3us,2254
+Bio/Entrez/DTDs/isoamsn.ent,sha256=uaQalCFMcgho83l6Fmclp8pdIAFiIOuZgK3gQhMTCzw,7945
+Bio/Entrez/DTDs/isoamso.ent,sha256=MUriBI5j9FfvAICPOj6-PNwIGnz8mP2UYamc4761b8U,4432
+Bio/Entrez/DTDs/isoamsr.ent,sha256=2vpeKkPl2fr1zOpPpNm6ibxcDMnkTjONXZa5omE2iWU,14133
+Bio/Entrez/DTDs/isobox.ent,sha256=OKYRXaEovQpTA_P3oQklQBQrximz9cAQmUgvjWx3Ug4,3507
+Bio/Entrez/DTDs/isocyr1.ent,sha256=4RZ1xTRw5BypIRbMTUQVGwhF2sRPzFp4w_suYiYjIMI,5257
+Bio/Entrez/DTDs/isocyr2.ent,sha256=o5qiJMRO3kMU-gtjp-k31-FNVn4rL31p0bKkpYYotB8,2457
+Bio/Entrez/DTDs/isodia.ent,sha256=PagdFcNO-RUrdtmLv3jk_X5UpdZmYN_MI2FVOzNH7tY,1473
+Bio/Entrez/DTDs/isogrk1.ent,sha256=2dnwGe2Lc0E8EWD350mZPMVA6oVxSOYouDmtpgrQ3g8,4102
+Bio/Entrez/DTDs/isogrk2.ent,sha256=0KNMYv6j4IuuUXwICFmLCbRb2_D_R2JF5K5dmZm377U,2389
+Bio/Entrez/DTDs/isogrk3.ent,sha256=IYAcnVbnWehXbNVEI6NX7dNB5xGV5_JUrNAGIvfJG5k,3699
+Bio/Entrez/DTDs/isogrk4.ent,sha256=_8ljq43-ZfUbsweyM7r0YRf4Si_g4irr_oDvR3qyOOY,3591
+Bio/Entrez/DTDs/isolat1.ent,sha256=W3kRUuV2drO4xQe8BNJYRGc8NMd1Hz9xtH8W-kJifoY,5199
+Bio/Entrez/DTDs/isolat2.ent,sha256=24pU6kXFzYpHUBxydqiLYOp_pFFgdNR9AxAcES2qXWw,8865
+Bio/Entrez/DTDs/isomfrk.ent,sha256=JimvrtuftcqxXJC5nK1YPHjG2mrwAM66u7U4mSqgHP8,4478
+Bio/Entrez/DTDs/isomopf.ent,sha256=Hz2gfe7th4LvrmrpJIjbSyVQTGm5M5O94IJiCEvD15Q,2522
+Bio/Entrez/DTDs/isomscr.ent,sha256=S8sjXp0WakDU1GV9iQurkUaUwci8_15v2Wn7a9s8ZQY,4557
+Bio/Entrez/DTDs/isonum.ent,sha256=pNQC3pk9UhI7jdM-dpj2GgT47Thiw0pTwqjfcSMAEDY,5816
+Bio/Entrez/DTDs/isopub.ent,sha256=Q3t5NQ4EXQafFMeUFIaslOIbIMo3Y_8OuqYRv74oj2g,6594
+Bio/Entrez/DTDs/isotech.ent,sha256=X1MbZMTwss4Zsis4Tzp0hWtzXSozESNO-GwdqyHz64M,12399
+Bio/Entrez/DTDs/journalmeta.ent,sha256=dzUy8aYJxnIhzOo-89FetC2SdNzw0voECvr4iURLabc,18988
+Bio/Entrez/DTDs/link.ent,sha256=gaeJl3kpZ3_55PqVPDyfKDKDIqJP3DeHblgOpnbT23k,28360
+Bio/Entrez/DTDs/list.ent,sha256=ke4CYbWhohcvZqPauNBIg5DHjgt14YHIC7I7qi21h9o,25663
+Bio/Entrez/DTDs/math.ent,sha256=X-ID1KnAz2HTqrA8uvB2-2-HXRl2W8r8ihZndVVRlp8,18334
+Bio/Entrez/DTDs/mathml-in-pubmed.mod,sha256=JEdFDllSTYme0pm9WjE1hVURKy0T3l1SF4qY_vl9Swo,6820
+Bio/Entrez/DTDs/mathml2-qname-1.mod,sha256=2WYXCQgVtax_DMJE4Wz0nQYiWxt4-m_z4bXTCQVcC4M,12948
+Bio/Entrez/DTDs/mathml2.dtd,sha256=LjOhvDtndW7BQF0QNX2kBSpQpFqlMJFco7vFzZt6cYM,50791
+Bio/Entrez/DTDs/mathml3-qname1.mod,sha256=jQEYIgRVtqAiZb6x9XmOqw5Ewdq1OrqrTYXPvMKvR54,12255
+Bio/Entrez/DTDs/mathml3.dtd,sha256=i8bDuihkXJJ6zm0wKRgN5q6hvEW3B6EMW8OKG-MDRbc,42407
+Bio/Entrez/DTDs/mathmlsetup.ent,sha256=RzVijIpCuL4kHtnef50H_1a0-cBO3A7br72QDQmOrfA,10452
+Bio/Entrez/DTDs/mmlalias.ent,sha256=UtxHlmtlUp5otOF_AU2fHD3go844XrpmAPpvLoD_MTc,37695
+Bio/Entrez/DTDs/mmlextra.ent,sha256=FbyPdxTAfPqtooS9wi9uilpAfmgvPpixayMHxXdRNac,7776
+Bio/Entrez/DTDs/modules.ent,sha256=5Bc42vE99Qe1AWFGxkg2gtTBo0QWEYCC606EcY_5eos,21579
+Bio/Entrez/DTDs/nlm-articleset-2.0.dtd,sha256=jF_rBcGNoIoWfnub1luNiHXJBQqN9o8MFwYwA1FLrLw,35333
+Bio/Entrez/DTDs/nlmcatalogrecordset_170601.dtd,sha256=zVBPd7C12RnewTsqOjHadIr0YvvGqtPJQOwF1mVgttc,12369
+Bio/Entrez/DTDs/nlmcommon_011101.dtd,sha256=TFRRotd5JhjVeEinqvdicxEOs6ok9HHYfAhRH_QF5cs,5839
+Bio/Entrez/DTDs/nlmcommon_080101.dtd,sha256=xWMdAKnEPC6kc8T6xB0paFhED9dLEOtF-TthiyYfmrc,7946
+Bio/Entrez/DTDs/nlmcommon_090101.dtd,sha256=4fnrqF1p_yKMHENZcBrbSLeVnsEPwbHle2OurokOr9c,8638
+Bio/Entrez/DTDs/nlmmedline_011101.dtd,sha256=cUX6PfwkxEPqxuwPNSKk8Vfk9I_JKvabXgPce78eCEM,2053
+Bio/Entrez/DTDs/nlmmedline_080101.dtd,sha256=77exsUHPLwoKRzo0pVgxI8SjJzcFrvdXZyrVldF7Jis,3017
+Bio/Entrez/DTDs/nlmmedline_090101.dtd,sha256=8TtPnfW4afjOcJBoAxtbyalsrSwSmcqEHRnpM46Vj2A,3195
+Bio/Entrez/DTDs/nlmmedlinecitation_011101.dtd,sha256=z4M-4ZKpYAozJH9Z9g3wF-GCrh75ETskz41QAfCnF6Y,6760
+Bio/Entrez/DTDs/nlmmedlinecitation_080101.dtd,sha256=QscN6yGVx51XAiy8erXcDUYif-sf82_P0es35iP6sHc,5001
+Bio/Entrez/DTDs/nlmmedlinecitation_090101.dtd,sha256=0btDyH1pypO0U0lfalZ6QoYpzQ4roOenTc0VF6_2nYA,5262
+Bio/Entrez/DTDs/nlmmedlinecitationset_100101.dtd,sha256=IifD6QlOXTx350NGYvXOJzhjDJX520dgprFpVH9IGWM,9322
+Bio/Entrez/DTDs/nlmmedlinecitationset_100301.dtd,sha256=DPVPngtaWtRLr1q2NyocXA07NemyB38MEZpMPBZYgEc,9618
+Bio/Entrez/DTDs/nlmmedlinecitationset_110101.dtd,sha256=9yPia1GT1mpWB3OBxHzfZG2Xl3c2sv_mazO-KseOZdo,9308
+Bio/Entrez/DTDs/nlmmedlinecitationset_120101.dtd,sha256=jC6j_N1lYmVncbfyIOK-OneNvKaOqufeYoN58SYKKAk,8829
+Bio/Entrez/DTDs/nlmmedlinecitationset_130101.dtd,sha256=L9mUro3WB95nv_yu1ANnzW1tySHbTSzLhX6fur-PgoY,8995
+Bio/Entrez/DTDs/nlmmedlinecitationset_130501.dtd,sha256=WzNSa95vM2mHY2EqINOpTgT7wFU5lcSqEbF_Mc-UBXc,9033
+Bio/Entrez/DTDs/nlmmedlinecitationset_140101.dtd,sha256=bfpnLgztqwGHpayi8B1BOnW4L_ZMGIignFitoyGwuzU,9112
+Bio/Entrez/DTDs/nlmmedlinecitationset_150101.dtd,sha256=HW9VKNWFMq8rkzeS8HeaWjwrh2fkKJNzpmwcpJR4cZQ,8947
+Bio/Entrez/DTDs/nlmserials_080101.dtd,sha256=Bqg_xRNPDFzaZRKSCPyoW5vRHnJHyrS2fOeKFl_4aJI,5672
+Bio/Entrez/DTDs/nlmserials_100101.dtd,sha256=odmX_CV_rHEq0IOsX1psIdJ2ShqvDHlYjPUdSv3SO7o,6703
+Bio/Entrez/DTDs/nlmsharedcatcit_080101.dtd,sha256=1ze4V86srXps-XNepcgKeWMOK1mte0MT0KkgJ98ylBc,3185
+Bio/Entrez/DTDs/nlmsharedcatcit_090101.dtd,sha256=7cUZKV1Pysy5q64byPx9OsOQ3lDmlbDRXnJwRxIC828,3317
+Bio/Entrez/DTDs/notat.ent,sha256=8T3TF0GSFDrlpY_l4ekQlxOUDlijaIoUxi9-H7ahkrs,9656
+Bio/Entrez/DTDs/para.ent,sha256=dL0ilkXsSkhRk9qXS2jesdvNqvBYTHpG7lPckDLB5jg,23807
+Bio/Entrez/DTDs/phrase.ent,sha256=DAkQer5pKPRhDJ9x-ymZyJlvHkYexH8X8V2yjaboG2s,15750
+Bio/Entrez/DTDs/pmc-1.dtd,sha256=XqrPQO-uHRN3spjNGBM3lsqHtczbZmL9RPTGZYGvxTc,25142
+Bio/Entrez/DTDs/pubmed_020114.dtd,sha256=IAGfdULpjjPODM-484qKyuXuXB2TwZbLuIqLUmOseNE,2714
+Bio/Entrez/DTDs/pubmed_080101.dtd,sha256=CkV3XF9NEkA_lYaFwWaRbvPH26mOQi5RMfmOaaSd2-U,3045
+Bio/Entrez/DTDs/pubmed_090101.dtd,sha256=zHzlgy2wCVoj0tq43VBKgQaWn-7ng1c5HtMgSM8ejiU,3059
+Bio/Entrez/DTDs/pubmed_100101.dtd,sha256=ELG9N5PSni2xixzYk3wIGog-2BW6Sv7nq3npxuShg7Q,3126
+Bio/Entrez/DTDs/pubmed_100301.dtd,sha256=LGYfgB3eC_Xp-bVRnufJT6AunEPNmnIH1PZgSll-dss,3434
+Bio/Entrez/DTDs/pubmed_110101.dtd,sha256=v3RFxJfGLCmYYS5XO4FZcIFmoGe0BlfY2I8PtAZmLgI,3434
+Bio/Entrez/DTDs/pubmed_120101.dtd,sha256=Ldmtv03z9o_IGFjjntrCcNMvYlEhr4qNje6ZDyVxF_M,3434
+Bio/Entrez/DTDs/pubmed_130101.dtd,sha256=tCV7OTohcjx4BotvD1YuFeoxXuAcEuRVlYu7qNuCsoM,3434
+Bio/Entrez/DTDs/pubmed_130501.dtd,sha256=gse-pDXqfgfBWrXq5YUSlbI3-Uo2I_kWcxAYvDIOABk,3445
+Bio/Entrez/DTDs/pubmed_140101.dtd,sha256=MGQK_6agHEmmwLIsKzzuPmbdJ88ZngdX-tmgqDQ3AGM,3445
+Bio/Entrez/DTDs/pubmed_150101.dtd,sha256=4FsJ1veegs8frYmQV7BBdqY2q8-bDV8I4r_7CBM4P_Y,3445
+Bio/Entrez/DTDs/pubmed_180101.dtd,sha256=ZeC8wT6YZTNGD5LaTx1c9nhXpXGFsjqdu8rHB5sVEkc,13062
+Bio/Entrez/DTDs/pubmed_180601.dtd,sha256=ok38f9usTiSV-0_iQcOetobtQS5cHonNWQOgM_Pbb6U,13869
+Bio/Entrez/DTDs/pubmed_190101.dtd,sha256=84BRtNsD6GjVDS7WKSNl1lC2d5PmmwN4BwDwI1LanCM,14576
+Bio/Entrez/DTDs/pubmed_230101.dtd,sha256=TkZv5Njde4wzImi4_aQ9-MOtYqVCRLqjySutwazQaCw,14297
+Bio/Entrez/DTDs/pubmed_240101.dtd,sha256=P520LjqcFh41LY5zAmNxiB4Kjc-Bh-70zPJk_MJLiuM,14624
+Bio/Entrez/DTDs/pubmed_250101.dtd,sha256=jJo8UgJZu3nKh8BAIWcetH_TAGRqoYE72ITEGCF9FXM,14430
+Bio/Entrez/DTDs/references.ent,sha256=VpAcxvqPMQxXGCd0znOX8xAZTKF3nLxcx_0oChQLa3A,40015
+Bio/Entrez/DTDs/section.ent,sha256=DV-jbZDiKokNZNVmCwgeqwYwYjA4Ljsvqei9MUOfjRk,13173
+Bio/Entrez/DTDs/taxon.dtd,sha256=fecg7a0W5zvdn3E2YLbucD6jVV5M1Z2iecyuRfYZ5ZM,4003
+Bio/Entrez/DTDs/xhtml-inlstyle-1.mod,sha256=gbwS95pApcQVeLn9MTH9csLQK11OyNGBkcZDUAbc3V4,1141
+Bio/Entrez/DTDs/xhtml-table-1.mod,sha256=Oetem0tGJ9dBbfi7A5TxAHEd0lL7fPehMW-AzNeQewk,9503
+Bio/Entrez/DTDs/xmlspecchars.ent,sha256=6hVOLeK0wKOtEy7qJqh1-b_z0a_GBRZL7PBKIn8eQpw,13595
+Bio/Entrez/Parser.py,sha256=24E47QFOlNBiNyoBJxldXc0raSta7nMhlbvRQz085uo,46942
+Bio/Entrez/XSDs/IPGReportSet.xsd,sha256=N71qfT3YknPSaTnHdx8VSAPzrDkcuAqQpILeQLJ3bTk,3536
+Bio/Entrez/XSDs/NCBI_BlastOutput2.mod.xsd,sha256=AAMj-wM5qk6ye-LMlTb-DQN60l5Ka1_gJ12_E_U1BPk,12059
+Bio/Entrez/XSDs/NCBI_BlastOutput2.xsd,sha256=yox6a4NST2jKr4hsq6E1NQSKy9m3i_MIbt6ipu3qlnQ,774
+Bio/Entrez/__init__.py,sha256=8e7KjzCrun1wJKtcmhmOfgXvre3eAocdcCRCBeUXkeY,29644
+Bio/Entrez/__pycache__/Parser.cpython-312.pyc,,
+Bio/Entrez/__pycache__/__init__.cpython-312.pyc,,
+Bio/ExPASy/Enzyme.py,sha256=sdjDF6_Da2YnELLRaiQNTltVpUZBHnthHSecDtenyIk,4570
+Bio/ExPASy/Prodoc.py,sha256=Ql5Esgo0rmOiYXvscuznFCdErITLndWFAQdggDnYp88,5009
+Bio/ExPASy/Prosite.py,sha256=X3iA6M2uZNKaGDAEQQiqBpYdyOD11P091fZII6ARYB0,11495
+Bio/ExPASy/ScanProsite.py,sha256=4EgmQTq4YTfilavG1aYUBHK3wZw3B0Vx7fMEhUUaGBY,5284
+Bio/ExPASy/__init__.py,sha256=3Y5zdyliQ21IRxVbKvl6mBPaIKhIK3yoi5MsQ8k7X-E,4357
+Bio/ExPASy/__pycache__/Enzyme.cpython-312.pyc,,
+Bio/ExPASy/__pycache__/Prodoc.cpython-312.pyc,,
+Bio/ExPASy/__pycache__/Prosite.cpython-312.pyc,,
+Bio/ExPASy/__pycache__/ScanProsite.cpython-312.pyc,,
+Bio/ExPASy/__pycache__/__init__.cpython-312.pyc,,
+Bio/ExPASy/__pycache__/cellosaurus.cpython-312.pyc,,
+Bio/ExPASy/cellosaurus.py,sha256=Uqy0t9crZIhJDRMPZn7g-rtnDESvubhhjE9mZ1Y0-1U,6670
+Bio/File.py,sha256=fUMuPiu1Ga6lA2t9uUuKNYUjbxhWFue83L55rOmW9aY,24702
+Bio/GenBank/Record.py,sha256=SFyMTwtna69VKJJYtXT_7G6Bjb7vhMvSmq2vR0cd7fk,23278
+Bio/GenBank/Scanner.py,sha256=5QcncBnSs5DaY6zGrUPbyVjRoEJHNr4ZROadxzONj2g,87392
+Bio/GenBank/__init__.py,sha256=P0kTRl-KHM3Jap2lY3fwxdU9WjE2MMqDqeol7s-V_uE,43718
+Bio/GenBank/__pycache__/Record.cpython-312.pyc,,
+Bio/GenBank/__pycache__/Scanner.cpython-312.pyc,,
+Bio/GenBank/__pycache__/__init__.cpython-312.pyc,,
+Bio/GenBank/__pycache__/utils.cpython-312.pyc,,
+Bio/GenBank/utils.py,sha256=_c9Po0p-Ay1xqcMmC5yaY2KwokMdZqivB-kME5-SqE4,2229
+Bio/Geo/Record.py,sha256=EX7prbB4ZpXvE8gCu7vg7GDTt8IfTW8CrgjyIpUn650,2972
+Bio/Geo/__init__.py,sha256=gfdjcBv6lQ5sab212l-jCzPuK4KTHeZQJDeV8pAq-sg,2176
+Bio/Geo/__pycache__/Record.cpython-312.pyc,,
+Bio/Geo/__pycache__/__init__.cpython-312.pyc,,
+Bio/Graphics/BasicChromosome.py,sha256=gvnILx6mhsH_XYbM8D3el5dXJ8UodLLtBSCSTcIyvNs,31526
+Bio/Graphics/ColorSpiral.py,sha256=1RllyUiU0f_WZ1J229NYqFo_aYp2VDaB_qcDacgGVkE,7349
+Bio/Graphics/Comparative.py,sha256=63R_JmAdrcR0p-PL8nNBnNcT_QOM2KGQu--dNv1Yn2o,6632
+Bio/Graphics/DisplayRepresentation.py,sha256=Tjn1fPHS0FOcooQ4M0h0EiAF6V6eePGfUZdm_tZqA7k,6749
+Bio/Graphics/Distribution.py,sha256=Mg4hS50WbYc3CDmXySdYZE_gz02JSvvica9Zn05ZD2g,9301
+Bio/Graphics/GenomeDiagram/_AbstractDrawer.py,sha256=i4FWKAszkBMAdLLWhYKZiHA5NyGF7QBwPEUL1sXl9gE,18539
+Bio/Graphics/GenomeDiagram/_CircularDrawer.py,sha256=h8o1OIpHkBPElCtyBtfwq1urghXFsLJOiqti2p0WhJE,68783
+Bio/Graphics/GenomeDiagram/_Colors.py,sha256=nw6Eswcq6OwVQZ32WkvQAp7ng7n0RhHclBoV1eBYvPU,9678
+Bio/Graphics/GenomeDiagram/_CrossLink.py,sha256=dwUCIZYVTt1dFepzY4qWP86GEPJ5zrIFXGiJEjM_JuA,3309
+Bio/Graphics/GenomeDiagram/_Diagram.py,sha256=30SLEWndoRgs657YERQB6EQnF3FvTjMqrrA2zA3Xf1o,15633
+Bio/Graphics/GenomeDiagram/_Feature.py,sha256=oW6LPMPIrDtwjhMaeYk7mPyjDC-2MeZLx1nXxzTwHMk,8064
+Bio/Graphics/GenomeDiagram/_FeatureSet.py,sha256=I3N2nIo3LWUmHhY2X5kDNeZDFcvKIg-rtSFTAtgBkZ4,7774
+Bio/Graphics/GenomeDiagram/_Graph.py,sha256=LpzVWx9XUgn2A6_77uG-nuGcSWhgUYGUXjxaRyPWO1s,6838
+Bio/Graphics/GenomeDiagram/_GraphSet.py,sha256=evDWezSVo_9MXt2W1fSp9k7QxonRURG5PBgWorLKKlY,5634
+Bio/Graphics/GenomeDiagram/_LinearDrawer.py,sha256=TeSFV9lD7xHqp4y1C305BDK_U3TG1EGZAe9TNl5hSO8,63449
+Bio/Graphics/GenomeDiagram/_Track.py,sha256=qshNMFoxMFHKh2HHLaoqZP7kZ_RXmVcvxhWFppOQUh0,11662
+Bio/Graphics/GenomeDiagram/__init__.py,sha256=KtXssbsNzeG4tYwgwPua5f9ydF0kp2UX_c2K_qypHiU,1172
+Bio/Graphics/GenomeDiagram/__pycache__/_AbstractDrawer.cpython-312.pyc,,
+Bio/Graphics/GenomeDiagram/__pycache__/_CircularDrawer.cpython-312.pyc,,
+Bio/Graphics/GenomeDiagram/__pycache__/_Colors.cpython-312.pyc,,
+Bio/Graphics/GenomeDiagram/__pycache__/_CrossLink.cpython-312.pyc,,
+Bio/Graphics/GenomeDiagram/__pycache__/_Diagram.cpython-312.pyc,,
+Bio/Graphics/GenomeDiagram/__pycache__/_Feature.cpython-312.pyc,,
+Bio/Graphics/GenomeDiagram/__pycache__/_FeatureSet.cpython-312.pyc,,
+Bio/Graphics/GenomeDiagram/__pycache__/_Graph.cpython-312.pyc,,
+Bio/Graphics/GenomeDiagram/__pycache__/_GraphSet.cpython-312.pyc,,
+Bio/Graphics/GenomeDiagram/__pycache__/_LinearDrawer.cpython-312.pyc,,
+Bio/Graphics/GenomeDiagram/__pycache__/_Track.cpython-312.pyc,,
+Bio/Graphics/GenomeDiagram/__pycache__/__init__.cpython-312.pyc,,
+Bio/Graphics/KGML_vis.py,sha256=OkI6oIkzQeVsxXk-RyzmIZM5BVij5APKcODE_YKPkeQ,17637
+Bio/Graphics/__init__.py,sha256=43mq7-w22n_AGlQkOqqrr6o--DoETbevHRwgHHDQNLA,3300
+Bio/Graphics/__pycache__/BasicChromosome.cpython-312.pyc,,
+Bio/Graphics/__pycache__/ColorSpiral.cpython-312.pyc,,
+Bio/Graphics/__pycache__/Comparative.cpython-312.pyc,,
+Bio/Graphics/__pycache__/DisplayRepresentation.cpython-312.pyc,,
+Bio/Graphics/__pycache__/Distribution.cpython-312.pyc,,
+Bio/Graphics/__pycache__/KGML_vis.cpython-312.pyc,,
+Bio/Graphics/__pycache__/__init__.cpython-312.pyc,,
+Bio/HMM/__init__.py,sha256=okwrOJ6vAlLIJrAUERUWS31R8rN1EUQvcXlUr0T1FQo,283
+Bio/HMM/__pycache__/__init__.cpython-312.pyc,,
+Bio/KEGG/Compound/__init__.py,sha256=Ezkr17o6MC_3SrziqWzvjhTgAH3-ZxuRbSNh-fQFrqU,5470
+Bio/KEGG/Compound/__pycache__/__init__.cpython-312.pyc,,
+Bio/KEGG/Enzyme/__init__.py,sha256=2vdcLAeM3tnuUH6rH_musgToOm14hScEtrBSy4MA8f8,11185
+Bio/KEGG/Enzyme/__pycache__/__init__.cpython-312.pyc,,
+Bio/KEGG/Gene/__init__.py,sha256=bRw6lqK2qgU1-oSoJgmmM_crsG4qfbQFoIuJJorTdno,4288
+Bio/KEGG/Gene/__pycache__/__init__.cpython-312.pyc,,
+Bio/KEGG/KGML/KGML_parser.py,sha256=CFuPIqGfoUdzbyyO7AYjq1dOboKuEfxmJPukiClNp5E,6347
+Bio/KEGG/KGML/KGML_pathway.py,sha256=yNohdxjYB3aByjc5ncrfpeCU3jtb5J98SXeEszOU300,27600
+Bio/KEGG/KGML/__init__.py,sha256=ukRQD0nvdi63W3GSkea6JBvESgr-glQK-_0If6CdDro,516
+Bio/KEGG/KGML/__pycache__/KGML_parser.cpython-312.pyc,,
+Bio/KEGG/KGML/__pycache__/KGML_pathway.cpython-312.pyc,,
+Bio/KEGG/KGML/__pycache__/__init__.cpython-312.pyc,,
+Bio/KEGG/Map/__init__.py,sha256=1fC5kUk2y3gBg8U0amU03LBQzk0n5-i9WRAnAizSOM0,1642
+Bio/KEGG/Map/__pycache__/__init__.cpython-312.pyc,,
+Bio/KEGG/REST.py,sha256=Var39F7iAs4w6EchIIjteksdnCgNjAxMeUXG6J8d2TE,11302
+Bio/KEGG/__init__.py,sha256=R9b11HHpx7j_5R1Zh3RcqYVn18Ge0fQn5ecdXNP681g,3038
+Bio/KEGG/__pycache__/REST.cpython-312.pyc,,
+Bio/KEGG/__pycache__/__init__.cpython-312.pyc,,
+Bio/Medline/__init__.py,sha256=v8wuyY_BI2HS_XPrR_wiZdTgQG-kmTUYIKtZamVV058,6272
+Bio/Medline/__pycache__/__init__.cpython-312.pyc,,
+Bio/NMR/NOEtools.py,sha256=ivb_vEtACYGL3rmTsUL-gQEwbMuV_vfFV-pcSd-2EdA,3353
+Bio/NMR/__init__.py,sha256=Nh9dRG4raRrtUIZt1NA_7hQ0IylsA8Wt7iPlOfHiZqc,332
+Bio/NMR/__pycache__/NOEtools.cpython-312.pyc,,
+Bio/NMR/__pycache__/__init__.cpython-312.pyc,,
+Bio/NMR/__pycache__/xpktools.cpython-312.pyc,,
+Bio/NMR/xpktools.py,sha256=x0pZrA8aE2Ux9b3WLooMMypy2y1yYMVA8w1K1oOK-SM,9274
+Bio/Nexus/Nexus.py,sha256=bAcaX1GtllyPnYXPRS9XfPInbEX5HevpYROxkncGCWI,83879
+Bio/Nexus/Nodes.py,sha256=_4ISSokpZzxsl8ttvC6TKsufDRKkzqCtvm7R5rp3IFc,5828
+Bio/Nexus/StandardData.py,sha256=Oa3cGxQ7a4tbNHUny9s6f4rY-4R1PjnwIX9az6B-MWA,3996
+Bio/Nexus/Trees.py,sha256=U4AWSE1Quj-xHDyzp2SXFN_0uHKP-tj9ui7HZrh-Los,40311
+Bio/Nexus/__init__.py,sha256=ngZ2q80ta5PB-RTcmHVpf3HMlpIKN3uLBB3f_z2648g,388
+Bio/Nexus/__pycache__/Nexus.cpython-312.pyc,,
+Bio/Nexus/__pycache__/Nodes.cpython-312.pyc,,
+Bio/Nexus/__pycache__/StandardData.cpython-312.pyc,,
+Bio/Nexus/__pycache__/Trees.cpython-312.pyc,,
+Bio/Nexus/__pycache__/__init__.cpython-312.pyc,,
+Bio/Nexus/cnexus.c,sha256=LWFHaUPHuaH44gx6m2u3oY0tp7KL1HciHhWjxPa5ojY,3741
+Bio/Nexus/cnexus.cpython-312-darwin.so,sha256=nAm_WSg7yWo1Fu_EOuF15vcBaOw8RDKYdOTQlS6KMhg,50880
+Bio/PDB/AbstractPropertyMap.py,sha256=4xW0sC-UUBFfqtcUsMYcA7XmMGfkkKPhvw_U6EDlw6g,4080
+Bio/PDB/Atom.py,sha256=rE26TKAU-fNkjgEtaIhfmJkOksw1Cdrv7T1xi-hgfzs,20424
+Bio/PDB/Chain.py,sha256=l1EZNpHNERvbqnUN2pfYX6f2Ho1Zyz_Y0cQjvvG_wzM,7101
+Bio/PDB/DSSP.py,sha256=V-dZoMQXlgr5XJ4GD7QnU_XI9ZzjjOsx-1C7qDlwUMI,20210
+Bio/PDB/Dice.py,sha256=6i-rMhTr1GCzosccoOnrimApJN28N20lLW8A9t_CKFQ,2315
+Bio/PDB/Entity.py,sha256=SH0PEO3oS0wLkSpyEIvoKDDIZ_NE28CC_gsZfrHdR2I,18506
+Bio/PDB/FragmentMapper.py,sha256=2bM9vuNvbHnjmZcuDIGTYePIneOggsK_2zdh9AfXrzw,9621
+Bio/PDB/HSExposure.py,sha256=uNC36Byn5tW-fMttn7DTqLxtXBpYS2aNIh6q1omTR2c,11337
+Bio/PDB/MMCIF2Dict.py,sha256=C0GGBvX-qQpIQfVLlBXr1zUWd_CmcMVenE7EqvcqPYo,5063
+Bio/PDB/MMCIFParser.py,sha256=0NFbbSDi3jCt3Nl9VAJcMBAdHvciZCXif1iKHjwDe7M,25471
+Bio/PDB/Model.py,sha256=9jlTAdzmpdAm10BGCratNJCnsEklaRcqOGIpkxUdscY,2358
+Bio/PDB/NACCESS.py,sha256=uoevihcnPjdi-KAoncAS2reDQBXrUcNUQPULqOuUCqQ,7219
+Bio/PDB/NeighborSearch.py,sha256=3HKwxAuvcznxflAImQzAeREtNbfKKV7aqXUPHNalOsk,4490
+Bio/PDB/PDBExceptions.py,sha256=Zg5aQWKFIDFHOd5Ynh65auHJXp967PWSIbqaEzL10Iw,934
+Bio/PDB/PDBIO.py,sha256=cb5hVhWLaVGAVXquZosDTJCAXZGzyN1u7hfgoHWYSAo,16445
+Bio/PDB/PDBList.py,sha256=rj315ZxYZXMiqJo12K0r2dItSf0754Ff0-K8-ezcKlc,31347
+Bio/PDB/PDBMLParser.py,sha256=3hOtdAOSXPZf9x21sIr6CmBPK4YXZsqFHBDooRF_mts,6858
+Bio/PDB/PDBParser.py,sha256=u0D-TlIrjyMy0rLpRFyl5lf4eTFnh6VPl5tgM7T5brc,17185
+Bio/PDB/PICIO.py,sha256=T2ULeIhoq9VA3GqnKGKUlWGmGiAhXMlDSRpNa8OZE6Y,41280
+Bio/PDB/PSEA.py,sha256=lnLfeYNItavkJzE8YNwp5M9JrPCbnentURk4yuCw7ZQ,3141
+Bio/PDB/Polypeptide.py,sha256=iD3f4MG6y5h1UfbtMZrwEBpWRQCiGe6FpycaFJCBreA,14220
+Bio/PDB/Residue.py,sha256=586-gp0Psi1wkciYpUW4yZBu8R2WEJNedv59iBfz3Ag,6395
+Bio/PDB/ResidueDepth.py,sha256=5_59-WIdwTnulnVlm33JLIe7sBi8Um97BvtYhViLAu4,22252
+Bio/PDB/SASA.py,sha256=8IPAOSc_4Uhghpwwr_n0hkKkxZMfQ8sLCJ9OxkTJT08,8505
+Bio/PDB/SCADIO.py,sha256=o9hReAxg3xhQlZbDPWIa0npjxCKnDzcV58fKsXenCLs,35847
+Bio/PDB/Selection.py,sha256=EnmaQGGPyIbz4rOnnUlAxeMmuHSOxsZzRIOW020wRgI,2589
+Bio/PDB/Structure.py,sha256=-9aSoKFlx9p7sGw9hAz2P_bGFOX1Q86Acolty8ljvds,2147
+Bio/PDB/StructureAlignment.py,sha256=CLyJT66r-zMyRaAZ4OJb42YmfBjimCW9mwYwzQScWU4,7021
+Bio/PDB/StructureBuilder.py,sha256=zTPwI3_S_a8SMvlXpnDxNmCp01J0hKsNSvrZcsICidA,12137
+Bio/PDB/Superimposer.py,sha256=GDH3mSgA3P6v7RNdiOtwHRrCJpCIdHhKv1eN24T-9tY,1943
+Bio/PDB/__init__.py,sha256=KIynAABv3lQBZRnOje4YlOyUgK6I8QT9xCbUS-2_bLw,3092
+Bio/PDB/__pycache__/AbstractPropertyMap.cpython-312.pyc,,
+Bio/PDB/__pycache__/Atom.cpython-312.pyc,,
+Bio/PDB/__pycache__/Chain.cpython-312.pyc,,
+Bio/PDB/__pycache__/DSSP.cpython-312.pyc,,
+Bio/PDB/__pycache__/Dice.cpython-312.pyc,,
+Bio/PDB/__pycache__/Entity.cpython-312.pyc,,
+Bio/PDB/__pycache__/FragmentMapper.cpython-312.pyc,,
+Bio/PDB/__pycache__/HSExposure.cpython-312.pyc,,
+Bio/PDB/__pycache__/MMCIF2Dict.cpython-312.pyc,,
+Bio/PDB/__pycache__/MMCIFParser.cpython-312.pyc,,
+Bio/PDB/__pycache__/Model.cpython-312.pyc,,
+Bio/PDB/__pycache__/NACCESS.cpython-312.pyc,,
+Bio/PDB/__pycache__/NeighborSearch.cpython-312.pyc,,
+Bio/PDB/__pycache__/PDBExceptions.cpython-312.pyc,,
+Bio/PDB/__pycache__/PDBIO.cpython-312.pyc,,
+Bio/PDB/__pycache__/PDBList.cpython-312.pyc,,
+Bio/PDB/__pycache__/PDBMLParser.cpython-312.pyc,,
+Bio/PDB/__pycache__/PDBParser.cpython-312.pyc,,
+Bio/PDB/__pycache__/PICIO.cpython-312.pyc,,
+Bio/PDB/__pycache__/PSEA.cpython-312.pyc,,
+Bio/PDB/__pycache__/Polypeptide.cpython-312.pyc,,
+Bio/PDB/__pycache__/Residue.cpython-312.pyc,,
+Bio/PDB/__pycache__/ResidueDepth.cpython-312.pyc,,
+Bio/PDB/__pycache__/SASA.cpython-312.pyc,,
+Bio/PDB/__pycache__/SCADIO.cpython-312.pyc,,
+Bio/PDB/__pycache__/Selection.cpython-312.pyc,,
+Bio/PDB/__pycache__/Structure.cpython-312.pyc,,
+Bio/PDB/__pycache__/StructureAlignment.cpython-312.pyc,,
+Bio/PDB/__pycache__/StructureBuilder.cpython-312.pyc,,
+Bio/PDB/__pycache__/Superimposer.cpython-312.pyc,,
+Bio/PDB/__pycache__/__init__.cpython-312.pyc,,
+Bio/PDB/__pycache__/alphafold_db.cpython-312.pyc,,
+Bio/PDB/__pycache__/binary_cif.cpython-312.pyc,,
+Bio/PDB/__pycache__/cealign.cpython-312.pyc,,
+Bio/PDB/__pycache__/ic_data.cpython-312.pyc,,
+Bio/PDB/__pycache__/ic_rebuild.cpython-312.pyc,,
+Bio/PDB/__pycache__/internal_coords.cpython-312.pyc,,
+Bio/PDB/__pycache__/mmcifio.cpython-312.pyc,,
+Bio/PDB/__pycache__/parse_pdb_header.cpython-312.pyc,,
+Bio/PDB/__pycache__/qcprot.cpython-312.pyc,,
+Bio/PDB/__pycache__/vectors.cpython-312.pyc,,
+Bio/PDB/_bcif_helper.cpython-312-darwin.so,sha256=PrhXEfJIruVwQHe2X1vbgzw99txH3-zVFRJUB5Y4u8E,51424
+Bio/PDB/alphafold_db.py,sha256=Iv0Iy0v3CWpSwLO98uESFmw2lkdYtj5GsLf78gBZ1oo,3991
+Bio/PDB/bcifhelpermodule.c,sha256=CDYshdZg_5X-lZDtkeexoNiH1V2JDacV-qT9kmqVYds,4816
+Bio/PDB/binary_cif.py,sha256=iuGPZvTHZY4P2GlcR_E9_gWl6z49jXcSubNcfrKFxu4,10229
+Bio/PDB/ccealign.cpython-312-darwin.so,sha256=lJXFpAUDHO7Q38malC0EXHdk6xmpa8bvlovQDqTTR6I,52256
+Bio/PDB/ccealignmodule.c,sha256=T1n8HK0IGORAElHC0OUsUzmgLjcjB5g8ZjTrkTD8NOs,26731
+Bio/PDB/cealign.py,sha256=DJsfZ6tcSbY79xKE0m-rVjhOysQqIU_zOFQ1rOvVQV0,7535
+Bio/PDB/ic_data.py,sha256=_yXXal4_LU4DVr61WBLgU2JN6qwcm51p7Akn5pi5aHQ,59270
+Bio/PDB/ic_rebuild.py,sha256=8HvehhUTm36TdaN_KWLbGggBUfG3Yi3K43nhEFklIoo,18341
+Bio/PDB/internal_coords.py,sha256=Yw928UOvsTB6RaK6luknG20KbkgYpfUcBS01GbyrK74,188712
+Bio/PDB/kdtrees.c,sha256=RZP17Wur4pOmhFvArz8G9RmAcSQHZPSK6gZuGoCgPNQ,38489
+Bio/PDB/kdtrees.cpython-312-darwin.so,sha256=dBSfbK0vVYhlN1SELqPJHbXwTKYStmXaqzTo2rsLefE,55056
+Bio/PDB/mmcifio.py,sha256=VLG9DjpF-LMMPnc8z_vpBpXuI7vEqbcPo7D9hlFhEO8,15454
+Bio/PDB/mmtf/DefaultParser.py,sha256=9AFF9xVj0ruenFJy-qFU19R6P4NoNQ7idJa8oMGU26Y,8888
+Bio/PDB/mmtf/__init__.py,sha256=J24rQXRAxb43roQx7RZvitT85abXUKIfOO1BmPPcWTE,1568
+Bio/PDB/mmtf/__pycache__/DefaultParser.cpython-312.pyc,,
+Bio/PDB/mmtf/__pycache__/__init__.cpython-312.pyc,,
+Bio/PDB/mmtf/__pycache__/mmtfio.cpython-312.pyc,,
+Bio/PDB/mmtf/mmtfio.py,sha256=40X-U24c1KtZYDMTaLPWBFjK97ZveV-_9I4Ck5Mqeik,11174
+Bio/PDB/parse_pdb_header.py,sha256=wjUBgHLnqAojAMCftFofJGNTU9gAJerD6i-VWAZwYb0,13618
+Bio/PDB/qcprot.py,sha256=6TiN_JayaSeRfhEAAoXHLpwbZt5pBalIYUj4ctKx_uM,12295
+Bio/PDB/vectors.py,sha256=u57Y4V6Ppkz11kTggWLOB10TqaKqx23h-uKK4GI-LWc,20145
+Bio/Pathway/Rep/Graph.py,sha256=nrtXU1tSCBYSzQLC72-JADXtgn3GaLGE8PGJSBOvbo0,5865
+Bio/Pathway/Rep/MultiGraph.py,sha256=wvjmawcQoAqOYJHJwXgok8OGSM1EDXGweitvuF5PPkU,6779
+Bio/Pathway/Rep/__init__.py,sha256=at4OJza1C4g5QTYe0DWPYHyH_PjXNKRWapNINfVB4ig,575
+Bio/Pathway/Rep/__pycache__/Graph.cpython-312.pyc,,
+Bio/Pathway/Rep/__pycache__/MultiGraph.cpython-312.pyc,,
+Bio/Pathway/Rep/__pycache__/__init__.cpython-312.pyc,,
+Bio/Pathway/__init__.py,sha256=bPdJG_Wxz2ygj4rq2mjom0YVkmADB5ydseudrj45Z3U,10763
+Bio/Pathway/__pycache__/__init__.cpython-312.pyc,,
+Bio/Phylo/BaseTree.py,sha256=N69rc175o0NwoxfsWUl0__bJYHKHud2SYYDiT59_o94,44799
+Bio/Phylo/CDAO.py,sha256=zJfBYZBdA4LhMW9JSQ_phD_cgIxXQfWUfKLtdgtTbSY,1662
+Bio/Phylo/CDAOIO.py,sha256=w0DsTBMLm2egoLZ9EhMnqv5yE-SxK5pB97T0Zyj1Z2I,16066
+Bio/Phylo/Consensus.py,sha256=XDwwRs68NC5KsTGl51R2k248sAyoCecrMwmi-pjTMjQ,24305
+Bio/Phylo/NeXML.py,sha256=boHxjwQjFtTi60P7tbqvjiqgJ8YvlJAlrzW7vTZFriE,1404
+Bio/Phylo/NeXMLIO.py,sha256=TClB94T1wsvSqdZ9CNG0AoeijSrkeIb-ZMwXV5cGTjE,10974
+Bio/Phylo/Newick.py,sha256=Z3dOQM0GdqD3Vtlonn5vGLIGxs0fOYogrMOEK4_0bj4,1298
+Bio/Phylo/NewickIO.py,sha256=KUtLtvtxd86t2JfCvUAsvIomA8h8Xx06fSXqVsZ9Jyg,12911
+Bio/Phylo/NexusIO.py,sha256=6W3MIGuRDNixAkqQ-HfB3tiDIkK6m6ng-d5ncYmAC2s,2672
+Bio/Phylo/PAML/__init__.py,sha256=Wlo4XIDffJhmHZm1zpQ3l1PT-STCKQIE0JERLVcBCaY,325
+Bio/Phylo/PAML/__pycache__/__init__.cpython-312.pyc,,
+Bio/Phylo/PAML/__pycache__/_paml.cpython-312.pyc,,
+Bio/Phylo/PAML/__pycache__/_parse_baseml.cpython-312.pyc,,
+Bio/Phylo/PAML/__pycache__/_parse_codeml.cpython-312.pyc,,
+Bio/Phylo/PAML/__pycache__/_parse_yn00.cpython-312.pyc,,
+Bio/Phylo/PAML/__pycache__/baseml.cpython-312.pyc,,
+Bio/Phylo/PAML/__pycache__/chi2.cpython-312.pyc,,
+Bio/Phylo/PAML/__pycache__/codeml.cpython-312.pyc,,
+Bio/Phylo/PAML/__pycache__/yn00.cpython-312.pyc,,
+Bio/Phylo/PAML/_paml.py,sha256=AxKMp6BmzEiz9cS7N9OhcJNLKUza_4AUE-cpC0GX5QM,5118
+Bio/Phylo/PAML/_parse_baseml.py,sha256=icHahwSmYnWVd8xCpoWxf1oVRIG_7Kq6RC8awXSCiSs,11408
+Bio/Phylo/PAML/_parse_codeml.py,sha256=lDHO5sx7LJFsq_vUlsgBxz2wbK_64fDGOZhhEVzk6XY,21149
+Bio/Phylo/PAML/_parse_yn00.py,sha256=_3X3fMZKAOrGWI2h7nnBU3YS2WhHz3dZncEtPdoXbn8,6820
+Bio/Phylo/PAML/baseml.py,sha256=WOXc-nBPwzrKRT74Y_iak-9n54nBBdjNzXZRqM4W8bo,8719
+Bio/Phylo/PAML/chi2.py,sha256=rOGetcZeZ_GW-YlTy_GKli_4dYEsHH5NQYxJNlFfPws,3743
+Bio/Phylo/PAML/codeml.py,sha256=z7MMMNDCjVJvTjzAMHJ0tdg59584xvdCLyKESRYSr1s,9371
+Bio/Phylo/PAML/yn00.py,sha256=dY_Z7I2DyhYYd4O6OP__cQDZCt6PRekjOGNcUsOao24,6168
+Bio/Phylo/PhyloXML.py,sha256=ckZGwnOgidFcHEIkS-SWIT1Xkeyl5S8i3o7OV6XoUyg,46829
+Bio/Phylo/PhyloXMLIO.py,sha256=hKesIc4S5xNob3cMQgthf8qF8i9RFqAHr-HEqm_Bh0E,32340
+Bio/Phylo/TreeConstruction.py,sha256=iFBHLPWgpzxeTpGv6fI7jgXOoHc_idLPKyfvdn6fFRY,48988
+Bio/Phylo/__init__.py,sha256=I9sH2KCL5_Q2WwbLm-r9Fs20eSdQemAWmQO2Y0-pUOI,683
+Bio/Phylo/__pycache__/BaseTree.cpython-312.pyc,,
+Bio/Phylo/__pycache__/CDAO.cpython-312.pyc,,
+Bio/Phylo/__pycache__/CDAOIO.cpython-312.pyc,,
+Bio/Phylo/__pycache__/Consensus.cpython-312.pyc,,
+Bio/Phylo/__pycache__/NeXML.cpython-312.pyc,,
+Bio/Phylo/__pycache__/NeXMLIO.cpython-312.pyc,,
+Bio/Phylo/__pycache__/Newick.cpython-312.pyc,,
+Bio/Phylo/__pycache__/NewickIO.cpython-312.pyc,,
+Bio/Phylo/__pycache__/NexusIO.cpython-312.pyc,,
+Bio/Phylo/__pycache__/PhyloXML.cpython-312.pyc,,
+Bio/Phylo/__pycache__/PhyloXMLIO.cpython-312.pyc,,
+Bio/Phylo/__pycache__/TreeConstruction.cpython-312.pyc,,
+Bio/Phylo/__pycache__/__init__.cpython-312.pyc,,
+Bio/Phylo/__pycache__/_cdao_owl.cpython-312.pyc,,
+Bio/Phylo/__pycache__/_io.cpython-312.pyc,,
+Bio/Phylo/__pycache__/_utils.cpython-312.pyc,,
+Bio/Phylo/_cdao_owl.py,sha256=iC54sav9Hr0GAvnvR6SCGGJtbzFz93t4iJ98i7UVsGs,109367
+Bio/Phylo/_io.py,sha256=gu3_melHtwVGHVe0pcLfBxKkiQW0h2xkcEd2sF2w-YI,2678
+Bio/Phylo/_utils.py,sha256=ydw3YO4xWdTPVWQ0rWiJA9_9Grh6Z3a0-1q6mCFAhew,22303
+Bio/PopGen/GenePop/FileParser.py,sha256=XOuLzb19tYC2l9kfEClh1DFN7WukxRkRAqaJ-gS3sBk,11861
+Bio/PopGen/GenePop/LargeFileParser.py,sha256=IOH8yfg02lB-wUZheXDXPE1L3dAnUAQJ-UWql25oLBg,3919
+Bio/PopGen/GenePop/__init__.py,sha256=_zZsbbWImQpUY4SfTR_UZ9j1M96-iqNMQcI8pnyuT30,7462
+Bio/PopGen/GenePop/__pycache__/FileParser.cpython-312.pyc,,
+Bio/PopGen/GenePop/__pycache__/LargeFileParser.cpython-312.pyc,,
+Bio/PopGen/GenePop/__pycache__/__init__.cpython-312.pyc,,
+Bio/PopGen/__init__.py,sha256=SWc6kj2QqJnhoB6P7AzcfiSj9HIBXt65aHSZLMdLsCU,359
+Bio/PopGen/__pycache__/__init__.cpython-312.pyc,,
+Bio/Restriction/PrintFormat.py,sha256=vmHyuQG2r6URF9-N_N8_LURWYdeRm-PKv4EMJRg98i0,16232
+Bio/Restriction/Restriction.py,sha256=JMLrSJR80C0nmzjSyKkt9W3vpG7KOoAaImdKYDrQTSs,83609
+Bio/Restriction/Restriction_Dictionary.py,sha256=KnkJkpXbrWBh6mehHgU3h8WR_LLrEPyMD4nq2QjfoCs,562312
+Bio/Restriction/__init__.py,sha256=PWWjOJk8zs9wFk43IRplNMKtBE0wa40QGpf93SZkvcQ,7846
+Bio/Restriction/__pycache__/PrintFormat.cpython-312.pyc,,
+Bio/Restriction/__pycache__/Restriction.cpython-312.pyc,,
+Bio/Restriction/__pycache__/Restriction_Dictionary.cpython-312.pyc,,
+Bio/Restriction/__pycache__/__init__.cpython-312.pyc,,
+Bio/SCOP/Cla.py,sha256=QQaaTRm8MhgkIc9kmWjzSBJzDZ8yPflzqGPahGPOkYE,3922
+Bio/SCOP/Des.py,sha256=E01r8L7xyH4u_pE_BdQWfgLZQzjxxy9yNQlK_wMms8E,3004
+Bio/SCOP/Dom.py,sha256=n2Vz4JCwgp1KYPCdWIHqnz3ox5zVapFKiikAmMtRBHU,2466
+Bio/SCOP/Hie.py,sha256=V89zuR10IszC0g1ElG9kJ4l18AmX7k8IiPuld5TbXPM,2963
+Bio/SCOP/Raf.py,sha256=5alSIWZ8cChAcbLJ-WdiJ78OJq4UOXKWD6pu0QTvEK4,10317
+Bio/SCOP/Residues.py,sha256=B6uF848LZAhqP_arxU6y20Wf5vghMPtX2t_6YRBP88k,3083
+Bio/SCOP/__init__.py,sha256=c3hBShiNDaIyiFMkAyvPHWDVgdLWkKMz3cD8UPaQER0,31276
+Bio/SCOP/__pycache__/Cla.cpython-312.pyc,,
+Bio/SCOP/__pycache__/Des.cpython-312.pyc,,
+Bio/SCOP/__pycache__/Dom.cpython-312.pyc,,
+Bio/SCOP/__pycache__/Hie.cpython-312.pyc,,
+Bio/SCOP/__pycache__/Raf.cpython-312.pyc,,
+Bio/SCOP/__pycache__/Residues.cpython-312.pyc,,
+Bio/SCOP/__pycache__/__init__.cpython-312.pyc,,
+Bio/SVDSuperimposer/__init__.py,sha256=tx50Pd3Ze2JlwzJElQLx0tvKadmtyBOa3Fgkll8JQrE,6256
+Bio/SVDSuperimposer/__pycache__/__init__.cpython-312.pyc,,
+Bio/SearchIO/BlastIO/__init__.py,sha256=ucZ_p5ltygjjeP4_BNzCyMF-nF-t_yT3qTWde58xKjE,17923
+Bio/SearchIO/BlastIO/__pycache__/__init__.cpython-312.pyc,,
+Bio/SearchIO/BlastIO/__pycache__/blast_tab.cpython-312.pyc,,
+Bio/SearchIO/BlastIO/__pycache__/blast_xml.cpython-312.pyc,,
+Bio/SearchIO/BlastIO/blast_tab.py,sha256=Xh_B0zTNnFmCukINkyx2ZfuCnOp2oeEnO4kUkJpK91Q,33824
+Bio/SearchIO/BlastIO/blast_xml.py,sha256=236zeNwhlmVIb0c5xrCh2pQS0kgamoGCB72B-iGgu60,37031
+Bio/SearchIO/BlatIO.py,sha256=bKLnyCRGVnIp592mGUhAt2BApPY0uyC6h-coz97kUf8,31398
+Bio/SearchIO/ExonerateIO/__init__.py,sha256=R4mdx-hmQ-GY_RSnZRrF2PiOcJYeaBr4ehvhwUl9V5E,13047
+Bio/SearchIO/ExonerateIO/__pycache__/__init__.cpython-312.pyc,,
+Bio/SearchIO/ExonerateIO/__pycache__/_base.cpython-312.pyc,,
+Bio/SearchIO/ExonerateIO/__pycache__/exonerate_cigar.cpython-312.pyc,,
+Bio/SearchIO/ExonerateIO/__pycache__/exonerate_text.cpython-312.pyc,,
+Bio/SearchIO/ExonerateIO/__pycache__/exonerate_vulgar.cpython-312.pyc,,
+Bio/SearchIO/ExonerateIO/_base.py,sha256=j7nW9rqQ3TlGr_ZLJXJIFz7PKjtwkMVNwvKHSSP65Bw,21071
+Bio/SearchIO/ExonerateIO/exonerate_cigar.py,sha256=C7qLNaMMeeWpt7jIDFMTTw2BVLUjNn2O4mTeg1gGCeM,4106
+Bio/SearchIO/ExonerateIO/exonerate_text.py,sha256=2iZbeVHy6iFhJNTa4khDzag7vLql8g__1nOpEmJV1ZE,20463
+Bio/SearchIO/ExonerateIO/exonerate_vulgar.py,sha256=OymbeXbgHFyEgvbB2_E9bwQQbqq7TxAy-sBxONVMFvE,8307
+Bio/SearchIO/FastaIO.py,sha256=9-TItA1-b5cpp1cFmbMZzdZsYtAXwWZrL_U3DFSxLEU,25993
+Bio/SearchIO/HHsuiteIO/__init__.py,sha256=Uwu-QC0n7JZwEEFqbCoXsmAjiColuhLRZlWHJjx0_O0,639
+Bio/SearchIO/HHsuiteIO/__pycache__/__init__.cpython-312.pyc,,
+Bio/SearchIO/HHsuiteIO/__pycache__/hhsuite2_text.cpython-312.pyc,,
+Bio/SearchIO/HHsuiteIO/hhsuite2_text.py,sha256=OmDl977VgdlewVKAfr-pcwCm6kNQA9DPFZ6b_3Shap8,9354
+Bio/SearchIO/HmmerIO/__init__.py,sha256=RpjGWuRZOqb_z93d_xEwEAGgrxEB8lQCOSKvYMALIIw,20466
+Bio/SearchIO/HmmerIO/__pycache__/__init__.cpython-312.pyc,,
+Bio/SearchIO/HmmerIO/__pycache__/_base.cpython-312.pyc,,
+Bio/SearchIO/HmmerIO/__pycache__/hmmer2_text.cpython-312.pyc,,
+Bio/SearchIO/HmmerIO/__pycache__/hmmer3_domtab.cpython-312.pyc,,
+Bio/SearchIO/HmmerIO/__pycache__/hmmer3_tab.cpython-312.pyc,,
+Bio/SearchIO/HmmerIO/__pycache__/hmmer3_text.cpython-312.pyc,,
+Bio/SearchIO/HmmerIO/_base.py,sha256=qSiP2JbGjWPOXuWsvN2F7gSPOZTbyAzHj5CvRFtmWoo,1482
+Bio/SearchIO/HmmerIO/hmmer2_text.py,sha256=A5_YMdp-ugLORE4AY5kk8MCmFDBjxXoaO15OJeENBbc,12932
+Bio/SearchIO/HmmerIO/hmmer3_domtab.py,sha256=magDmjA-r3S2_dfWq93TBP2aFQ9ezZQCJdSVaN_4vIY,14071
+Bio/SearchIO/HmmerIO/hmmer3_tab.py,sha256=ElBtEi4dtO56Ne_BnahnLxzHJl8p9091MChy3XX09U4,12910
+Bio/SearchIO/HmmerIO/hmmer3_text.py,sha256=M7VcbL42350ZwwL2kX5noxUousAIIgbOLCU_eTKb1qY,20043
+Bio/SearchIO/InfernalIO/__init__.py,sha256=xF4wQKNLbfTMiKFL6NmU-sgSphriy_0aXlN9ngzPoyY,15555
+Bio/SearchIO/InfernalIO/__pycache__/__init__.cpython-312.pyc,,
+Bio/SearchIO/InfernalIO/__pycache__/_base.cpython-312.pyc,,
+Bio/SearchIO/InfernalIO/__pycache__/infernal_tab.cpython-312.pyc,,
+Bio/SearchIO/InfernalIO/__pycache__/infernal_text.cpython-312.pyc,,
+Bio/SearchIO/InfernalIO/_base.py,sha256=w_itxTD5azRfaA3PCZ13UYRq6t4TEg2BzA-WjnST5Fc,1415
+Bio/SearchIO/InfernalIO/infernal_tab.py,sha256=tlJZ7DQ672DfHlL7AJI3E9qiJG61T8dhsOU5ngeaJ0o,14947
+Bio/SearchIO/InfernalIO/infernal_text.py,sha256=jchZqcR-pep7NzWycllszemlQX0sr1UcKeFQSFYeCCY,21628
+Bio/SearchIO/InterproscanIO/__init__.py,sha256=bnQbZAEmthvBubnQn6tu0nCovgYmCS1eVdxs7cC83Kw,5155
+Bio/SearchIO/InterproscanIO/__pycache__/__init__.cpython-312.pyc,,
+Bio/SearchIO/InterproscanIO/__pycache__/interproscan_xml.cpython-312.pyc,,
+Bio/SearchIO/InterproscanIO/interproscan_xml.py,sha256=sDeP_ssPvhifYzZ2sta4ils2DzqB4WunEUQw9D2Shuk,7547
+Bio/SearchIO/__init__.py,sha256=rvNn0BsWNe_PrQ_fhnvwCVBupcWDi_tcYf8uQDOsohg,29177
+Bio/SearchIO/__pycache__/BlatIO.cpython-312.pyc,,
+Bio/SearchIO/__pycache__/FastaIO.cpython-312.pyc,,
+Bio/SearchIO/__pycache__/__init__.cpython-312.pyc,,
+Bio/SearchIO/__pycache__/_index.cpython-312.pyc,,
+Bio/SearchIO/__pycache__/_utils.cpython-312.pyc,,
+Bio/SearchIO/_index.py,sha256=KGWJfTcPTWPyv7HxVjebifl_jsFqIKxJNUdz327rLgw,1233
+Bio/SearchIO/_model/__init__.py,sha256=sE-9oUiX0HdKUC_Z0njFA7giJrlDUUAfczNvnDfJh3s,2479
+Bio/SearchIO/_model/__pycache__/__init__.cpython-312.pyc,,
+Bio/SearchIO/_model/__pycache__/_base.cpython-312.pyc,,
+Bio/SearchIO/_model/__pycache__/hit.cpython-312.pyc,,
+Bio/SearchIO/_model/__pycache__/hsp.cpython-312.pyc,,
+Bio/SearchIO/_model/__pycache__/query.cpython-312.pyc,,
+Bio/SearchIO/_model/_base.py,sha256=NEVzhcvyY79M-ByUjdz9WmDtRu1xMMC8Pf_a1na1aHo,2671
+Bio/SearchIO/_model/hit.py,sha256=gXAkhuGNv7eSrlTA18nf7eqaGdCCmBxkc3Dc4fyTGIs,17396
+Bio/SearchIO/_model/hsp.py,sha256=XDuwCr30WxKv1nbUt1Ii6Ywlj-c7-s7ql3j8ZFqW0CU,48308
+Bio/SearchIO/_model/query.py,sha256=xKg8NCsJ1Q37KKXAfjMdV_479ocNz_FyB4Op5H_txeM,30199
+Bio/SearchIO/_utils.py,sha256=Od-zvdwFUZzhjVHNX0pmayza0bZZs93hfOLaMCnBYUM,5596
+Bio/Seq.py,sha256=rSosheRMdEVtyd1vRXy9TnsPCyxNwPa8KKcahny-FWs,114972
+Bio/SeqFeature.py,sha256=o8vTou8W9C6CBBCwuEM5ZCmNOuKMATecYNQ1cBws334,80760
+Bio/SeqIO/AbiIO.py,sha256=V_Xo_WI9uOTAVAl_zQtXaItb-uHE1VjXfzdiZK8PUyk,26249
+Bio/SeqIO/AceIO.py,sha256=jCS6DUiK-p0GbXMT697yy26IVbCn5s23ioLdqmtpfaE,4769
+Bio/SeqIO/FastaIO.py,sha256=g-aGuutrm-r34JwqI_j5TY_ORSRn99UAcdA4EBsE-nU,22100
+Bio/SeqIO/GckIO.py,sha256=-QoNJdwRbGbyB1IOiSB5kslShMg91BRdBhMlB5nNWzw,8994
+Bio/SeqIO/GfaIO.py,sha256=VSxljdd4Roa3n1pOkwkleA2WWy9cEUa514aTKJTehfM,7091
+Bio/SeqIO/IgIO.py,sha256=tkSa-vuU81cyjxX4FMU2n-Q_8St6evLQQTb0iqdwKf8,4068
+Bio/SeqIO/InsdcIO.py,sha256=1RQD7Mucudr3wyh5Xesgb5zK5D9ciaAl7g2XZ7A8T80,58571
+Bio/SeqIO/Interfaces.py,sha256=7IQvUADcSKI77Mha-MAMzJFc7g-cErjK11mMvL673sk,8325
+Bio/SeqIO/NibIO.py,sha256=Ocrhdhjgaqzje4mvNblzOjZGyd4jFx8WXTqLJ6hp0HM,5857
+Bio/SeqIO/PdbIO.py,sha256=hJDdg5z4ScgyRrV-NzP9ycK6qQPMaeCVRROgdRntido,22748
+Bio/SeqIO/PhdIO.py,sha256=7ifjaPVED1o3MKv432rvGG42LiIEvlRzADvhOhexYMg,6330
+Bio/SeqIO/PirIO.py,sha256=Iu6PhBKNs8aOCFdcwfN3XJL-BCZs7jft69WZQfvWYV0,10021
+Bio/SeqIO/QualityIO.py,sha256=Uxb7_DI_kVmYzVMSES5pOkUxrRC_JOlaggd435rvv8U,95985
+Bio/SeqIO/SeqXmlIO.py,sha256=OTO_RnjmwihhNlEkzxmMFSFfjO6WRENtOD4gbq6377M,30529
+Bio/SeqIO/SffIO.py,sha256=hhKYmSxTzR0YW4JETeipZHX-YE8VLIYhcDRMFg7Wdao,55380
+Bio/SeqIO/SnapGeneIO.py,sha256=G5WNqTsF3qw9qCATgPiFLoH9UtITo86hyh3tsNgVKg0,12385
+Bio/SeqIO/SwissIO.py,sha256=qRTDePuE-EQGRkraWtpegtmTK6Yur2L6Sd0eaEnvVdI,5251
+Bio/SeqIO/TabIO.py,sha256=6mbOO5fpUk8iY7X4q0wqozXvwUAR4ra7wH2HCyjGO8I,5125
+Bio/SeqIO/TwoBitIO.py,sha256=PDXnfMeDfVi6ez2YiNmZn5LG2BsISu1V4lj_3piOn_A,11165
+Bio/SeqIO/UniprotIO.py,sha256=SaBS6NUanEyySnGkiXQARtmsRQ2NONwBAslpi7j69iA,24645
+Bio/SeqIO/XdnaIO.py,sha256=ixODv7NjTXyPr7Pj05eMkLFEhPxCArRJKo3Xk31uBhE,12342
+Bio/SeqIO/__init__.py,sha256=orRUs-vmBmrysNZTQjslwDyELAgb7082Q9NPClcLsR8,45723
+Bio/SeqIO/__pycache__/AbiIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/AceIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/FastaIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/GckIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/GfaIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/IgIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/InsdcIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/Interfaces.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/NibIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/PdbIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/PhdIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/PirIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/QualityIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/SeqXmlIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/SffIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/SnapGeneIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/SwissIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/TabIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/TwoBitIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/UniprotIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/XdnaIO.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/__init__.cpython-312.pyc,,
+Bio/SeqIO/__pycache__/_index.cpython-312.pyc,,
+Bio/SeqIO/_index.py,sha256=wkH3rAsSV68s481L68TAQ2YWkZW-qDKOeZOuNXGXqdE,27642
+Bio/SeqIO/_twoBitIO.c,sha256=vgig9JSepUZMZCLr9TM55Zil_mtKqdKiDPHvN_Efn7Y,22033
+Bio/SeqIO/_twoBitIO.cpython-312-darwin.so,sha256=eafrc5Ajj_aGhv1MF2YqY2bWj8EHJ8RNy1HxvHTAQqc,51680
+Bio/SeqRecord.py,sha256=eLyYfA2ERI9WreLwxNAO3nsgoB3pJDoTtdz-1eEQYfI,61621
+Bio/SeqUtils/CheckSum.py,sha256=unmsn9dSkJqmuHjuSMnJydlbyMlWotm6CsHxMbFIOpk,3510
+Bio/SeqUtils/IsoelectricPoint.py,sha256=k6DTKbpjee3QfFP16o7LOcloTZIYqz_LRzbhMk4srtI,6557
+Bio/SeqUtils/MeltingTemp.py,sha256=Tzy8WF_9aNVDhtQPXtsROnwurkqkOIxrSWvO7N7AZQA,43151
+Bio/SeqUtils/ProtParam.py,sha256=0KU-ykP3-nkfptAApXwmMKdpQwTCmhz1vjlzYATyAE8,13174
+Bio/SeqUtils/ProtParamData.py,sha256=SIpMM2VWxeaqQekgjNSpOQ16KdPYPiyL4fDLUYxxiUc,18172
+Bio/SeqUtils/__init__.py,sha256=vW42dv28AciOGTE_G6v2XJZpcBlGDx5z4dE2OS3PfWo,25604
+Bio/SeqUtils/__pycache__/CheckSum.cpython-312.pyc,,
+Bio/SeqUtils/__pycache__/IsoelectricPoint.cpython-312.pyc,,
+Bio/SeqUtils/__pycache__/MeltingTemp.cpython-312.pyc,,
+Bio/SeqUtils/__pycache__/ProtParam.cpython-312.pyc,,
+Bio/SeqUtils/__pycache__/ProtParamData.cpython-312.pyc,,
+Bio/SeqUtils/__pycache__/__init__.cpython-312.pyc,,
+Bio/SeqUtils/__pycache__/lcc.cpython-312.pyc,,
+Bio/SeqUtils/lcc.py,sha256=XBY4ZRGoRiUEqmz55dhnLpPLi9ebKhIUa7VEJhHtMd8,5502
+Bio/Sequencing/Ace.py,sha256=_Su6gu-odBELWvCtZmz3y6CnXBMJEji1q1h1CHSnpYg,20432
+Bio/Sequencing/Phd.py,sha256=qMigC5HmXLowegKMXobMa6QppCKAPjvDcsqflle9URg,5684
+Bio/Sequencing/__init__.py,sha256=r9llSVj9cqJveTCKxDHw-pDPdvL4KBYil12zby9QpMg,530
+Bio/Sequencing/__pycache__/Ace.cpython-312.pyc,,
+Bio/Sequencing/__pycache__/Phd.cpython-312.pyc,,
+Bio/Sequencing/__pycache__/__init__.cpython-312.pyc,,
+Bio/SwissProt/KeyWList.py,sha256=DiMiwlFCWMPtyvoly2fkkmgTPG75tJUXQ1S6EPGnUA0,3468
+Bio/SwissProt/__init__.py,sha256=5nmAYalbLowU1VFcN_UAtyH4PkYQ_7vCHnTG0Fbw0zw,32910
+Bio/SwissProt/__pycache__/KeyWList.cpython-312.pyc,,
+Bio/SwissProt/__pycache__/__init__.cpython-312.pyc,,
+Bio/TogoWS/__init__.py,sha256=Vsw0IMrIQ52k-Gu4WH6Yd-i_-D1RgqhPhqa7_gwJTL8,13966
+Bio/TogoWS/__pycache__/__init__.cpython-312.pyc,,
+Bio/UniGene/__init__.py,sha256=EjnkeKTzkJhq2ghSOeMC3E_eZ4U89LFGCS1n6-s9otw,12738
+Bio/UniGene/__pycache__/__init__.cpython-312.pyc,,
+Bio/UniProt/GOA.py,sha256=nXzgZAiC1P4HsuLfM7z0ca4h5cH8auBNISEB9-hve6w,15791
+Bio/UniProt/__init__.py,sha256=eQwo82zOz4o9hqJMSle0K9brewdx5a_NcHp3fRXDsA8,5376
+Bio/UniProt/__pycache__/GOA.cpython-312.pyc,,
+Bio/UniProt/__pycache__/__init__.cpython-312.pyc,,
+Bio/__init__.py,sha256=WQPbWoi90aKnzAgfzTFcra9pO0jG8JPpDukzxllOn3o,5411
+Bio/__pycache__/File.cpython-312.pyc,,
+Bio/__pycache__/Seq.cpython-312.pyc,,
+Bio/__pycache__/SeqFeature.cpython-312.pyc,,
+Bio/__pycache__/SeqRecord.cpython-312.pyc,,
+Bio/__pycache__/__init__.cpython-312.pyc,,
+Bio/__pycache__/_utils.cpython-312.pyc,,
+Bio/__pycache__/bgzf.cpython-312.pyc,,
+Bio/__pycache__/pairwise2.cpython-312.pyc,,
+Bio/_utils.py,sha256=_WcE3XdMiyta5aTDdZVRnFTdou8D0REGZkhLlOMCgqs,2918
+Bio/bgzf.py,sha256=Eun1RXey_n9mSttJrH15wIEZrFRaOyjREP5Rasc2KIo,39777
+Bio/codonalign/__init__.py,sha256=umcOampgYmjCJAIl5qzKktYZbKKMDaMp5OXlFvD-_j0,30114
+Bio/codonalign/__pycache__/__init__.cpython-312.pyc,,
+Bio/codonalign/__pycache__/codonalignment.cpython-312.pyc,,
+Bio/codonalign/__pycache__/codonseq.cpython-312.pyc,,
+Bio/codonalign/codonalignment.py,sha256=EZGYrxbqWHbH7lUsoGXYK0ziAwH3Iginpb7sHajH_Ws,18231
+Bio/codonalign/codonseq.py,sha256=FwHAAfwhK_VvQs-uyhK15phwPG92_0WiVnFXcwOsWrA,47934
+Bio/cpairwise2.cpython-312-darwin.so,sha256=2YBuX1Y_xzlCxaQlPl4MOlturMuuxAJRdmv4Itl52Ow,52304
+Bio/cpairwise2module.c,sha256=rCEMYaN3LJnust0hpjlojfGh_YAXM6fi6hXaMAudayU,16868
+Bio/motifs/__init__.py,sha256=I7OyH7iRI3-UovgMYufgBbhP1FolNHS1-08KqvYYjIU,22158
+Bio/motifs/__pycache__/__init__.cpython-312.pyc,,
+Bio/motifs/__pycache__/alignace.cpython-312.pyc,,
+Bio/motifs/__pycache__/clusterbuster.cpython-312.pyc,,
+Bio/motifs/__pycache__/mast.cpython-312.pyc,,
+Bio/motifs/__pycache__/matrix.cpython-312.pyc,,
+Bio/motifs/__pycache__/meme.cpython-312.pyc,,
+Bio/motifs/__pycache__/minimal.cpython-312.pyc,,
+Bio/motifs/__pycache__/pfm.cpython-312.pyc,,
+Bio/motifs/__pycache__/thresholds.cpython-312.pyc,,
+Bio/motifs/__pycache__/transfac.cpython-312.pyc,,
+Bio/motifs/__pycache__/xms.cpython-312.pyc,,
+Bio/motifs/_pwm.c,sha256=1vOzUu0th-NZdHXc50b4IhZyRM0hQH4itjMvIBTnx4g,5793
+Bio/motifs/_pwm.cpython-312-darwin.so,sha256=zldhaoVwzNuB9eHgv4Hu5vpYWykYGstQ4MYNdj5nLWA,51384
+Bio/motifs/alignace.py,sha256=-Fqz1ka9VKwPpB8PPZTuMm5GGu29UQhHqR52IFBrBb4,2118
+Bio/motifs/clusterbuster.py,sha256=VXUM9fCXJv2HIdkhSInlKuSaxWn3wpAfd_Yt1q_p8EI,3852
+Bio/motifs/jaspar/__init__.py,sha256=BM-AozLo_6eKvpwnfjpSIGoMQx-dX6BogdNCYIJX53Y,11388
+Bio/motifs/jaspar/__pycache__/__init__.cpython-312.pyc,,
+Bio/motifs/jaspar/__pycache__/db.cpython-312.pyc,,
+Bio/motifs/jaspar/db.py,sha256=Nl1fmXPhRWxdo-5EhP-5NhrSCO8KC69IEq-FnQh_pw0,27980
+Bio/motifs/mast.py,sha256=WKoDkBRSJ9IvpmolXrS3otOBPDYDR1lFt7uJHrzUSoo,4915
+Bio/motifs/matrix.py,sha256=sVzzwoIEREiuWwpcPsSoeJzg1DliBgq5OuoiRS7WJh4,24049
+Bio/motifs/meme.py,sha256=_wQt896H1uky4K2Tc2bO-PVsvSoZh6ntss1eeW7qMp8,6397
+Bio/motifs/minimal.py,sha256=SK1OHuxU3RdubK82hzUH-cBOGIYYAfoMq9kmkKw9HjM,7161
+Bio/motifs/pfm.py,sha256=4KvB9j7fnGQKBQs-_SCGYqG5qnlCmQcREe9gEkvG9vo,17229
+Bio/motifs/thresholds.py,sha256=o0K4bKPNYpVsribsDmOhIsV10lY31NNL1_HbT3sRwM4,4530
+Bio/motifs/transfac.py,sha256=fDi-ExuWX5_74iIo9Id7lT-8jPB_iMN9OLbDJHla_zw,12127
+Bio/motifs/xms.py,sha256=NNRXpG5JZC5Twy5CHB4GjpYhWjiJTLlVabRRUxJ32Hc,3942
+Bio/pairwise2.py,sha256=6TqFmPrI58IMlevMDgLowi1bEshJfKERp-wVvnt4sWQ,53156
+Bio/phenotype/__init__.py,sha256=ygNXhDYIMSb8C3woqkvCOOyefr98MUssE6KqRokIL8Q,8353
+Bio/phenotype/__pycache__/__init__.cpython-312.pyc,,
+Bio/phenotype/__pycache__/phen_micro.cpython-312.pyc,,
+Bio/phenotype/__pycache__/pm_fitting.cpython-312.pyc,,
+Bio/phenotype/phen_micro.py,sha256=Bep81ibmizySAfbLVcyffqGeqWvRt8Te-2v4WDeqF0w,37710
+Bio/phenotype/pm_fitting.py,sha256=W6zMBSSDPYdGrLRH6p9sL38z7HGNArEVBj7Xt7_KCEw,4208
+Bio/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+BioSQL/BioSeq.py,sha256=IodmnonVHMfl3BRXgYMo3DQq08IbRKW81eYEjgVDTjE,21795
+BioSQL/BioSeqDatabase.py,sha256=F3L8O1Csm8HWhNdDoAWykVXdjUJRN5JbuCLV1_uoJ7M,31312
+BioSQL/DBUtils.py,sha256=D8a89mQyIpo54_Nc2ZG376rhqLrFFdvtquoXX9MSFiU,4657
+BioSQL/Loader.py,sha256=VXvVd9CM7im8_b89uFlF44YC4R0ACVeHKUOYrFKbpN4,51599
+BioSQL/__init__.py,sha256=D4hw16z-KuugA_YcEa83q2zz2CNLDopcRHrPvFeSVKM,617
+BioSQL/__pycache__/BioSeq.cpython-312.pyc,,
+BioSQL/__pycache__/BioSeqDatabase.cpython-312.pyc,,
+BioSQL/__pycache__/DBUtils.cpython-312.pyc,,
+BioSQL/__pycache__/Loader.cpython-312.pyc,,
+BioSQL/__pycache__/__init__.cpython-312.pyc,,
+BioSQL/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+biopython-1.87.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+biopython-1.87.dist-info/METADATA,sha256=fzwcehh1yVgVs5euzF5bkLETW6DHsctEeonCOGYsjxA,13290
+biopython-1.87.dist-info/RECORD,,
+biopython-1.87.dist-info/WHEEL,sha256=cMbdUR4MuJwKTk_cclTNco-OW6sDrQbwZ6MlSMtlrI4,136
+biopython-1.87.dist-info/licenses/LICENSE.rst,sha256=EdHryq0uufDwmj3x3rSsqZpNo2aumucPgox0R6JN5FM,3267
+biopython-1.87.dist-info/top_level.txt,sha256=jN-JQ-4c2AzNqKFp3H5s0o2dIfGhg0SAVilkXmnLl_M,11

.venv_haddock/lib/python3.12/site-packages/biopython-1.87.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: false
+Tag: cp312-cp312-macosx_11_0_arm64
+Generator: delocate 0.13.0
+

.venv_haddock/lib/python3.12/site-packages/biopython-1.87.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+Bio
+BioSQL

.venv_haddock/lib/python3.12/site-packages/freesasa-2.2.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

.venv_haddock/lib/python3.12/site-packages/freesasa-2.2.1.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: freesasa
+Version: 2.2.1
+Summary: Calculate solvent accessible surface areas of proteins
+Home-page: http://freesasa.github.io/
+Author: Simon Mitternacht
+License: MIT
+Keywords: structural biology,proteins,bioinformatics
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+License-File: LICENSE.txt
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: home-page
+Dynamic: keywords
+Dynamic: license
+Dynamic: license-file
+Dynamic: summary
+
+This module provides bindings for the FreeSASA C library. See http://freesasa.github.io/python/ for documentation.

.venv_haddock/lib/python3.12/site-packages/freesasa-2.2.1.dist-info/RECORD

@@ -0,0 +1,34 @@
+../../../include/site/python3.12/freesasa/classifier.c,sha256=QuOypS0HeJsvfC00uJQRIfy3B9ESyL5xiZxr2nwQzkc,35591
+../../../include/site/python3.12/freesasa/classifier.h,sha256=sOKgAMIOXDWWbqsCCVzvsaRPuryifufjbtZUc2HQQ3E,3892
+../../../include/site/python3.12/freesasa/classifier_naccess.c,sha256=zvtxtks_MLjXjOibwJEO9avBL2Kxb1Wdnfm6Rtud5Fg,21027
+../../../include/site/python3.12/freesasa/classifier_oons.c,sha256=TCq2jX6JRDUSDj6XPGsRZ5bWNgeSmsNrJntrNG58StA,15528
+../../../include/site/python3.12/freesasa/classifier_protor.c,sha256=smnSPFn73TDSeKkhOKdywELYbUnRcC-vYdMX0ds0Fog,32827
+../../../include/site/python3.12/freesasa/coord.c,sha256=4Z7x-9uBdMt4QXrrX6YJuFMXi0vIeWdJEmMTktzjVwQ,6745
+../../../include/site/python3.12/freesasa/coord.h,sha256=X2wcRh-4p5ohI1snT4wKIO68VVwL4LfLhsZxOJnM9Ps,9655
+../../../include/site/python3.12/freesasa/freesasa.c,sha256=HdK4t5ziSaFFb87MPjBfuTA1fX3Lugt9LwXlIRaewFY,6264
+../../../include/site/python3.12/freesasa/freesasa.h,sha256=HzQtufMN6g_XJyBFXIetrgjgEQljx6DoNRaZyi8VU88,49886
+../../../include/site/python3.12/freesasa/freesasa_internal.h,sha256=_xQzC0bVomyLhRw-2RrOX3dq22StxL8f4Qi61CWndmQ,14465
+../../../include/site/python3.12/freesasa/lexer.c,sha256=W5aUyYV6Gw0bseRnPGP6FI8Z32chj9e460dstgB-m98,61622
+../../../include/site/python3.12/freesasa/lexer.h,sha256=sXp5aWS_NgsRXYPmplaE1GhTTTkUW42L8jrjIgXXgVA,8630
+../../../include/site/python3.12/freesasa/log.c,sha256=vW5bCZYHcP4IARFlDP7z853KkEdlR5nn9q0G4UxeOv0,7861
+../../../include/site/python3.12/freesasa/nb.c,sha256=6_h6oq1lyBAd4XwDil2oTrxtEpFM7eGAuQeM9QOy6_4,15541
+../../../include/site/python3.12/freesasa/nb.h,sha256=jaKOzW6-YVQzNLFeypvt7SouCxMoYv2liqBIGtEE4WU,2041
+../../../include/site/python3.12/freesasa/node.c,sha256=0BWahd-TV0QXKFAJgVsHa7SExsrsEGxVoMJnv3PYRT8,19924
+../../../include/site/python3.12/freesasa/parser.c,sha256=MBsZ8NX8TgbDPkVEGXjoYPNIwLN5pXL36-953vd76ms,51255
+../../../include/site/python3.12/freesasa/parser.h,sha256=nO9gF0kztlJE1nnabh-msSv-PABZN6lQepL-6_hFclA,2723
+../../../include/site/python3.12/freesasa/pdb.c,sha256=sabnoL63I_3k9aeiSZEeRPVwKFrd920XMvowxMUc_e8,12746
+../../../include/site/python3.12/freesasa/pdb.h,sha256=DZDM0KcSkjvwfC9YFRYyUsxG6OMeAnokl9coQs6nBEA,6761
+../../../include/site/python3.12/freesasa/rsa.c,sha256=OiNoqehuFGHtZBc-hEUcp7_Vo480YwO5mQwwdoPdKq0,6056
+../../../include/site/python3.12/freesasa/sasa_lr.c,sha256=W7meigB7HWeafmYcToLkFOw06NI3PFEkJjXQjOyUo7A,13910
+../../../include/site/python3.12/freesasa/sasa_sr.c,sha256=bJg7HZpSAABD10H5Fx9_YdFzmoJVB4wIGflnaHkCmho,9542
+../../../include/site/python3.12/freesasa/selection.c,sha256=2E7hqhHawETKspw2eoK7w_s2drTuuZgfeI31GMEJWXo,27380
+../../../include/site/python3.12/freesasa/selection.h,sha256=4hN-ryHR6g-Lu2cqwE23cb5_HOKSg1riOtQtAJGj4_A,1345
+../../../include/site/python3.12/freesasa/structure.c,sha256=qc97rrNNYv-WqkqgskSOZcvCgWr84lRVeJcKf87fa_Q,35165
+../../../include/site/python3.12/freesasa/util.c,sha256=RffIRstokC0qsiiwZKMx5pKMSW8EWWvwXRoZWIZ61X0,2786
+freesasa-2.2.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+freesasa-2.2.1.dist-info/METADATA,sha256=HlSBCXpnLYfB9COp1efDUjYPhx1mb1CYEnWUGjatpQA,1017
+freesasa-2.2.1.dist-info/RECORD,,
+freesasa-2.2.1.dist-info/WHEEL,sha256=CltXN3lQvXbHxKDtiDwW0RNzF8s2WyBuPbOAX_ZeQlA,109
+freesasa-2.2.1.dist-info/licenses/LICENSE.txt,sha256=wszU7NQ3S0N_vNRFEQF27pIPlZtcknvqIxqRbJOfp0U,1085
+freesasa-2.2.1.dist-info/top_level.txt,sha256=lrUU06PGnY5L5fM8Sm8XZBESUDWcf0rlRoEIHREIAS0,9
+freesasa.cpython-312-darwin.so,sha256=_PFdHl19_V5VKB6kQyIodQwkA5hXnH32t6pxcQxA2wM,455360

.venv_haddock/lib/python3.12/site-packages/freesasa-2.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp312-cp312-macosx_11_0_arm64
+

.venv_haddock/lib/python3.12/site-packages/freesasa-2.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+freesasa

.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/METADATA

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: numpy
+Version: 2.4.4
+Summary: Fundamental package for array computing in Python
+Author: Travis E. Oliphant et al.
+Maintainer-Email: NumPy Developers <numpy-discussion@python.org>
+License-Expression: BSD-3-Clause AND 0BSD AND MIT AND Zlib AND CC0-1.0
+License-File: LICENSE.txt
+License-File: numpy/_core/include/numpy/libdivide/LICENSE.txt
+License-File: numpy/_core/src/common/pythoncapi-compat/COPYING
+License-File: numpy/_core/src/highway/LICENSE
+License-File: numpy/_core/src/multiarray/dragon4_LICENSE.txt
+License-File: numpy/_core/src/npysort/x86-simd-sort/LICENSE.md
+License-File: numpy/_core/src/umath/svml/LICENSE
+License-File: numpy/fft/pocketfft/LICENSE.md
+License-File: numpy/linalg/lapack_lite/LICENSE.txt
+License-File: numpy/ma/LICENSE
+License-File: numpy/random/LICENSE.md
+License-File: numpy/random/src/distributions/LICENSE.md
+License-File: numpy/random/src/mt19937/LICENSE.md
+License-File: numpy/random/src/pcg64/LICENSE.md
+License-File: numpy/random/src/philox/LICENSE.md
+License-File: numpy/random/src/sfc64/LICENSE.md
+License-File: numpy/random/src/splitmix64/LICENSE.md
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development
+Classifier: Topic :: Scientific/Engineering
+Classifier: Typing :: Typed
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: Unix
+Classifier: Operating System :: MacOS
+Project-URL: homepage, https://numpy.org
+Project-URL: documentation, https://numpy.org/doc/
+Project-URL: source, https://github.com/numpy/numpy
+Project-URL: download, https://pypi.org/project/numpy/#files
+Project-URL: tracker, https://github.com/numpy/numpy/issues
+Project-URL: release notes, https://numpy.org/doc/stable/release
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+<h1 align="center">
+<img src="https://raw.githubusercontent.com/numpy/numpy/main/branding/logo/primary/numpylogo.svg" width="300">
+</h1><br>
+
+
+[![Powered by NumFOCUS](https://img.shields.io/badge/powered%20by-NumFOCUS-orange.svg?style=flat&colorA=E1523D&colorB=007D8A)](
+https://numfocus.org)
+[![PyPI Downloads](https://img.shields.io/pypi/dm/numpy.svg?label=PyPI%20downloads)](
+https://pypi.org/project/numpy/)
+[![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/numpy.svg?label=Conda%20downloads)](
+https://anaconda.org/conda-forge/numpy)
+[![Stack Overflow](https://img.shields.io/badge/stackoverflow-Ask%20questions-blue.svg)](
+https://stackoverflow.com/questions/tagged/numpy)
+[![Nature Paper](https://img.shields.io/badge/DOI-10.1038%2Fs41586--020--2649--2-blue)](
+https://doi.org/10.1038/s41586-020-2649-2)
+[![LFX Health Score](https://insights.linuxfoundation.org/api/badge/health-score?project=numpy)](https://insights.linuxfoundation.org/project/numpy)
+[![OpenSSF Scorecard](https://api.securityscorecards.dev/projects/github.com/numpy/numpy/badge)](https://securityscorecards.dev/viewer/?uri=github.com/numpy/numpy)
+[![Typing](https://img.shields.io/pypi/types/numpy)](https://pypi.org/project/numpy/)
+
+
+NumPy is the fundamental package for scientific computing with Python.
+
+- **Website:** https://numpy.org
+- **Documentation:** https://numpy.org/doc
+- **Mailing list:** https://mail.python.org/mailman/listinfo/numpy-discussion
+- **Source code:** https://github.com/numpy/numpy
+- **Contributing:** https://numpy.org/devdocs/dev/index.html
+- **Bug reports:** https://github.com/numpy/numpy/issues
+- **Report a security vulnerability:** https://tidelift.com/docs/security
+
+It provides:
+
+- a powerful N-dimensional array object
+- sophisticated (broadcasting) functions
+- tools for integrating C/C++ and Fortran code
+- useful linear algebra, Fourier transform, and random number capabilities
+
+Testing:
+
+NumPy requires `pytest` and `hypothesis`.  Tests can then be run after installation with:
+
+    python -c "import numpy, sys; sys.exit(numpy.test() is False)"
+
+Code of Conduct
+----------------------
+
+NumPy is a community-driven open source project developed by a diverse group of
+[contributors](https://numpy.org/teams/). The NumPy leadership has made a strong
+commitment to creating an open, inclusive, and positive community. Please read the
+[NumPy Code of Conduct](https://numpy.org/code-of-conduct/) for guidance on how to interact
+with others in a way that makes our community thrive.
+
+Call for Contributions
+----------------------
+
+The NumPy project welcomes your expertise and enthusiasm!
+
+Small improvements or fixes are always appreciated. If you are considering larger contributions
+to the source code, please contact us through the [mailing
+list](https://mail.python.org/mailman/listinfo/numpy-discussion) first.
+
+Writing code isn’t the only way to contribute to NumPy. You can also:
+- review pull requests
+- help us stay on top of new and old issues
+- develop tutorials, presentations, and other educational materials
+- maintain and improve [our website](https://github.com/numpy/numpy.org)
+- develop graphic design for our brand assets and promotional materials
+- translate website content
+- help with outreach and onboard new contributors
+- write grant proposals and help with other fundraising efforts
+
+For more information about the ways you can contribute to NumPy, visit [our website](https://numpy.org/contribute/). 
+If you’re unsure where to start or how your skills fit in, reach out! You can
+ask on the mailing list or here, on GitHub, by opening a new issue or leaving a
+comment on a relevant issue that is already open.
+
+Our preferred channels of communication are all public, but if you’d like to
+speak to us in private first, contact our community coordinators at
+numpy-team@googlegroups.com or on Slack (write numpy-team@googlegroups.com for
+an invitation).
+
+We also have a biweekly community call, details of which are announced on the
+mailing list. You are very welcome to join.
+
+If you are new to contributing to open source, [this
+guide](https://opensource.guide/how-to-contribute/) helps explain why, what,
+and how to successfully get involved.

.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: meson
+Root-Is-Purelib: false
+Tag: cp312-cp312-macosx_14_0_arm64
+Generator: delocate 0.13.0
+

.venv_haddock/lib/python3.12/site-packages/numpy-2.4.4.dist-info/entry_points.txt

@@ -0,0 +1,13 @@
+[pkg_config]
+numpy = numpy._core.lib.pkgconfig
+
+[array_api]
+numpy = numpy
+
+[pyinstaller40]
+hook-dirs = numpy:_pyinstaller_hooks_dir
+
+[console_scripts]
+f2py = numpy.f2py.f2py2e:main
+numpy-config = numpy._configtool:main
+

.venv_haddock/lib/python3.12/site-packages/pandas/_config/__init__.py

@@ -0,0 +1,57 @@
+"""
+pandas._config is considered explicitly upstream of everything else in pandas,
+should have no intra-pandas dependencies.
+
+importing `dates` and `display` ensures that keys needed by _libs
+are initialized.
+"""
+__all__ = [
+    "config",
+    "detect_console_encoding",
+    "get_option",
+    "set_option",
+    "reset_option",
+    "describe_option",
+    "option_context",
+    "options",
+    "using_copy_on_write",
+    "warn_copy_on_write",
+]
+from pandas._config import config
+from pandas._config import dates  # pyright: ignore[reportUnusedImport]  # noqa: F401
+from pandas._config.config import (
+    _global_config,
+    describe_option,
+    get_option,
+    option_context,
+    options,
+    reset_option,
+    set_option,
+)
+from pandas._config.display import detect_console_encoding
+
+
+def using_copy_on_write() -> bool:
+    _mode_options = _global_config["mode"]
+    return (
+        _mode_options["copy_on_write"] is True
+        and _mode_options["data_manager"] == "block"
+    )
+
+
+def warn_copy_on_write() -> bool:
+    _mode_options = _global_config["mode"]
+    return (
+        _mode_options["copy_on_write"] == "warn"
+        and _mode_options["data_manager"] == "block"
+    )
+
+
+def using_nullable_dtypes() -> bool:
+    _mode_options = _global_config["mode"]
+    return _mode_options["nullable_dtypes"]
+
+
+def using_string_dtype() -> bool:
+    _mode_options = _global_config["future"]
+    return _mode_options["infer_string"]

.venv_haddock/lib/python3.12/site-packages/pandas/_config/config.py

@@ -0,0 +1,948 @@
+"""
+The config module holds package-wide configurables and provides
+a uniform API for working with them.
+
+Overview
+========
+
+This module supports the following requirements:
+- options are referenced using keys in dot.notation, e.g. "x.y.option - z".
+- keys are case-insensitive.
+- functions should accept partial/regex keys, when unambiguous.
+- options can be registered by modules at import time.
+- options can be registered at init-time (via core.config_init)
+- options have a default value, and (optionally) a description and
+  validation function associated with them.
+- options can be deprecated, in which case referencing them
+  should produce a warning.
+- deprecated options can optionally be rerouted to a replacement
+  so that accessing a deprecated option reroutes to a differently
+  named option.
+- options can be reset to their default value.
+- all option can be reset to their default value at once.
+- all options in a certain sub - namespace can be reset at once.
+- the user can set / get / reset or ask for the description of an option.
+- a developer can register and mark an option as deprecated.
+- you can register a callback to be invoked when the option value
+  is set or reset. Changing the stored value is considered misuse, but
+  is not verboten.
+
+Implementation
+==============
+
+- Data is stored using nested dictionaries, and should be accessed
+  through the provided API.
+
+- "Registered options" and "Deprecated options" have metadata associated
+  with them, which are stored in auxiliary dictionaries keyed on the
+  fully-qualified key, e.g. "x.y.z.option".
+
+- the config_init module is imported by the package's __init__.py file.
+  placing any register_option() calls there will ensure those options
+  are available as soon as pandas is loaded. If you use register_option
+  in a module, it will only be available after that module is imported,
+  which you should be aware of.
+
+- `config_prefix` is a context_manager (for use with the `with` keyword)
+  which can save developers some typing, see the docstring.
+
+"""
+
+from __future__ import annotations
+
+from contextlib import (
+    ContextDecorator,
+    contextmanager,
+)
+import re
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Generic,
+    NamedTuple,
+    cast,
+)
+import warnings
+
+from pandas._typing import (
+    F,
+    T,
+)
+from pandas.util._exceptions import find_stack_level
+
+if TYPE_CHECKING:
+    from collections.abc import (
+        Generator,
+        Iterable,
+    )
+
+
+class DeprecatedOption(NamedTuple):
+    key: str
+    msg: str | None
+    rkey: str | None
+    removal_ver: str | None
+
+
+class RegisteredOption(NamedTuple):
+    key: str
+    defval: object
+    doc: str
+    validator: Callable[[object], Any] | None
+    cb: Callable[[str], Any] | None
+
+
+# holds deprecated option metadata
+_deprecated_options: dict[str, DeprecatedOption] = {}
+
+# holds registered option metadata
+_registered_options: dict[str, RegisteredOption] = {}
+
+# holds the current values for registered options
+_global_config: dict[str, Any] = {}
+
+# keys which have a special meaning
+_reserved_keys: list[str] = ["all"]
+
+
+class OptionError(AttributeError, KeyError):
+    """
+    Exception raised for pandas.options.
+
+    Backwards compatible with KeyError checks.
+
+    Examples
+    --------
+    >>> pd.options.context
+    Traceback (most recent call last):
+    OptionError: No such option
+    """
+
+
+#
+# User API
+
+
+def _get_single_key(pat: str, silent: bool) -> str:
+    keys = _select_options(pat)
+    if len(keys) == 0:
+        if not silent:
+            _warn_if_deprecated(pat)
+        raise OptionError(f"No such keys(s): {repr(pat)}")
+    if len(keys) > 1:
+        raise OptionError("Pattern matched multiple keys")
+    key = keys[0]
+
+    if not silent:
+        _warn_if_deprecated(key)
+
+    key = _translate_key(key)
+
+    return key
+
+
+def _get_option(pat: str, silent: bool = False) -> Any:
+    key = _get_single_key(pat, silent)
+
+    # walk the nested dict
+    root, k = _get_root(key)
+    return root[k]
+
+
+def _set_option(*args, **kwargs) -> None:
+    # must at least 1 arg deal with constraints later
+    nargs = len(args)
+    if not nargs or nargs % 2 != 0:
+        raise ValueError("Must provide an even number of non-keyword arguments")
+
+    # default to false
+    silent = kwargs.pop("silent", False)
+
+    if kwargs:
+        kwarg = next(iter(kwargs.keys()))
+        raise TypeError(f'_set_option() got an unexpected keyword argument "{kwarg}"')
+
+    for k, v in zip(args[::2], args[1::2]):
+        key = _get_single_key(k, silent)
+
+        o = _get_registered_option(key)
+        if o and o.validator:
+            o.validator(v)
+
+        # walk the nested dict
+        root, k_root = _get_root(key)
+        root[k_root] = v
+
+        if o.cb:
+            if silent:
+                with warnings.catch_warnings(record=True):
+                    o.cb(key)
+            else:
+                o.cb(key)
+
+
+def _describe_option(pat: str = "", _print_desc: bool = True) -> str | None:
+    keys = _select_options(pat)
+    if len(keys) == 0:
+        raise OptionError("No such keys(s)")
+
+    s = "\n".join([_build_option_description(k) for k in keys])
+
+    if _print_desc:
+        print(s)
+        return None
+    return s
+
+
+def _reset_option(pat: str, silent: bool = False) -> None:
+    keys = _select_options(pat)
+
+    if len(keys) == 0:
+        raise OptionError("No such keys(s)")
+
+    if len(keys) > 1 and len(pat) < 4 and pat != "all":
+        raise ValueError(
+            "You must specify at least 4 characters when "
+            "resetting multiple keys, use the special keyword "
+            '"all" to reset all the options to their default value'
+        )
+
+    for k in keys:
+        _set_option(k, _registered_options[k].defval, silent=silent)
+
+
+def get_default_val(pat: str):
+    key = _get_single_key(pat, silent=True)
+    return _get_registered_option(key).defval
+
+
+class DictWrapper:
+    """provide attribute-style access to a nested dict"""
+
+    d: dict[str, Any]
+
+    def __init__(self, d: dict[str, Any], prefix: str = "") -> None:
+        object.__setattr__(self, "d", d)
+        object.__setattr__(self, "prefix", prefix)
+
+    def __setattr__(self, key: str, val: Any) -> None:
+        prefix = object.__getattribute__(self, "prefix")
+        if prefix:
+            prefix += "."
+        prefix += key
+        # you can't set new keys
+        # can you can't overwrite subtrees
+        if key in self.d and not isinstance(self.d[key], dict):
+            _set_option(prefix, val)
+        else:
+            raise OptionError("You can only set the value of existing options")
+
+    def __getattr__(self, key: str):
+        prefix = object.__getattribute__(self, "prefix")
+        if prefix:
+            prefix += "."
+        prefix += key
+        try:
+            v = object.__getattribute__(self, "d")[key]
+        except KeyError as err:
+            raise OptionError("No such option") from err
+        if isinstance(v, dict):
+            return DictWrapper(v, prefix)
+        else:
+            return _get_option(prefix)
+
+    def __dir__(self) -> list[str]:
+        return list(self.d.keys())
+
+
+# For user convenience,  we'd like to have the available options described
+# in the docstring. For dev convenience we'd like to generate the docstrings
+# dynamically instead of maintaining them by hand. To this, we use the
+# class below which wraps functions inside a callable, and converts
+# __doc__ into a property function. The doctsrings below are templates
+# using the py2.6+ advanced formatting syntax to plug in a concise list
+# of options, and option descriptions.
+
+
+class CallableDynamicDoc(Generic[T]):
+    def __init__(self, func: Callable[..., T], doc_tmpl: str) -> None:
+        self.__doc_tmpl__ = doc_tmpl
+        self.__func__ = func
+
+    def __call__(self, *args, **kwds) -> T:
+        return self.__func__(*args, **kwds)
+
+    # error: Signature of "__doc__" incompatible with supertype "object"
+    @property
+    def __doc__(self) -> str:  # type: ignore[override]
+        opts_desc = _describe_option("all", _print_desc=False)
+        opts_list = pp_options_list(list(_registered_options.keys()))
+        return self.__doc_tmpl__.format(opts_desc=opts_desc, opts_list=opts_list)
+
+
+_get_option_tmpl = """
+get_option(pat)
+
+Retrieves the value of the specified option.
+
+Available options:
+
+{opts_list}
+
+Parameters
+----------
+pat : str
+    Regexp which should match a single option.
+    Note: partial matches are supported for convenience, but unless you use the
+    full option name (e.g. x.y.z.option_name), your code may break in future
+    versions if new options with similar names are introduced.
+
+Returns
+-------
+result : the value of the option
+
+Raises
+------
+OptionError : if no such option exists
+
+Notes
+-----
+Please reference the :ref:`User Guide <options>` for more information.
+
+The available options with its descriptions:
+
+{opts_desc}
+
+Examples
+--------
+>>> pd.get_option('display.max_columns')  # doctest: +SKIP
+4
+"""
+
+_set_option_tmpl = """
+set_option(pat, value)
+
+Sets the value of the specified option.
+
+Available options:
+
+{opts_list}
+
+Parameters
+----------
+pat : str
+    Regexp which should match a single option.
+    Note: partial matches are supported for convenience, but unless you use the
+    full option name (e.g. x.y.z.option_name), your code may break in future
+    versions if new options with similar names are introduced.
+value : object
+    New value of option.
+
+Returns
+-------
+None
+
+Raises
+------
+OptionError if no such option exists
+
+Notes
+-----
+Please reference the :ref:`User Guide <options>` for more information.
+
+The available options with its descriptions:
+
+{opts_desc}
+
+Examples
+--------
+>>> pd.set_option('display.max_columns', 4)
+>>> df = pd.DataFrame([[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
+>>> df
+   0  1  ...  3   4
+0  1  2  ...  4   5
+1  6  7  ...  9  10
+[2 rows x 5 columns]
+>>> pd.reset_option('display.max_columns')
+"""
+
+_describe_option_tmpl = """
+describe_option(pat, _print_desc=False)
+
+Prints the description for one or more registered options.
+
+Call with no arguments to get a listing for all registered options.
+
+Available options:
+
+{opts_list}
+
+Parameters
+----------
+pat : str
+    Regexp pattern. All matching keys will have their description displayed.
+_print_desc : bool, default True
+    If True (default) the description(s) will be printed to stdout.
+    Otherwise, the description(s) will be returned as a unicode string
+    (for testing).
+
+Returns
+-------
+None by default, the description(s) as a unicode string if _print_desc
+is False
+
+Notes
+-----
+Please reference the :ref:`User Guide <options>` for more information.
+
+The available options with its descriptions:
+
+{opts_desc}
+
+Examples
+--------
+>>> pd.describe_option('display.max_columns')  # doctest: +SKIP
+display.max_columns : int
+    If max_cols is exceeded, switch to truncate view...
+"""
+
+_reset_option_tmpl = """
+reset_option(pat)
+
+Reset one or more options to their default value.
+
+Pass "all" as argument to reset all options.
+
+Available options:
+
+{opts_list}
+
+Parameters
+----------
+pat : str/regex
+    If specified only options matching `prefix*` will be reset.
+    Note: partial matches are supported for convenience, but unless you
+    use the full option name (e.g. x.y.z.option_name), your code may break
+    in future versions if new options with similar names are introduced.
+
+Returns
+-------
+None
+
+Notes
+-----
+Please reference the :ref:`User Guide <options>` for more information.
+
+The available options with its descriptions:
+
+{opts_desc}
+
+Examples
+--------
+>>> pd.reset_option('display.max_columns')  # doctest: +SKIP
+"""
+
+# bind the functions with their docstrings into a Callable
+# and use that as the functions exposed in pd.api
+get_option = CallableDynamicDoc(_get_option, _get_option_tmpl)
+set_option = CallableDynamicDoc(_set_option, _set_option_tmpl)
+reset_option = CallableDynamicDoc(_reset_option, _reset_option_tmpl)
+describe_option = CallableDynamicDoc(_describe_option, _describe_option_tmpl)
+options = DictWrapper(_global_config)
+
+#
+# Functions for use by pandas developers, in addition to User - api
+
+
+class option_context(ContextDecorator):
+    """
+    Context manager to temporarily set options in the `with` statement context.
+
+    You need to invoke as ``option_context(pat, val, [(pat, val), ...])``.
+
+    Examples
+    --------
+    >>> from pandas import option_context
+    >>> with option_context('display.max_rows', 10, 'display.max_columns', 5):
+    ...     pass
+    """
+
+    def __init__(self, *args) -> None:
+        if len(args) % 2 != 0 or len(args) < 2:
+            raise ValueError(
+                "Need to invoke as option_context(pat, val, [(pat, val), ...])."
+            )
+
+        self.ops = list(zip(args[::2], args[1::2]))
+
+    def __enter__(self) -> None:
+        self.undo = [(pat, _get_option(pat)) for pat, val in self.ops]
+
+        for pat, val in self.ops:
+            _set_option(pat, val, silent=True)
+
+    def __exit__(self, *args) -> None:
+        if self.undo:
+            for pat, val in self.undo:
+                _set_option(pat, val, silent=True)
+
+
+def register_option(
+    key: str,
+    defval: object,
+    doc: str = "",
+    validator: Callable[[object], Any] | None = None,
+    cb: Callable[[str], Any] | None = None,
+) -> None:
+    """
+    Register an option in the package-wide pandas config object
+
+    Parameters
+    ----------
+    key : str
+        Fully-qualified key, e.g. "x.y.option - z".
+    defval : object
+        Default value of the option.
+    doc : str
+        Description of the option.
+    validator : Callable, optional
+        Function of a single argument, should raise `ValueError` if
+        called with a value which is not a legal value for the option.
+    cb
+        a function of a single argument "key", which is called
+        immediately after an option value is set/reset. key is
+        the full name of the option.
+
+    Raises
+    ------
+    ValueError if `validator` is specified and `defval` is not a valid value.
+
+    """
+    import keyword
+    import tokenize
+
+    key = key.lower()
+
+    if key in _registered_options:
+        raise OptionError(f"Option '{key}' has already been registered")
+    if key in _reserved_keys:
+        raise OptionError(f"Option '{key}' is a reserved key")
+
+    # the default value should be legal
+    if validator:
+        validator(defval)
+
+    # walk the nested dict, creating dicts as needed along the path
+    path = key.split(".")
+
+    for k in path:
+        if not re.match("^" + tokenize.Name + "$", k):
+            raise ValueError(f"{k} is not a valid identifier")
+        if keyword.iskeyword(k):
+            raise ValueError(f"{k} is a python keyword")
+
+    cursor = _global_config
+    msg = "Path prefix to option '{option}' is already an option"
+
+    for i, p in enumerate(path[:-1]):
+        if not isinstance(cursor, dict):
+            raise OptionError(msg.format(option=".".join(path[:i])))
+        if p not in cursor:
+            cursor[p] = {}
+        cursor = cursor[p]
+
+    if not isinstance(cursor, dict):
+        raise OptionError(msg.format(option=".".join(path[:-1])))
+
+    cursor[path[-1]] = defval  # initialize
+
+    # save the option metadata
+    _registered_options[key] = RegisteredOption(
+        key=key, defval=defval, doc=doc, validator=validator, cb=cb
+    )
+
+
+def deprecate_option(
+    key: str,
+    msg: str | None = None,
+    rkey: str | None = None,
+    removal_ver: str | None = None,
+) -> None:
+    """
+    Mark option `key` as deprecated, if code attempts to access this option,
+    a warning will be produced, using `msg` if given, or a default message
+    if not.
+    if `rkey` is given, any access to the key will be re-routed to `rkey`.
+
+    Neither the existence of `key` nor that if `rkey` is checked. If they
+    do not exist, any subsequence access will fail as usual, after the
+    deprecation warning is given.
+
+    Parameters
+    ----------
+    key : str
+        Name of the option to be deprecated.
+        must be a fully-qualified option name (e.g "x.y.z.rkey").
+    msg : str, optional
+        Warning message to output when the key is referenced.
+        if no message is given a default message will be emitted.
+    rkey : str, optional
+        Name of an option to reroute access to.
+        If specified, any referenced `key` will be
+        re-routed to `rkey` including set/get/reset.
+        rkey must be a fully-qualified option name (e.g "x.y.z.rkey").
+        used by the default message if no `msg` is specified.
+    removal_ver : str, optional
+        Specifies the version in which this option will
+        be removed. used by the default message if no `msg` is specified.
+
+    Raises
+    ------
+    OptionError
+        If the specified key has already been deprecated.
+    """
+    key = key.lower()
+
+    if key in _deprecated_options:
+        raise OptionError(f"Option '{key}' has already been defined as deprecated.")
+
+    _deprecated_options[key] = DeprecatedOption(key, msg, rkey, removal_ver)
+
+
+#
+# functions internal to the module
+
+
+def _select_options(pat: str) -> list[str]:
+    """
+    returns a list of keys matching `pat`
+
+    if pat=="all", returns all registered options
+    """
+    # short-circuit for exact key
+    if pat in _registered_options:
+        return [pat]
+
+    # else look through all of them
+    keys = sorted(_registered_options.keys())
+    if pat == "all":  # reserved key
+        return keys
+
+    return [k for k in keys if re.search(pat, k, re.I)]
+
+
+def _get_root(key: str) -> tuple[dict[str, Any], str]:
+    path = key.split(".")
+    cursor = _global_config
+    for p in path[:-1]:
+        cursor = cursor[p]
+    return cursor, path[-1]
+
+
+def _is_deprecated(key: str) -> bool:
+    """Returns True if the given option has been deprecated"""
+    key = key.lower()
+    return key in _deprecated_options
+
+
+def _get_deprecated_option(key: str):
+    """
+    Retrieves the metadata for a deprecated option, if `key` is deprecated.
+
+    Returns
+    -------
+    DeprecatedOption (namedtuple) if key is deprecated, None otherwise
+    """
+    try:
+        d = _deprecated_options[key]
+    except KeyError:
+        return None
+    else:
+        return d
+
+
+def _get_registered_option(key: str):
+    """
+    Retrieves the option metadata if `key` is a registered option.
+
+    Returns
+    -------
+    RegisteredOption (namedtuple) if key is deprecated, None otherwise
+    """
+    return _registered_options.get(key)
+
+
+def _translate_key(key: str) -> str:
+    """
+    if key id deprecated and a replacement key defined, will return the
+    replacement key, otherwise returns `key` as - is
+    """
+    d = _get_deprecated_option(key)
+    if d:
+        return d.rkey or key
+    else:
+        return key
+
+
+def _warn_if_deprecated(key: str) -> bool:
+    """
+    Checks if `key` is a deprecated option and if so, prints a warning.
+
+    Returns
+    -------
+    bool - True if `key` is deprecated, False otherwise.
+    """
+    d = _get_deprecated_option(key)
+    if d:
+        if d.msg:
+            warnings.warn(
+                d.msg,
+                FutureWarning,
+                stacklevel=find_stack_level(),
+            )
+        else:
+            msg = f"'{key}' is deprecated"
+            if d.removal_ver:
+                msg += f" and will be removed in {d.removal_ver}"
+            if d.rkey:
+                msg += f", please use '{d.rkey}' instead."
+            else:
+                msg += ", please refrain from using it."
+
+            warnings.warn(msg, FutureWarning, stacklevel=find_stack_level())
+        return True
+    return False
+
+
+def _build_option_description(k: str) -> str:
+    """Builds a formatted description of a registered option and prints it"""
+    o = _get_registered_option(k)
+    d = _get_deprecated_option(k)
+
+    s = f"{k} "
+
+    if o.doc:
+        s += "\n".join(o.doc.strip().split("\n"))
+    else:
+        s += "No description available."
+
+    if o:
+        s += f"\n    [default: {o.defval}] [currently: {_get_option(k, True)}]"
+
+    if d:
+        rkey = d.rkey or ""
+        s += "\n    (Deprecated"
+        s += f", use `{rkey}` instead."
+        s += ")"
+
+    return s
+
+
+def pp_options_list(keys: Iterable[str], width: int = 80, _print: bool = False):
+    """Builds a concise listing of available options, grouped by prefix"""
+    from itertools import groupby
+    from textwrap import wrap
+
+    def pp(name: str, ks: Iterable[str]) -> list[str]:
+        pfx = "- " + name + ".[" if name else ""
+        ls = wrap(
+            ", ".join(ks),
+            width,
+            initial_indent=pfx,
+            subsequent_indent="  ",
+            break_long_words=False,
+        )
+        if ls and ls[-1] and name:
+            ls[-1] = ls[-1] + "]"
+        return ls
+
+    ls: list[str] = []
+    singles = [x for x in sorted(keys) if x.find(".") < 0]
+    if singles:
+        ls += pp("", singles)
+    keys = [x for x in keys if x.find(".") >= 0]
+
+    for k, g in groupby(sorted(keys), lambda x: x[: x.rfind(".")]):
+        ks = [x[len(k) + 1 :] for x in list(g)]
+        ls += pp(k, ks)
+    s = "\n".join(ls)
+    if _print:
+        print(s)
+    else:
+        return s
+
+
+#
+# helpers
+
+
+@contextmanager
+def config_prefix(prefix: str) -> Generator[None, None, None]:
+    """
+    contextmanager for multiple invocations of API with a common prefix
+
+    supported API functions: (register / get / set )__option
+
+    Warning: This is not thread - safe, and won't work properly if you import
+    the API functions into your module using the "from x import y" construct.
+
+    Example
+    -------
+    import pandas._config.config as cf
+    with cf.config_prefix("display.font"):
+        cf.register_option("color", "red")
+        cf.register_option("size", " 5 pt")
+        cf.set_option(size, " 6 pt")
+        cf.get_option(size)
+        ...
+
+        etc'
+
+    will register options "display.font.color", "display.font.size", set the
+    value of "display.font.size"... and so on.
+    """
+    # Note: reset_option relies on set_option, and on key directly
+    # it does not fit in to this monkey-patching scheme
+
+    global register_option, get_option, set_option
+
+    def wrap(func: F) -> F:
+        def inner(key: str, *args, **kwds):
+            pkey = f"{prefix}.{key}"
+            return func(pkey, *args, **kwds)
+
+        return cast(F, inner)
+
+    _register_option = register_option
+    _get_option = get_option
+    _set_option = set_option
+    set_option = wrap(set_option)
+    get_option = wrap(get_option)
+    register_option = wrap(register_option)
+    try:
+        yield
+    finally:
+        set_option = _set_option
+        get_option = _get_option
+        register_option = _register_option
+
+
+# These factories and methods are handy for use as the validator
+# arg in register_option
+
+
+def is_type_factory(_type: type[Any]) -> Callable[[Any], None]:
+    """
+
+    Parameters
+    ----------
+    `_type` - a type to be compared against (e.g. type(x) == `_type`)
+
+    Returns
+    -------
+    validator - a function of a single argument x , which raises
+                ValueError if type(x) is not equal to `_type`
+
+    """
+
+    def inner(x) -> None:
+        if type(x) != _type:
+            raise ValueError(f"Value must have type '{_type}'")
+
+    return inner
+
+
+def is_instance_factory(_type) -> Callable[[Any], None]:
+    """
+
+    Parameters
+    ----------
+    `_type` - the type to be checked against
+
+    Returns
+    -------
+    validator - a function of a single argument x , which raises
+                ValueError if x is not an instance of `_type`
+
+    """
+    if isinstance(_type, (tuple, list)):
+        _type = tuple(_type)
+        type_repr = "|".join(map(str, _type))
+    else:
+        type_repr = f"'{_type}'"
+
+    def inner(x) -> None:
+        if not isinstance(x, _type):
+            raise ValueError(f"Value must be an instance of {type_repr}")
+
+    return inner
+
+
+def is_one_of_factory(legal_values) -> Callable[[Any], None]:
+    callables = [c for c in legal_values if callable(c)]
+    legal_values = [c for c in legal_values if not callable(c)]
+
+    def inner(x) -> None:
+        if x not in legal_values:
+            if not any(c(x) for c in callables):
+                uvals = [str(lval) for lval in legal_values]
+                pp_values = "|".join(uvals)
+                msg = f"Value must be one of {pp_values}"
+                if len(callables):
+                    msg += " or a callable"
+                raise ValueError(msg)
+
+    return inner
+
+
+def is_nonnegative_int(value: object) -> None:
+    """
+    Verify that value is None or a positive int.
+
+    Parameters
+    ----------
+    value : None or int
+            The `value` to be checked.
+
+    Raises
+    ------
+    ValueError
+        When the value is not None or is a negative integer
+    """
+    if value is None:
+        return
+
+    elif isinstance(value, int):
+        if value >= 0:
+            return
+
+    msg = "Value must be a nonnegative integer or None"
+    raise ValueError(msg)
+
+
+# common type validators, for convenience
+# usage: register_option(... , validator = is_int)
+is_int = is_type_factory(int)
+is_bool = is_type_factory(bool)
+is_float = is_type_factory(float)
+is_str = is_type_factory(str)
+is_text = is_instance_factory((str, bytes))
+
+
+def is_callable(obj) -> bool:
+    """
+
+    Parameters
+    ----------
+    `obj` - the object to be checked
+
+    Returns
+    -------
+    validator - returns True if object is callable
+        raises ValueError otherwise.
+
+    """
+    if not callable(obj):
+        raise ValueError("Value must be a callable")
+    return True

.venv_haddock/lib/python3.12/site-packages/pandas/_config/dates.py

@@ -0,0 +1,25 @@
+"""
+config for datetime formatting
+"""
+from __future__ import annotations
+
+from pandas._config import config as cf
+
+pc_date_dayfirst_doc = """
+: boolean
+    When True, prints and parses dates with the day first, eg 20/01/2005
+"""
+
+pc_date_yearfirst_doc = """
+: boolean
+    When True, prints and parses dates with the year first, eg 2005/01/20
+"""
+
+with cf.config_prefix("display"):
+    # Needed upstream of `_libs` because these are used in tslibs.parsing
+    cf.register_option(
+        "date_dayfirst", False, pc_date_dayfirst_doc, validator=cf.is_bool
+    )
+    cf.register_option(
+        "date_yearfirst", False, pc_date_yearfirst_doc, validator=cf.is_bool
+    )

.venv_haddock/lib/python3.12/site-packages/pandas/_config/display.py

@@ -0,0 +1,62 @@
+"""
+Unopinionated display configuration.
+"""
+
+from __future__ import annotations
+
+import locale
+import sys
+
+from pandas._config import config as cf
+
+# -----------------------------------------------------------------------------
+# Global formatting options
+_initial_defencoding: str | None = None
+
+
+def detect_console_encoding() -> str:
+    """
+    Try to find the most capable encoding supported by the console.
+    slightly modified from the way IPython handles the same issue.
+    """
+    global _initial_defencoding
+
+    encoding = None
+    try:
+        encoding = sys.stdout.encoding or sys.stdin.encoding
+    except (AttributeError, OSError):
+        pass
+
+    # try again for something better
+    if not encoding or "ascii" in encoding.lower():
+        try:
+            encoding = locale.getpreferredencoding()
+        except locale.Error:
+            # can be raised by locale.setlocale(), which is
+            #  called by getpreferredencoding
+            #  (on some systems, see stdlib locale docs)
+            pass
+
+    # when all else fails. this will usually be "ascii"
+    if not encoding or "ascii" in encoding.lower():
+        encoding = sys.getdefaultencoding()
+
+    # GH#3360, save the reported defencoding at import time
+    # MPL backends may change it. Make available for debugging.
+    if not _initial_defencoding:
+        _initial_defencoding = sys.getdefaultencoding()
+
+    return encoding
+
+
+pc_encoding_doc = """
+: str/unicode
+    Defaults to the detected encoding of the console.
+    Specifies the encoding to be used for strings returned by to_string,
+    these are generally strings meant to be displayed on the console.
+"""
+
+with cf.config_prefix("display"):
+    cf.register_option(
+        "encoding", detect_console_encoding(), pc_encoding_doc, validator=cf.is_text
+    )

.venv_haddock/lib/python3.12/site-packages/pandas/_config/localization.py

@@ -0,0 +1,172 @@
+"""
+Helpers for configuring locale settings.
+
+Name `localization` is chosen to avoid overlap with builtin `locale` module.
+"""
+from __future__ import annotations
+
+from contextlib import contextmanager
+import locale
+import platform
+import re
+import subprocess
+from typing import TYPE_CHECKING
+
+from pandas._config.config import options
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+
+
+@contextmanager
+def set_locale(
+    new_locale: str | tuple[str, str], lc_var: int = locale.LC_ALL
+) -> Generator[str | tuple[str, str], None, None]:
+    """
+    Context manager for temporarily setting a locale.
+
+    Parameters
+    ----------
+    new_locale : str or tuple
+        A string of the form <language_country>.<encoding>. For example to set
+        the current locale to US English with a UTF8 encoding, you would pass
+        "en_US.UTF-8".
+    lc_var : int, default `locale.LC_ALL`
+        The category of the locale being set.
+
+    Notes
+    -----
+    This is useful when you want to run a particular block of code under a
+    particular locale, without globally setting the locale. This probably isn't
+    thread-safe.
+    """
+    # getlocale is not always compliant with setlocale, use setlocale. GH#46595
+    current_locale = locale.setlocale(lc_var)
+
+    try:
+        locale.setlocale(lc_var, new_locale)
+        normalized_code, normalized_encoding = locale.getlocale()
+        if normalized_code is not None and normalized_encoding is not None:
+            yield f"{normalized_code}.{normalized_encoding}"
+        else:
+            yield new_locale
+    finally:
+        locale.setlocale(lc_var, current_locale)
+
+
+def can_set_locale(lc: str, lc_var: int = locale.LC_ALL) -> bool:
+    """
+    Check to see if we can set a locale, and subsequently get the locale,
+    without raising an Exception.
+
+    Parameters
+    ----------
+    lc : str
+        The locale to attempt to set.
+    lc_var : int, default `locale.LC_ALL`
+        The category of the locale being set.
+
+    Returns
+    -------
+    bool
+        Whether the passed locale can be set
+    """
+    try:
+        with set_locale(lc, lc_var=lc_var):
+            pass
+    except (ValueError, locale.Error):
+        # horrible name for a Exception subclass
+        return False
+    else:
+        return True
+
+
+def _valid_locales(locales: list[str] | str, normalize: bool) -> list[str]:
+    """
+    Return a list of normalized locales that do not throw an ``Exception``
+    when set.
+
+    Parameters
+    ----------
+    locales : str
+        A string where each locale is separated by a newline.
+    normalize : bool
+        Whether to call ``locale.normalize`` on each locale.
+
+    Returns
+    -------
+    valid_locales : list
+        A list of valid locales.
+    """
+    return [
+        loc
+        for loc in (
+            locale.normalize(loc.strip()) if normalize else loc.strip()
+            for loc in locales
+        )
+        if can_set_locale(loc)
+    ]
+
+
+def get_locales(
+    prefix: str | None = None,
+    normalize: bool = True,
+) -> list[str]:
+    """
+    Get all the locales that are available on the system.
+
+    Parameters
+    ----------
+    prefix : str
+        If not ``None`` then return only those locales with the prefix
+        provided. For example to get all English language locales (those that
+        start with ``"en"``), pass ``prefix="en"``.
+    normalize : bool
+        Call ``locale.normalize`` on the resulting list of available locales.
+        If ``True``, only locales that can be set without throwing an
+        ``Exception`` are returned.
+
+    Returns
+    -------
+    locales : list of strings
+        A list of locale strings that can be set with ``locale.setlocale()``.
+        For example::
+
+            locale.setlocale(locale.LC_ALL, locale_string)
+
+    On error will return an empty list (no locale available, e.g. Windows)
+
+    """
+    if platform.system() in ("Linux", "Darwin"):
+        raw_locales = subprocess.check_output(["locale", "-a"])
+    else:
+        # Other platforms e.g. windows platforms don't define "locale -a"
+        #  Note: is_platform_windows causes circular import here
+        return []
+
+    try:
+        # raw_locales is "\n" separated list of locales
+        # it may contain non-decodable parts, so split
+        # extract what we can and then rejoin.
+        split_raw_locales = raw_locales.split(b"\n")
+        out_locales = []
+        for x in split_raw_locales:
+            try:
+                out_locales.append(str(x, encoding=options.display.encoding))
+            except UnicodeError:
+                # 'locale -a' is used to populated 'raw_locales' and on
+                # Redhat 7 Linux (and maybe others) prints locale names
+                # using windows-1252 encoding.  Bug only triggered by
+                # a few special characters and when there is an
+                # extensive list of installed locales.
+                out_locales.append(str(x, encoding="windows-1252"))
+
+    except TypeError:
+        pass
+
+    if prefix is None:
+        return _valid_locales(out_locales, normalize)
+
+    pattern = re.compile(f"{prefix}.*")
+    found = pattern.findall("\n".join(out_locales))
+    return _valid_locales(found, normalize)

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/arrays.pyi

@@ -0,0 +1,40 @@
+from typing import Sequence
+
+import numpy as np
+
+from pandas._typing import (
+    AxisInt,
+    DtypeObj,
+    Self,
+    Shape,
+)
+
+class NDArrayBacked:
+    _dtype: DtypeObj
+    _ndarray: np.ndarray
+    def __init__(self, values: np.ndarray, dtype: DtypeObj) -> None: ...
+    @classmethod
+    def _simple_new(cls, values: np.ndarray, dtype: DtypeObj): ...
+    def _from_backing_data(self, values: np.ndarray): ...
+    def __setstate__(self, state): ...
+    def __len__(self) -> int: ...
+    @property
+    def shape(self) -> Shape: ...
+    @property
+    def ndim(self) -> int: ...
+    @property
+    def size(self) -> int: ...
+    @property
+    def nbytes(self) -> int: ...
+    def copy(self, order=...): ...
+    def delete(self, loc, axis=...): ...
+    def swapaxes(self, axis1, axis2): ...
+    def repeat(self, repeats: int | Sequence[int], axis: int | None = ...): ...
+    def reshape(self, *args, **kwargs): ...
+    def ravel(self, order=...): ...
+    @property
+    def T(self): ...
+    @classmethod
+    def _concat_same_type(
+        cls, to_concat: Sequence[Self], axis: AxisInt = ...
+    ) -> Self: ...

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/byteswap.pyi

@@ -0,0 +1,5 @@
+def read_float_with_byteswap(data: bytes, offset: int, byteswap: bool) -> float: ...
+def read_double_with_byteswap(data: bytes, offset: int, byteswap: bool) -> float: ...
+def read_uint16_with_byteswap(data: bytes, offset: int, byteswap: bool) -> int: ...
+def read_uint32_with_byteswap(data: bytes, offset: int, byteswap: bool) -> int: ...
+def read_uint64_with_byteswap(data: bytes, offset: int, byteswap: bool) -> int: ...

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/hashing.pyi

@@ -0,0 +1,9 @@
+import numpy as np
+
+from pandas._typing import npt
+
+def hash_object_array(
+    arr: npt.NDArray[np.object_],
+    key: str,
+    encoding: str = ...,
+) -> npt.NDArray[np.uint64]: ...

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/hashtable.pyi

@@ -0,0 +1,252 @@
+from typing import (
+    Any,
+    Hashable,
+    Literal,
+)
+
+import numpy as np
+
+from pandas._typing import npt
+
+def unique_label_indices(
+    labels: np.ndarray,  # const int64_t[:]
+) -> np.ndarray: ...
+
+class Factorizer:
+    count: int
+    uniques: Any
+    def __init__(self, size_hint: int) -> None: ...
+    def get_count(self) -> int: ...
+    def factorize(
+        self,
+        values: np.ndarray,
+        na_sentinel=...,
+        na_value=...,
+        mask=...,
+    ) -> npt.NDArray[np.intp]: ...
+
+class ObjectFactorizer(Factorizer):
+    table: PyObjectHashTable
+    uniques: ObjectVector
+
+class Int64Factorizer(Factorizer):
+    table: Int64HashTable
+    uniques: Int64Vector
+
+class UInt64Factorizer(Factorizer):
+    table: UInt64HashTable
+    uniques: UInt64Vector
+
+class Int32Factorizer(Factorizer):
+    table: Int32HashTable
+    uniques: Int32Vector
+
+class UInt32Factorizer(Factorizer):
+    table: UInt32HashTable
+    uniques: UInt32Vector
+
+class Int16Factorizer(Factorizer):
+    table: Int16HashTable
+    uniques: Int16Vector
+
+class UInt16Factorizer(Factorizer):
+    table: UInt16HashTable
+    uniques: UInt16Vector
+
+class Int8Factorizer(Factorizer):
+    table: Int8HashTable
+    uniques: Int8Vector
+
+class UInt8Factorizer(Factorizer):
+    table: UInt8HashTable
+    uniques: UInt8Vector
+
+class Float64Factorizer(Factorizer):
+    table: Float64HashTable
+    uniques: Float64Vector
+
+class Float32Factorizer(Factorizer):
+    table: Float32HashTable
+    uniques: Float32Vector
+
+class Complex64Factorizer(Factorizer):
+    table: Complex64HashTable
+    uniques: Complex64Vector
+
+class Complex128Factorizer(Factorizer):
+    table: Complex128HashTable
+    uniques: Complex128Vector
+
+class Int64Vector:
+    def __init__(self, *args) -> None: ...
+    def __len__(self) -> int: ...
+    def to_array(self) -> npt.NDArray[np.int64]: ...
+
+class Int32Vector:
+    def __init__(self, *args) -> None: ...
+    def __len__(self) -> int: ...
+    def to_array(self) -> npt.NDArray[np.int32]: ...
+
+class Int16Vector:
+    def __init__(self, *args) -> None: ...
+    def __len__(self) -> int: ...
+    def to_array(self) -> npt.NDArray[np.int16]: ...
+
+class Int8Vector:
+    def __init__(self, *args) -> None: ...
+    def __len__(self) -> int: ...
+    def to_array(self) -> npt.NDArray[np.int8]: ...
+
+class UInt64Vector:
+    def __init__(self, *args) -> None: ...
+    def __len__(self) -> int: ...
+    def to_array(self) -> npt.NDArray[np.uint64]: ...
+
+class UInt32Vector:
+    def __init__(self, *args) -> None: ...
+    def __len__(self) -> int: ...
+    def to_array(self) -> npt.NDArray[np.uint32]: ...
+
+class UInt16Vector:
+    def __init__(self, *args) -> None: ...
+    def __len__(self) -> int: ...
+    def to_array(self) -> npt.NDArray[np.uint16]: ...
+
+class UInt8Vector:
+    def __init__(self, *args) -> None: ...
+    def __len__(self) -> int: ...
+    def to_array(self) -> npt.NDArray[np.uint8]: ...
+
+class Float64Vector:
+    def __init__(self, *args) -> None: ...
+    def __len__(self) -> int: ...
+    def to_array(self) -> npt.NDArray[np.float64]: ...
+
+class Float32Vector:
+    def __init__(self, *args) -> None: ...
+    def __len__(self) -> int: ...
+    def to_array(self) -> npt.NDArray[np.float32]: ...
+
+class Complex128Vector:
+    def __init__(self, *args) -> None: ...
+    def __len__(self) -> int: ...
+    def to_array(self) -> npt.NDArray[np.complex128]: ...
+
+class Complex64Vector:
+    def __init__(self, *args) -> None: ...
+    def __len__(self) -> int: ...
+    def to_array(self) -> npt.NDArray[np.complex64]: ...
+
+class StringVector:
+    def __init__(self, *args) -> None: ...
+    def __len__(self) -> int: ...
+    def to_array(self) -> npt.NDArray[np.object_]: ...
+
+class ObjectVector:
+    def __init__(self, *args) -> None: ...
+    def __len__(self) -> int: ...
+    def to_array(self) -> npt.NDArray[np.object_]: ...
+
+class HashTable:
+    # NB: The base HashTable class does _not_ actually have these methods;
+    #  we are putting them here for the sake of mypy to avoid
+    #  reproducing them in each subclass below.
+    def __init__(self, size_hint: int = ..., uses_mask: bool = ...) -> None: ...
+    def __len__(self) -> int: ...
+    def __contains__(self, key: Hashable) -> bool: ...
+    def sizeof(self, deep: bool = ...) -> int: ...
+    def get_state(self) -> dict[str, int]: ...
+    # TODO: `val/key` type is subclass-specific
+    def get_item(self, val): ...  # TODO: return type?
+    def set_item(self, key, val) -> None: ...
+    def get_na(self): ...  # TODO: return type?
+    def set_na(self, val) -> None: ...
+    def map_locations(
+        self,
+        values: np.ndarray,  # np.ndarray[subclass-specific]
+        mask: npt.NDArray[np.bool_] | None = ...,
+    ) -> None: ...
+    def lookup(
+        self,
+        values: np.ndarray,  # np.ndarray[subclass-specific]
+        mask: npt.NDArray[np.bool_] | None = ...,
+    ) -> npt.NDArray[np.intp]: ...
+    def get_labels(
+        self,
+        values: np.ndarray,  # np.ndarray[subclass-specific]
+        uniques,  # SubclassTypeVector
+        count_prior: int = ...,
+        na_sentinel: int = ...,
+        na_value: object = ...,
+        mask=...,
+    ) -> npt.NDArray[np.intp]: ...
+    def unique(
+        self,
+        values: np.ndarray,  # np.ndarray[subclass-specific]
+        return_inverse: bool = ...,
+        mask=...,
+    ) -> (
+        tuple[
+            np.ndarray,  # np.ndarray[subclass-specific]
+            npt.NDArray[np.intp],
+        ]
+        | np.ndarray
+    ): ...  # np.ndarray[subclass-specific]
+    def factorize(
+        self,
+        values: np.ndarray,  # np.ndarray[subclass-specific]
+        na_sentinel: int = ...,
+        na_value: object = ...,
+        mask=...,
+        ignore_na: bool = True,
+    ) -> tuple[np.ndarray, npt.NDArray[np.intp]]: ...  # np.ndarray[subclass-specific]
+
+class Complex128HashTable(HashTable): ...
+class Complex64HashTable(HashTable): ...
+class Float64HashTable(HashTable): ...
+class Float32HashTable(HashTable): ...
+
+class Int64HashTable(HashTable):
+    # Only Int64HashTable has get_labels_groupby, map_keys_to_values
+    def get_labels_groupby(
+        self,
+        values: npt.NDArray[np.int64],  # const int64_t[:]
+    ) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.int64]]: ...
+    def map_keys_to_values(
+        self,
+        keys: npt.NDArray[np.int64],
+        values: npt.NDArray[np.int64],  # const int64_t[:]
+    ) -> None: ...
+
+class Int32HashTable(HashTable): ...
+class Int16HashTable(HashTable): ...
+class Int8HashTable(HashTable): ...
+class UInt64HashTable(HashTable): ...
+class UInt32HashTable(HashTable): ...
+class UInt16HashTable(HashTable): ...
+class UInt8HashTable(HashTable): ...
+class StringHashTable(HashTable): ...
+class PyObjectHashTable(HashTable): ...
+class IntpHashTable(HashTable): ...
+
+def duplicated(
+    values: np.ndarray,
+    keep: Literal["last", "first", False] = ...,
+    mask: npt.NDArray[np.bool_] | None = ...,
+) -> npt.NDArray[np.bool_]: ...
+def mode(
+    values: np.ndarray, dropna: bool, mask: npt.NDArray[np.bool_] | None = ...
+) -> np.ndarray: ...
+def value_count(
+    values: np.ndarray,
+    dropna: bool,
+    mask: npt.NDArray[np.bool_] | None = ...,
+) -> tuple[np.ndarray, npt.NDArray[np.int64], int]: ...  # np.ndarray[same-as-values]
+
+# arr and values should have same dtype
+def ismember(
+    arr: np.ndarray,
+    values: np.ndarray,
+) -> npt.NDArray[np.bool_]: ...
+def object_hash(obj) -> int: ...
+def objects_are_equal(a, b) -> bool: ...

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/index.pyi

@@ -0,0 +1,103 @@
+import numpy as np
+
+from pandas._typing import npt
+
+from pandas import MultiIndex
+from pandas.core.arrays import ExtensionArray
+
+multiindex_nulls_shift: int
+
+class IndexEngine:
+    over_size_threshold: bool
+    def __init__(self, values: np.ndarray) -> None: ...
+    def __contains__(self, val: object) -> bool: ...
+
+    # -> int | slice | np.ndarray[bool]
+    def get_loc(self, val: object) -> int | slice | np.ndarray: ...
+    def sizeof(self, deep: bool = ...) -> int: ...
+    def __sizeof__(self) -> int: ...
+    @property
+    def is_unique(self) -> bool: ...
+    @property
+    def is_monotonic_increasing(self) -> bool: ...
+    @property
+    def is_monotonic_decreasing(self) -> bool: ...
+    @property
+    def is_mapping_populated(self) -> bool: ...
+    def clear_mapping(self): ...
+    def get_indexer(self, values: np.ndarray) -> npt.NDArray[np.intp]: ...
+    def get_indexer_non_unique(
+        self,
+        targets: np.ndarray,
+    ) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
+
+class MaskedIndexEngine(IndexEngine):
+    def __init__(self, values: object) -> None: ...
+    def get_indexer_non_unique(
+        self, targets: object
+    ) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
+
+class Float64Engine(IndexEngine): ...
+class Float32Engine(IndexEngine): ...
+class Complex128Engine(IndexEngine): ...
+class Complex64Engine(IndexEngine): ...
+class Int64Engine(IndexEngine): ...
+class Int32Engine(IndexEngine): ...
+class Int16Engine(IndexEngine): ...
+class Int8Engine(IndexEngine): ...
+class UInt64Engine(IndexEngine): ...
+class UInt32Engine(IndexEngine): ...
+class UInt16Engine(IndexEngine): ...
+class UInt8Engine(IndexEngine): ...
+class ObjectEngine(IndexEngine): ...
+class DatetimeEngine(Int64Engine): ...
+class TimedeltaEngine(DatetimeEngine): ...
+class PeriodEngine(Int64Engine): ...
+class BoolEngine(UInt8Engine): ...
+class MaskedFloat64Engine(MaskedIndexEngine): ...
+class MaskedFloat32Engine(MaskedIndexEngine): ...
+class MaskedComplex128Engine(MaskedIndexEngine): ...
+class MaskedComplex64Engine(MaskedIndexEngine): ...
+class MaskedInt64Engine(MaskedIndexEngine): ...
+class MaskedInt32Engine(MaskedIndexEngine): ...
+class MaskedInt16Engine(MaskedIndexEngine): ...
+class MaskedInt8Engine(MaskedIndexEngine): ...
+class MaskedUInt64Engine(MaskedIndexEngine): ...
+class MaskedUInt32Engine(MaskedIndexEngine): ...
+class MaskedUInt16Engine(MaskedIndexEngine): ...
+class MaskedUInt8Engine(MaskedIndexEngine): ...
+class MaskedBoolEngine(MaskedUInt8Engine): ...
+
+class StringObjectEngine(ObjectEngine):
+    def __init__(self, values: object, na_value) -> None: ...
+
+class BaseMultiIndexCodesEngine:
+    levels: list[np.ndarray]
+    offsets: np.ndarray  # ndarray[uint64_t, ndim=1]
+
+    def __init__(
+        self,
+        levels: list[np.ndarray],  # all entries hashable
+        labels: list[np.ndarray],  # all entries integer-dtyped
+        offsets: np.ndarray,  # np.ndarray[np.uint64, ndim=1]
+    ) -> None: ...
+    def get_indexer(self, target: npt.NDArray[np.object_]) -> npt.NDArray[np.intp]: ...
+    def _extract_level_codes(self, target: MultiIndex) -> np.ndarray: ...
+
+class ExtensionEngine:
+    def __init__(self, values: ExtensionArray) -> None: ...
+    def __contains__(self, val: object) -> bool: ...
+    def get_loc(self, val: object) -> int | slice | np.ndarray: ...
+    def get_indexer(self, values: np.ndarray) -> npt.NDArray[np.intp]: ...
+    def get_indexer_non_unique(
+        self,
+        targets: np.ndarray,
+    ) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
+    @property
+    def is_unique(self) -> bool: ...
+    @property
+    def is_monotonic_increasing(self) -> bool: ...
+    @property
+    def is_monotonic_decreasing(self) -> bool: ...
+    def sizeof(self, deep: bool = ...) -> int: ...
+    def clear_mapping(self): ...

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/interval.pyi

@@ -0,0 +1,174 @@
+from typing import (
+    Any,
+    Generic,
+    TypeVar,
+    overload,
+)
+
+import numpy as np
+import numpy.typing as npt
+
+from pandas._typing import (
+    IntervalClosedType,
+    Timedelta,
+    Timestamp,
+)
+
+VALID_CLOSED: frozenset[str]
+
+_OrderableScalarT = TypeVar("_OrderableScalarT", int, float)
+_OrderableTimesT = TypeVar("_OrderableTimesT", Timestamp, Timedelta)
+_OrderableT = TypeVar("_OrderableT", int, float, Timestamp, Timedelta)
+
+class _LengthDescriptor:
+    @overload
+    def __get__(
+        self, instance: Interval[_OrderableScalarT], owner: Any
+    ) -> _OrderableScalarT: ...
+    @overload
+    def __get__(
+        self, instance: Interval[_OrderableTimesT], owner: Any
+    ) -> Timedelta: ...
+
+class _MidDescriptor:
+    @overload
+    def __get__(self, instance: Interval[_OrderableScalarT], owner: Any) -> float: ...
+    @overload
+    def __get__(
+        self, instance: Interval[_OrderableTimesT], owner: Any
+    ) -> _OrderableTimesT: ...
+
+class IntervalMixin:
+    @property
+    def closed_left(self) -> bool: ...
+    @property
+    def closed_right(self) -> bool: ...
+    @property
+    def open_left(self) -> bool: ...
+    @property
+    def open_right(self) -> bool: ...
+    @property
+    def is_empty(self) -> bool: ...
+    def _check_closed_matches(self, other: IntervalMixin, name: str = ...) -> None: ...
+
+class Interval(IntervalMixin, Generic[_OrderableT]):
+    @property
+    def left(self: Interval[_OrderableT]) -> _OrderableT: ...
+    @property
+    def right(self: Interval[_OrderableT]) -> _OrderableT: ...
+    @property
+    def closed(self) -> IntervalClosedType: ...
+    mid: _MidDescriptor
+    length: _LengthDescriptor
+    def __init__(
+        self,
+        left: _OrderableT,
+        right: _OrderableT,
+        closed: IntervalClosedType = ...,
+    ) -> None: ...
+    def __hash__(self) -> int: ...
+    @overload
+    def __contains__(
+        self: Interval[Timedelta], key: Timedelta | Interval[Timedelta]
+    ) -> bool: ...
+    @overload
+    def __contains__(
+        self: Interval[Timestamp], key: Timestamp | Interval[Timestamp]
+    ) -> bool: ...
+    @overload
+    def __contains__(
+        self: Interval[_OrderableScalarT],
+        key: _OrderableScalarT | Interval[_OrderableScalarT],
+    ) -> bool: ...
+    @overload
+    def __add__(
+        self: Interval[_OrderableTimesT], y: Timedelta
+    ) -> Interval[_OrderableTimesT]: ...
+    @overload
+    def __add__(
+        self: Interval[int], y: _OrderableScalarT
+    ) -> Interval[_OrderableScalarT]: ...
+    @overload
+    def __add__(self: Interval[float], y: float) -> Interval[float]: ...
+    @overload
+    def __radd__(
+        self: Interval[_OrderableTimesT], y: Timedelta
+    ) -> Interval[_OrderableTimesT]: ...
+    @overload
+    def __radd__(
+        self: Interval[int], y: _OrderableScalarT
+    ) -> Interval[_OrderableScalarT]: ...
+    @overload
+    def __radd__(self: Interval[float], y: float) -> Interval[float]: ...
+    @overload
+    def __sub__(
+        self: Interval[_OrderableTimesT], y: Timedelta
+    ) -> Interval[_OrderableTimesT]: ...
+    @overload
+    def __sub__(
+        self: Interval[int], y: _OrderableScalarT
+    ) -> Interval[_OrderableScalarT]: ...
+    @overload
+    def __sub__(self: Interval[float], y: float) -> Interval[float]: ...
+    @overload
+    def __rsub__(
+        self: Interval[_OrderableTimesT], y: Timedelta
+    ) -> Interval[_OrderableTimesT]: ...
+    @overload
+    def __rsub__(
+        self: Interval[int], y: _OrderableScalarT
+    ) -> Interval[_OrderableScalarT]: ...
+    @overload
+    def __rsub__(self: Interval[float], y: float) -> Interval[float]: ...
+    @overload
+    def __mul__(
+        self: Interval[int], y: _OrderableScalarT
+    ) -> Interval[_OrderableScalarT]: ...
+    @overload
+    def __mul__(self: Interval[float], y: float) -> Interval[float]: ...
+    @overload
+    def __rmul__(
+        self: Interval[int], y: _OrderableScalarT
+    ) -> Interval[_OrderableScalarT]: ...
+    @overload
+    def __rmul__(self: Interval[float], y: float) -> Interval[float]: ...
+    @overload
+    def __truediv__(
+        self: Interval[int], y: _OrderableScalarT
+    ) -> Interval[_OrderableScalarT]: ...
+    @overload
+    def __truediv__(self: Interval[float], y: float) -> Interval[float]: ...
+    @overload
+    def __floordiv__(
+        self: Interval[int], y: _OrderableScalarT
+    ) -> Interval[_OrderableScalarT]: ...
+    @overload
+    def __floordiv__(self: Interval[float], y: float) -> Interval[float]: ...
+    def overlaps(self: Interval[_OrderableT], other: Interval[_OrderableT]) -> bool: ...
+
+def intervals_to_interval_bounds(
+    intervals: np.ndarray, validate_closed: bool = ...
+) -> tuple[np.ndarray, np.ndarray, IntervalClosedType]: ...
+
+class IntervalTree(IntervalMixin):
+    def __init__(
+        self,
+        left: np.ndarray,
+        right: np.ndarray,
+        closed: IntervalClosedType = ...,
+        leaf_size: int = ...,
+    ) -> None: ...
+    @property
+    def mid(self) -> np.ndarray: ...
+    @property
+    def length(self) -> np.ndarray: ...
+    def get_indexer(self, target) -> npt.NDArray[np.intp]: ...
+    def get_indexer_non_unique(
+        self, target
+    ) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
+    _na_count: int
+    @property
+    def is_overlapping(self) -> bool: ...
+    @property
+    def is_monotonic_increasing(self) -> bool: ...
+    def clear_mapping(self) -> None: ...

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/join.pyi

@@ -0,0 +1,79 @@
+import numpy as np
+
+from pandas._typing import npt
+
+def inner_join(
+    left: np.ndarray,  # const intp_t[:]
+    right: np.ndarray,  # const intp_t[:]
+    max_groups: int,
+    sort: bool = ...,
+) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
+def left_outer_join(
+    left: np.ndarray,  # const intp_t[:]
+    right: np.ndarray,  # const intp_t[:]
+    max_groups: int,
+    sort: bool = ...,
+) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
+def full_outer_join(
+    left: np.ndarray,  # const intp_t[:]
+    right: np.ndarray,  # const intp_t[:]
+    max_groups: int,
+) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
+def ffill_indexer(
+    indexer: np.ndarray,  # const intp_t[:]
+) -> npt.NDArray[np.intp]: ...
+def left_join_indexer_unique(
+    left: np.ndarray,  # ndarray[join_t]
+    right: np.ndarray,  # ndarray[join_t]
+) -> npt.NDArray[np.intp]: ...
+def left_join_indexer(
+    left: np.ndarray,  # ndarray[join_t]
+    right: np.ndarray,  # ndarray[join_t]
+) -> tuple[
+    np.ndarray,  # np.ndarray[join_t]
+    npt.NDArray[np.intp],
+    npt.NDArray[np.intp],
+]: ...
+def inner_join_indexer(
+    left: np.ndarray,  # ndarray[join_t]
+    right: np.ndarray,  # ndarray[join_t]
+) -> tuple[
+    np.ndarray,  # np.ndarray[join_t]
+    npt.NDArray[np.intp],
+    npt.NDArray[np.intp],
+]: ...
+def outer_join_indexer(
+    left: np.ndarray,  # ndarray[join_t]
+    right: np.ndarray,  # ndarray[join_t]
+) -> tuple[
+    np.ndarray,  # np.ndarray[join_t]
+    npt.NDArray[np.intp],
+    npt.NDArray[np.intp],
+]: ...
+def asof_join_backward_on_X_by_Y(
+    left_values: np.ndarray,  # ndarray[numeric_t]
+    right_values: np.ndarray,  # ndarray[numeric_t]
+    left_by_values: np.ndarray,  # const int64_t[:]
+    right_by_values: np.ndarray,  # const int64_t[:]
+    allow_exact_matches: bool = ...,
+    tolerance: np.number | float | None = ...,
+    use_hashtable: bool = ...,
+) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
+def asof_join_forward_on_X_by_Y(
+    left_values: np.ndarray,  # ndarray[numeric_t]
+    right_values: np.ndarray,  # ndarray[numeric_t]
+    left_by_values: np.ndarray,  # const int64_t[:]
+    right_by_values: np.ndarray,  # const int64_t[:]
+    allow_exact_matches: bool = ...,
+    tolerance: np.number | float | None = ...,
+    use_hashtable: bool = ...,
+) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...
+def asof_join_nearest_on_X_by_Y(
+    left_values: np.ndarray,  # ndarray[numeric_t]
+    right_values: np.ndarray,  # ndarray[numeric_t]
+    left_by_values: np.ndarray,  # const int64_t[:]
+    right_by_values: np.ndarray,  # const int64_t[:]
+    allow_exact_matches: bool = ...,
+    tolerance: np.number | float | None = ...,
+    use_hashtable: bool = ...,
+) -> tuple[npt.NDArray[np.intp], npt.NDArray[np.intp]]: ...

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/json.pyi

@@ -0,0 +1,23 @@
+from typing import (
+    Any,
+    Callable,
+)
+
+def ujson_dumps(
+    obj: Any,
+    ensure_ascii: bool = ...,
+    double_precision: int = ...,
+    indent: int = ...,
+    orient: str = ...,
+    date_unit: str = ...,
+    iso_dates: bool = ...,
+    default_handler: None
+    | Callable[[Any], str | float | bool | list | dict | None] = ...,
+) -> str: ...
+def ujson_loads(
+    s: str,
+    precise_float: bool = ...,
+    numpy: bool = ...,
+    dtype: None = ...,
+    labelled: bool = ...,
+) -> Any: ...

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/properties.pyi

@@ -0,0 +1,27 @@
+from typing import (
+    Sequence,
+    overload,
+)
+
+from pandas._typing import (
+    AnyArrayLike,
+    DataFrame,
+    Index,
+    Series,
+)
+
+# note: this is a lie to make type checkers happy (they special
+# case property). cache_readonly uses attribute names similar to
+# property (fget) but it does not provide fset and fdel.
+cache_readonly = property
+
+class AxisProperty:
+    axis: int
+    def __init__(self, axis: int = ..., doc: str = ...) -> None: ...
+    @overload
+    def __get__(self, obj: DataFrame | Series, type) -> Index: ...
+    @overload
+    def __get__(self, obj: None, type) -> AxisProperty: ...
+    def __set__(
+        self, obj: DataFrame | Series, value: AnyArrayLike | Sequence
+    ) -> None: ...

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/sas.pyi

@@ -0,0 +1,7 @@
+from pandas.io.sas.sas7bdat import SAS7BDATReader
+
+class Parser:
+    def __init__(self, parser: SAS7BDATReader) -> None: ...
+    def read(self, nrows: int) -> None: ...
+
+def get_subheader_index(signature: bytes) -> int: ...

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/sparse.pyi

@@ -0,0 +1,51 @@
+from typing import Sequence
+
+import numpy as np
+
+from pandas._typing import (
+    Self,
+    npt,
+)
+
+class SparseIndex:
+    length: int
+    npoints: int
+    def __init__(self) -> None: ...
+    @property
+    def ngaps(self) -> int: ...
+    @property
+    def nbytes(self) -> int: ...
+    @property
+    def indices(self) -> npt.NDArray[np.int32]: ...
+    def equals(self, other) -> bool: ...
+    def lookup(self, index: int) -> np.int32: ...
+    def lookup_array(self, indexer: npt.NDArray[np.int32]) -> npt.NDArray[np.int32]: ...
+    def to_int_index(self) -> IntIndex: ...
+    def to_block_index(self) -> BlockIndex: ...
+    def intersect(self, y_: SparseIndex) -> Self: ...
+    def make_union(self, y_: SparseIndex) -> Self: ...
+
+class IntIndex(SparseIndex):
+    indices: npt.NDArray[np.int32]
+    def __init__(
+        self, length: int, indices: Sequence[int], check_integrity: bool = ...
+    ) -> None: ...
+
+class BlockIndex(SparseIndex):
+    nblocks: int
+    blocs: np.ndarray
+    blengths: np.ndarray
+    def __init__(
+        self, length: int, blocs: np.ndarray, blengths: np.ndarray
+    ) -> None: ...
+
+    # Override to have correct parameters
+    def intersect(self, other: SparseIndex) -> Self: ...
+    def make_union(self, y: SparseIndex) -> Self: ...
+
+def make_mask_object_ndarray(
+    arr: npt.NDArray[np.object_], fill_value
+) -> npt.NDArray[np.bool_]: ...
+def get_blocks(
+    indices: npt.NDArray[np.int32],
+) -> tuple[npt.NDArray[np.int32], npt.NDArray[np.int32]]: ...

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/testing.pyi

@@ -0,0 +1,12 @@
+def assert_dict_equal(a, b, compare_keys: bool = ...): ...
+def assert_almost_equal(
+    a,
+    b,
+    rtol: float = ...,
+    atol: float = ...,
+    check_dtype: bool = ...,
+    obj=...,
+    lobj=...,
+    robj=...,
+    index_values=...,
+): ...

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/tslibs/__init__.py

@@ -0,0 +1,87 @@
+__all__ = [
+    "dtypes",
+    "localize_pydatetime",
+    "NaT",
+    "NaTType",
+    "iNaT",
+    "nat_strings",
+    "OutOfBoundsDatetime",
+    "OutOfBoundsTimedelta",
+    "IncompatibleFrequency",
+    "Period",
+    "Resolution",
+    "Timedelta",
+    "normalize_i8_timestamps",
+    "is_date_array_normalized",
+    "dt64arr_to_periodarr",
+    "delta_to_nanoseconds",
+    "ints_to_pydatetime",
+    "ints_to_pytimedelta",
+    "get_resolution",
+    "Timestamp",
+    "tz_convert_from_utc_single",
+    "tz_convert_from_utc",
+    "to_offset",
+    "Tick",
+    "BaseOffset",
+    "tz_compare",
+    "is_unitless",
+    "astype_overflowsafe",
+    "get_unit_from_dtype",
+    "periods_per_day",
+    "periods_per_second",
+    "guess_datetime_format",
+    "add_overflowsafe",
+    "get_supported_dtype",
+    "is_supported_dtype",
+]
+
+from pandas._libs.tslibs import dtypes  # pylint: disable=import-self
+from pandas._libs.tslibs.conversion import localize_pydatetime
+from pandas._libs.tslibs.dtypes import (
+    Resolution,
+    periods_per_day,
+    periods_per_second,
+)
+from pandas._libs.tslibs.nattype import (
+    NaT,
+    NaTType,
+    iNaT,
+    nat_strings,
+)
+from pandas._libs.tslibs.np_datetime import (
+    OutOfBoundsDatetime,
+    OutOfBoundsTimedelta,
+    add_overflowsafe,
+    astype_overflowsafe,
+    get_supported_dtype,
+    is_supported_dtype,
+    is_unitless,
+    py_get_unit_from_dtype as get_unit_from_dtype,
+)
+from pandas._libs.tslibs.offsets import (
+    BaseOffset,
+    Tick,
+    to_offset,
+)
+from pandas._libs.tslibs.parsing import guess_datetime_format
+from pandas._libs.tslibs.period import (
+    IncompatibleFrequency,
+    Period,
+)
+from pandas._libs.tslibs.timedeltas import (
+    Timedelta,
+    delta_to_nanoseconds,
+    ints_to_pytimedelta,
+)
+from pandas._libs.tslibs.timestamps import Timestamp
+from pandas._libs.tslibs.timezones import tz_compare
+from pandas._libs.tslibs.tzconversion import tz_convert_from_utc_single
+from pandas._libs.tslibs.vectorized import (
+    dt64arr_to_periodarr,
+    get_resolution,
+    ints_to_pydatetime,
+    is_date_array_normalized,
+    normalize_i8_timestamps,
+    tz_convert_from_utc,
+)

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/tslibs/ccalendar.pyi

@@ -0,0 +1,12 @@
+DAYS: list[str]
+MONTH_ALIASES: dict[int, str]
+MONTH_NUMBERS: dict[str, int]
+MONTHS: list[str]
+int_to_weekday: dict[int, str]
+
+def get_firstbday(year: int, month: int) -> int: ...
+def get_lastbday(year: int, month: int) -> int: ...
+def get_day_of_year(year: int, month: int, day: int) -> int: ...
+def get_iso_calendar(year: int, month: int, day: int) -> tuple[int, int, int]: ...
+def get_week_of_year(year: int, month: int, day: int) -> int: ...
+def get_days_in_month(year: int, month: int) -> int: ...

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/tslibs/dtypes.pyi

@@ -0,0 +1,83 @@
+from enum import Enum
+
+OFFSET_TO_PERIOD_FREQSTR: dict[str, str]
+
+def periods_per_day(reso: int = ...) -> int: ...
+def periods_per_second(reso: int) -> int: ...
+def abbrev_to_npy_unit(abbrev: str | None) -> int: ...
+def freq_to_period_freqstr(freq_n: int, freq_name: str) -> str: ...
+
+class PeriodDtypeBase:
+    _dtype_code: int  # PeriodDtypeCode
+    _n: int
+
+    # actually __cinit__
+    def __new__(cls, code: int, n: int): ...
+    @property
+    def _freq_group_code(self) -> int: ...
+    @property
+    def _resolution_obj(self) -> Resolution: ...
+    def _get_to_timestamp_base(self) -> int: ...
+    @property
+    def _freqstr(self) -> str: ...
+    def __hash__(self) -> int: ...
+    def _is_tick_like(self) -> bool: ...
+    @property
+    def _creso(self) -> int: ...
+    @property
+    def _td64_unit(self) -> str: ...
+
+class FreqGroup(Enum):
+    FR_ANN: int
+    FR_QTR: int
+    FR_MTH: int
+    FR_WK: int
+    FR_BUS: int
+    FR_DAY: int
+    FR_HR: int
+    FR_MIN: int
+    FR_SEC: int
+    FR_MS: int
+    FR_US: int
+    FR_NS: int
+    FR_UND: int
+    @staticmethod
+    def from_period_dtype_code(code: int) -> FreqGroup: ...
+
+class Resolution(Enum):
+    RESO_NS: int
+    RESO_US: int
+    RESO_MS: int
+    RESO_SEC: int
+    RESO_MIN: int
+    RESO_HR: int
+    RESO_DAY: int
+    RESO_MTH: int
+    RESO_QTR: int
+    RESO_YR: int
+    def __lt__(self, other: Resolution) -> bool: ...
+    def __ge__(self, other: Resolution) -> bool: ...
+    @property
+    def attrname(self) -> str: ...
+    @classmethod
+    def from_attrname(cls, attrname: str) -> Resolution: ...
+    @classmethod
+    def get_reso_from_freqstr(cls, freq: str) -> Resolution: ...
+    @property
+    def attr_abbrev(self) -> str: ...
+
+class NpyDatetimeUnit(Enum):
+    NPY_FR_Y: int
+    NPY_FR_M: int
+    NPY_FR_W: int
+    NPY_FR_D: int
+    NPY_FR_h: int
+    NPY_FR_m: int
+    NPY_FR_s: int
+    NPY_FR_ms: int
+    NPY_FR_us: int
+    NPY_FR_ns: int
+    NPY_FR_ps: int
+    NPY_FR_fs: int
+    NPY_FR_as: int
+    NPY_FR_GENERIC: int

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/tslibs/np_datetime.pyi

@@ -0,0 +1,27 @@
+import numpy as np
+
+from pandas._typing import npt
+
+class OutOfBoundsDatetime(ValueError): ...
+class OutOfBoundsTimedelta(ValueError): ...
+
+# only exposed for testing
+def py_get_unit_from_dtype(dtype: np.dtype): ...
+def py_td64_to_tdstruct(td64: int, unit: int) -> dict: ...
+def astype_overflowsafe(
+    values: np.ndarray,
+    dtype: np.dtype,
+    copy: bool = ...,
+    round_ok: bool = ...,
+    is_coerce: bool = ...,
+) -> np.ndarray: ...
+def is_unitless(dtype: np.dtype) -> bool: ...
+def compare_mismatched_resolutions(
+    left: np.ndarray, right: np.ndarray, op
+) -> npt.NDArray[np.bool_]: ...
+def add_overflowsafe(
+    left: npt.NDArray[np.int64],
+    right: npt.NDArray[np.int64],
+) -> npt.NDArray[np.int64]: ...
+def get_supported_dtype(dtype: np.dtype) -> np.dtype: ...
+def is_supported_dtype(dtype: np.dtype) -> bool: ...

.venv_haddock/lib/python3.12/site-packages/pandas/_libs/tslibs/offsets.pyi

@@ -0,0 +1,287 @@
+from datetime import (
+    datetime,
+    time,
+    timedelta,
+)
+from typing import (
+    Any,
+    Collection,
+    Literal,
+    TypeVar,
+    overload,
+)
+
+import numpy as np
+
+from pandas._libs.tslibs.nattype import NaTType
+from pandas._typing import (
+    OffsetCalendar,
+    Self,
+    npt,
+)
+
+from .timedeltas import Timedelta
+
+_BaseOffsetT = TypeVar("_BaseOffsetT", bound=BaseOffset)
+_DatetimeT = TypeVar("_DatetimeT", bound=datetime)
+_TimedeltaT = TypeVar("_TimedeltaT", bound=timedelta)
+
+_relativedelta_kwds: set[str]
+prefix_mapping: dict[str, type]
+
+class ApplyTypeError(TypeError): ...
+
+class BaseOffset:
+    n: int
+    normalize: bool
+    def __init__(self, n: int = ..., normalize: bool = ...) -> None: ...
+    def __eq__(self, other) -> bool: ...
+    def __ne__(self, other) -> bool: ...
+    def __hash__(self) -> int: ...
+    @property
+    def kwds(self) -> dict: ...
+    @property
+    def base(self) -> BaseOffset: ...
+    @overload
+    def __add__(self, other: npt.NDArray[np.object_]) -> npt.NDArray[np.object_]: ...
+    @overload
+    def __add__(self, other: BaseOffset) -> Self: ...
+    @overload
+    def __add__(self, other: _DatetimeT) -> _DatetimeT: ...
+    @overload
+    def __add__(self, other: _TimedeltaT) -> _TimedeltaT: ...
+    @overload
+    def __radd__(self, other: npt.NDArray[np.object_]) -> npt.NDArray[np.object_]: ...
+    @overload
+    def __radd__(self, other: BaseOffset) -> Self: ...
+    @overload
+    def __radd__(self, other: _DatetimeT) -> _DatetimeT: ...
+    @overload
+    def __radd__(self, other: _TimedeltaT) -> _TimedeltaT: ...
+    @overload
+    def __radd__(self, other: NaTType) -> NaTType: ...
+    def __sub__(self, other: BaseOffset) -> Self: ...
+    @overload
+    def __rsub__(self, other: npt.NDArray[np.object_]) -> npt.NDArray[np.object_]: ...
+    @overload
+    def __rsub__(self, other: BaseOffset): ...
+    @overload
+    def __rsub__(self, other: _DatetimeT) -> _DatetimeT: ...
+    @overload
+    def __rsub__(self, other: _TimedeltaT) -> _TimedeltaT: ...
+    @overload
+    def __mul__(self, other: np.ndarray) -> np.ndarray: ...
+    @overload
+    def __mul__(self, other: int): ...
+    @overload
+    def __rmul__(self, other: np.ndarray) -> np.ndarray: ...
+    @overload
+    def __rmul__(self, other: int) -> Self: ...
+    def __neg__(self) -> Self: ...
+    def copy(self) -> Self: ...
+    @property
+    def name(self) -> str: ...
+    @property
+    def rule_code(self) -> str: ...
+    @property
+    def freqstr(self) -> str: ...
+    def _apply(self, other): ...
+    def _apply_array(self, dtarr: np.ndarray) -> np.ndarray: ...
+    def rollback(self, dt: datetime) -> datetime: ...
+    def rollforward(self, dt: datetime) -> datetime: ...
+    def is_on_offset(self, dt: datetime) -> bool: ...
+    def __setstate__(self, state) -> None: ...
+    def __getstate__(self): ...
+    @property
+    def nanos(self) -> int: ...
+    def is_anchored(self) -> bool: ...
+
+def _get_offset(name: str) -> BaseOffset: ...
+
+class SingleConstructorOffset(BaseOffset):
+    @classmethod
+    def _from_name(cls, suffix: None = ...): ...
+    def __reduce__(self): ...
+
+@overload
+def to_offset(freq: None, is_period: bool = ...) -> None: ...
+@overload
+def to_offset(freq: _BaseOffsetT, is_period: bool = ...) -> _BaseOffsetT: ...
+@overload
+def to_offset(freq: timedelta | str, is_period: bool = ...) -> BaseOffset: ...
+
+class Tick(SingleConstructorOffset):
+    _creso: int
+    _prefix: str
+    def __init__(self, n: int = ..., normalize: bool = ...) -> None: ...
+    @property
+    def delta(self) -> Timedelta: ...
+    @property
+    def nanos(self) -> int: ...
+
+def delta_to_tick(delta: timedelta) -> Tick: ...
+
+class Day(Tick): ...
+class Hour(Tick): ...
+class Minute(Tick): ...
+class Second(Tick): ...
+class Milli(Tick): ...
+class Micro(Tick): ...
+class Nano(Tick): ...
+
+class RelativeDeltaOffset(BaseOffset):
+    def __init__(self, n: int = ..., normalize: bool = ..., **kwds: Any) -> None: ...
+
+class BusinessMixin(SingleConstructorOffset):
+    def __init__(
+        self, n: int = ..., normalize: bool = ..., offset: timedelta = ...
+    ) -> None: ...
+
+class BusinessDay(BusinessMixin): ...
+
+class BusinessHour(BusinessMixin):
+    def __init__(
+        self,
+        n: int = ...,
+        normalize: bool = ...,
+        start: str | time | Collection[str | time] = ...,
+        end: str | time | Collection[str | time] = ...,
+        offset: timedelta = ...,
+    ) -> None: ...
+
+class WeekOfMonthMixin(SingleConstructorOffset):
+    def __init__(
+        self, n: int = ..., normalize: bool = ..., weekday: int = ...
+    ) -> None: ...
+
+class YearOffset(SingleConstructorOffset):
+    def __init__(
+        self, n: int = ..., normalize: bool = ..., month: int | None = ...
+    ) -> None: ...
+
+class BYearEnd(YearOffset): ...
+class BYearBegin(YearOffset): ...
+class YearEnd(YearOffset): ...
+class YearBegin(YearOffset): ...
+
+class QuarterOffset(SingleConstructorOffset):
+    def __init__(
+        self, n: int = ..., normalize: bool = ..., startingMonth: int | None = ...
+    ) -> None: ...
+
+class BQuarterEnd(QuarterOffset): ...
+class BQuarterBegin(QuarterOffset): ...
+class QuarterEnd(QuarterOffset): ...
+class QuarterBegin(QuarterOffset): ...
+class MonthOffset(SingleConstructorOffset): ...
+class MonthEnd(MonthOffset): ...
+class MonthBegin(MonthOffset): ...
+class BusinessMonthEnd(MonthOffset): ...
+class BusinessMonthBegin(MonthOffset): ...
+
+class SemiMonthOffset(SingleConstructorOffset):
+    def __init__(
+        self, n: int = ..., normalize: bool = ..., day_of_month: int | None = ...
+    ) -> None: ...
+
+class SemiMonthEnd(SemiMonthOffset): ...
+class SemiMonthBegin(SemiMonthOffset): ...
+
+class Week(SingleConstructorOffset):
+    def __init__(
+        self, n: int = ..., normalize: bool = ..., weekday: int | None = ...
+    ) -> None: ...
+
+class WeekOfMonth(WeekOfMonthMixin):
+    def __init__(
+        self, n: int = ..., normalize: bool = ..., week: int = ..., weekday: int = ...
+    ) -> None: ...
+
+class LastWeekOfMonth(WeekOfMonthMixin): ...
+
+class FY5253Mixin(SingleConstructorOffset):
+    def __init__(
+        self,
+        n: int = ...,
+        normalize: bool = ...,
+        weekday: int = ...,
+        startingMonth: int = ...,
+        variation: Literal["nearest", "last"] = ...,
+    ) -> None: ...
+
+class FY5253(FY5253Mixin): ...
+
+class FY5253Quarter(FY5253Mixin):
+    def __init__(
+        self,
+        n: int = ...,
+        normalize: bool = ...,
+        weekday: int = ...,
+        startingMonth: int = ...,
+        qtr_with_extra_week: int = ...,
+        variation: Literal["nearest", "last"] = ...,
+    ) -> None: ...
+
+class Easter(SingleConstructorOffset): ...
+
+class _CustomBusinessMonth(BusinessMixin):
+    def __init__(
+        self,
+        n: int = ...,
+        normalize: bool = ...,
+        weekmask: str = ...,
+        holidays: list | None = ...,
+        calendar: OffsetCalendar | None = ...,
+        offset: timedelta = ...,
+    ) -> None: ...
+
+class CustomBusinessDay(BusinessDay):
+    def __init__(
+        self,
+        n: int = ...,
+        normalize: bool = ...,
+        weekmask: str = ...,
+        holidays: list | None = ...,
+        calendar: OffsetCalendar | None = ...,
+        offset: timedelta = ...,
+    ) -> None: ...
+
+class CustomBusinessHour(BusinessHour):
+    def __init__(
+        self,
+        n: int = ...,
+        normalize: bool = ...,
+        weekmask: str = ...,
+        holidays: list | None = ...,
+        calendar: OffsetCalendar | None = ...,
+        start: str | time | Collection[str | time] = ...,
+        end: str | time | Collection[str | time] = ...,
+        offset: timedelta = ...,
+    ) -> None: ...
+
+class CustomBusinessMonthEnd(_CustomBusinessMonth): ...
+class CustomBusinessMonthBegin(_CustomBusinessMonth): ...
+class OffsetMeta(type): ...
+class DateOffset(RelativeDeltaOffset, metaclass=OffsetMeta): ...
+
+BDay = BusinessDay
+BMonthEnd = BusinessMonthEnd
+BMonthBegin = BusinessMonthBegin
+CBMonthEnd = CustomBusinessMonthEnd
+CBMonthBegin = CustomBusinessMonthBegin
+CDay = CustomBusinessDay
+
+def roll_qtrday(
+    other: datetime, n: int, month: int, day_opt: str, modby: int
+) -> int: ...
+
+INVALID_FREQ_ERR_MSG: Literal["Invalid frequency: {0}"]
+
+def shift_months(
+    dtindex: npt.NDArray[np.int64],
+    months: int,
+    day_opt: str | None = ...,
+    reso: int = ...,
+) -> npt.NDArray[np.int64]: ...
+
+_offset_map: dict[str, BaseOffset]