Add files using upload-large-folder tool

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

@@ -0,0 +1,626 @@
+# Copyright 1999 by Jeffrey Chang.  All rights reserved.
+# Copyright 2009-2018 by Peter Cock. All rights reserved.
+#
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+"""Code for more fancy file handles.
+
+Bio.File defines private classes used in Bio.SeqIO and Bio.SearchIO for
+indexing files. These are not intended for direct use.
+"""
+
+import collections.abc
+import contextlib
+import itertools
+import os
+from abc import ABC
+from abc import abstractmethod
+
+try:
+    import sqlite3
+except ImportError:
+    # May be missing if Python was compiled from source without its dependencies
+    sqlite3 = None  # type: ignore
+
+
+@contextlib.contextmanager
+def as_handle(handleish, mode="r", **kwargs):
+    r"""Context manager to ensure we are using a handle.
+
+    Context manager for arguments that can be passed to SeqIO and AlignIO read, write,
+    and parse methods: either file objects or path-like objects (strings, pathlib.Path
+    instances, or more generally, anything that can be handled by the builtin 'open'
+    function).
+
+    When given a path-like object, returns an open file handle to that path, with provided
+    mode, which will be closed when the manager exits.
+
+    All other inputs are returned, and are *not* closed.
+
+    Arguments:
+     - handleish  - Either a file handle or path-like object (anything which can be
+                    passed to the builtin 'open' function, such as str, bytes,
+                    pathlib.Path, and os.DirEntry objects)
+     - mode       - Mode to open handleish (used only if handleish is a string)
+     - kwargs     - Further arguments to pass to open(...)
+
+    Examples
+    --------
+    >>> from Bio import File
+    >>> import os
+    >>> with File.as_handle('seqs.fasta', 'w') as fp:
+    ...     fp.write('>test\nACGT')
+    ...
+    10
+    >>> fp.closed
+    True
+
+    >>> handle = open('seqs.fasta', 'w')
+    >>> with File.as_handle(handle) as fp:
+    ...     fp.write('>test\nACGT')
+    ...
+    10
+    >>> fp.closed
+    False
+    >>> fp.close()
+    >>> os.remove("seqs.fasta")  # tidy up
+
+    """
+    try:
+        with open(handleish, mode, **kwargs) as fp:
+            yield fp
+    except TypeError:
+        yield handleish
+
+
+def _open_for_random_access(filename):
+    """Open a file in binary mode, spot if it is BGZF format etc (PRIVATE).
+
+    This functionality is used by the Bio.SeqIO and Bio.SearchIO index
+    and index_db functions.
+
+    If the file is gzipped but not BGZF, a specific ValueError is raised.
+    """
+    handle = open(filename, "rb")
+    magic = handle.read(2)
+    handle.seek(0)
+
+    if magic == b"\x1f\x8b":
+        # This is a gzipped file, but is it BGZF?
+        from . import bgzf
+
+        try:
+            # If it is BGZF, we support that
+            return bgzf.BgzfReader(mode="rb", fileobj=handle)
+        except ValueError as e:
+            assert "BGZF" in str(e)
+            # Not a BGZF file after all,
+            handle.close()
+            raise ValueError(
+                "Gzipped files are not suitable for indexing, "
+                "please use BGZF (blocked gzip format) instead."
+            ) from None
+
+    return handle
+
+
+# The rest of this file defines code used in Bio.SeqIO and Bio.SearchIO
+# for indexing
+
+
+class _IndexedSeqFileProxy(ABC):
+    """Abstract base class for file format specific random access (PRIVATE).
+
+    This is subclasses in both Bio.SeqIO for indexing as SeqRecord
+    objects, and in Bio.SearchIO for indexing QueryResult objects.
+
+    Subclasses for each file format should define '__iter__', 'get'
+    and optionally 'get_raw' methods.
+    """
+
+    @abstractmethod
+    def __iter__(self):
+        """Return (identifier, offset, length in bytes) tuples.
+
+        The length can be zero where it is not implemented or not
+        possible for a particular file format.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def get(self, offset):
+        """Return parsed object for this entry."""
+        # Most file formats with self contained records can be handled by
+        # parsing StringIO(self.get_raw(offset).decode())
+        raise NotImplementedError
+
+    def get_raw(self, offset):
+        """Return the raw record from the file as a bytes string (if implemented).
+
+        If the key is not found, a KeyError exception is raised.
+
+        This may not have been implemented for all file formats.
+        """
+        # Should be done by each sub-class (if possible)
+        raise NotImplementedError("Not available for this file format.")
+
+
+class _IndexedSeqFileDict(collections.abc.Mapping):
+    """Read only dictionary interface to a sequential record file.
+
+    This code is used in both Bio.SeqIO for indexing as SeqRecord
+    objects, and in Bio.SearchIO for indexing QueryResult objects.
+
+    Keeps the keys and associated file offsets in memory, reads the file
+    to access entries as objects parsing them on demand. This approach
+    is memory limited, but will work even with millions of records.
+
+    Note duplicate keys are not allowed. If this happens, a ValueError
+    exception is raised.
+
+    As used in Bio.SeqIO, by default the SeqRecord's id string is used
+    as the dictionary key. In Bio.SearchIO, the query's id string is
+    used. This can be changed by supplying an optional key_function,
+    a callback function which will be given the record id and must
+    return the desired key. For example, this allows you to parse
+    NCBI style FASTA identifiers, and extract the GI number to use
+    as the dictionary key.
+
+    Note that this dictionary is essentially read only. You cannot
+    add or change values, pop values, nor clear the dictionary.
+    """
+
+    def __init__(self, random_access_proxy, key_function, repr, obj_repr):
+        """Initialize the class."""
+        # Use key_function=None for default value
+        self._proxy = random_access_proxy
+        self._key_function = key_function
+        self._repr = repr
+        self._obj_repr = obj_repr
+        self._cached_prev_record = (None, None)  # (key, record)
+        if key_function:
+            offset_iter = (
+                (key_function(key), offset, length)
+                for (key, offset, length) in random_access_proxy
+            )
+        else:
+            offset_iter = random_access_proxy
+        offsets = {}
+        for key, offset, length in offset_iter:
+            # Note - we don't store the length because I want to minimise the
+            # memory requirements. With the SQLite backend the length is kept
+            # and is used to speed up the get_raw method (by about 3 times).
+            # The length should be provided by all the current backends except
+            # SFF where there is an existing Roche index we can reuse (very fast
+            # but lacks the record lengths)
+            # assert length or format in ["sff", "sff-trim"], \
+            #       "%s at offset %i given length %r (%s format %s)" \
+            #       % (key, offset, length, filename, format)
+            if key in offsets:
+                self._proxy._handle.close()
+                raise ValueError(f"Duplicate key '{key}'")
+            else:
+                offsets[key] = offset
+        self._offsets = offsets
+
+    def __repr__(self):
+        """Return a string representation of the File object."""
+        return self._repr
+
+    def __str__(self):
+        """Create a string representation of the File object."""
+        # TODO - How best to handle the __str__ for SeqIO and SearchIO?
+        if self:
+            return f"{{{list(self.keys())[0]!r} : {self._obj_repr}(...), ...}}"
+        else:
+            return "{}"
+
+    def __len__(self):
+        """Return the number of records."""
+        return len(self._offsets)
+
+    def __iter__(self):
+        """Iterate over the keys."""
+        return iter(self._offsets)
+
+    def __getitem__(self, key):
+        """Return record for the specified key.
+
+        As an optimization when repeatedly asked to look up the same record,
+        the key and record are cached so that if the *same* record is
+        requested next time, it can be returned without going to disk.
+        """
+        if key == self._cached_prev_record[0]:
+            return self._cached_prev_record[1]
+        # Pass the offset to the proxy
+        record = self._proxy.get(self._offsets[key])
+        if self._key_function:
+            key2 = self._key_function(record.id)
+        else:
+            key2 = record.id
+        if key != key2:
+            raise ValueError(f"Key did not match ({key} vs {key2})")
+        self._cached_prev_record = (key, record)
+        return record
+
+    def get_raw(self, key):
+        """Return the raw record from the file as a bytes string.
+
+        If the key is not found, a KeyError exception is raised.
+        """
+        # Pass the offset to the proxy
+        return self._proxy.get_raw(self._offsets[key])
+
+    def close(self):
+        """Close the file handle being used to read the data.
+
+        Once called, further use of the index won't work. The sole purpose
+        of this method is to allow explicit handle closure - for example
+        if you wish to delete the file, on Windows you must first close
+        all open handles to that file.
+        """
+        self._proxy._handle.close()
+
+
+class _SQLiteManySeqFilesDict(_IndexedSeqFileDict):
+    """Read only dictionary interface to many sequential record files.
+
+    This code is used in both Bio.SeqIO for indexing as SeqRecord
+    objects, and in Bio.SearchIO for indexing QueryResult objects.
+
+    Keeps the keys, file-numbers and offsets in an SQLite database. To access
+    a record by key, reads from the offset in the appropriate file and then
+    parses the record into an object.
+
+    There are OS limits on the number of files that can be open at once,
+    so a pool are kept. If a record is required from a closed file, then
+    one of the open handles is closed first.
+    """
+
+    def __init__(
+        self,
+        index_filename,
+        filenames,
+        proxy_factory,
+        fmt,
+        key_function,
+        repr,
+        max_open=10,
+    ):
+        """Initialize the class."""
+        # TODO? - Don't keep filename list in memory (just in DB)?
+        # Should save a chunk of memory if dealing with 1000s of files.
+        # Furthermore could compare a generator to the DB on reloading
+        # (no need to turn it into a list)
+
+        if sqlite3 is None:
+            # Python was compiled without sqlite3 support
+            from Bio import MissingPythonDependencyError
+
+            raise MissingPythonDependencyError(
+                "Python was compiled without the sqlite3 module"
+            )
+        if filenames is not None:
+            filenames = list(filenames)  # In case it was a generator
+
+        # Cache the arguments as private variables
+        self._index_filename = index_filename
+        self._filenames = filenames
+        self._format = fmt
+        self._key_function = key_function
+        self._proxy_factory = proxy_factory
+        self._repr = repr
+        self._max_open = max_open
+        self._proxies = {}
+
+        # Note if using SQLite :memory: trick index filename, this will
+        # give $PWD as the relative path (which is fine).
+        self._relative_path = os.path.abspath(os.path.dirname(index_filename))
+
+        if os.path.isfile(index_filename):
+            self._load_index()
+        else:
+            self._build_index()
+
+    def _load_index(self):
+        """Call from __init__ to reuse an existing index (PRIVATE)."""
+        index_filename = self._index_filename
+        relative_path = self._relative_path
+        filenames = self._filenames
+        fmt = self._format
+        proxy_factory = self._proxy_factory
+
+        con = sqlite3.dbapi2.connect(index_filename, check_same_thread=False)
+        self._con = con
+        # Check the count...
+        try:
+            (count,) = con.execute(
+                "SELECT value FROM meta_data WHERE key=?;", ("count",)
+            ).fetchone()
+            self._length = int(count)
+            if self._length == -1:
+                con.close()
+                raise ValueError("Unfinished/partial database") from None
+
+            # use MAX(_ROWID_) to obtain the number of sequences in the database
+            # using COUNT(key) is quite slow in SQLITE
+            # (https://stackoverflow.com/questions/8988915/sqlite-count-slow-on-big-tables)
+            (count,) = con.execute("SELECT MAX(_ROWID_) FROM offset_data;").fetchone()
+            if self._length != int(count):
+                con.close()
+                raise ValueError(
+                    "Corrupt database? %i entries not %i" % (int(count), self._length)
+                ) from None
+            (self._format,) = con.execute(
+                "SELECT value FROM meta_data WHERE key=?;", ("format",)
+            ).fetchone()
+            if fmt and fmt != self._format:
+                con.close()
+                raise ValueError(
+                    f"Index file says format {self._format}, not {fmt}"
+                ) from None
+            try:
+                (filenames_relative_to_index,) = con.execute(
+                    "SELECT value FROM meta_data WHERE key=?;",
+                    ("filenames_relative_to_index",),
+                ).fetchone()
+                filenames_relative_to_index = (
+                    filenames_relative_to_index.upper() == "TRUE"
+                )
+            except TypeError:
+                # Original behaviour, assume if meta_data missing
+                filenames_relative_to_index = False
+            self._filenames = [
+                row[0]
+                for row in con.execute(
+                    "SELECT name FROM file_data ORDER BY file_number;"
+                ).fetchall()
+            ]
+            if filenames_relative_to_index:
+                # Not implicitly relative to $PWD, explicitly relative to index file
+                relative_path = os.path.abspath(os.path.dirname(index_filename))
+                tmp = []
+                for f in self._filenames:
+                    if os.path.isabs(f):
+                        tmp.append(f)
+                    else:
+                        # Would be stored with Unix / path separator, so convert
+                        # it to the local OS path separator here:
+                        tmp.append(
+                            os.path.join(relative_path, f.replace("/", os.path.sep))
+                        )
+                self._filenames = tmp
+                del tmp
+            if filenames and len(filenames) != len(self._filenames):
+                con.close()
+                raise ValueError(
+                    "Index file says %i files, not %i"
+                    % (len(self._filenames), len(filenames))
+                ) from None
+            if filenames and filenames != self._filenames:
+                for old, new in zip(self._filenames, filenames):
+                    # Want exact match (after making relative to the index above)
+                    if os.path.abspath(old) != os.path.abspath(new):
+                        con.close()
+                        if filenames_relative_to_index:
+                            raise ValueError(
+                                "Index file has different filenames, e.g. %r != %r"
+                                % (os.path.abspath(old), os.path.abspath(new))
+                            ) from None
+                        else:
+                            raise ValueError(
+                                "Index file has different filenames "
+                                "[This is an old index where any relative paths "
+                                "were relative to the original working directory]. "
+                                "e.g. %r != %r"
+                                % (os.path.abspath(old), os.path.abspath(new))
+                            ) from None
+                # Filenames are equal (after imposing abspath)
+        except sqlite3.OperationalError as err:
+            con.close()
+            raise ValueError(f"Not a Biopython index database? {err}") from None
+        # Now we have the format (from the DB if not given to us),
+        if not proxy_factory(self._format):
+            con.close()
+            raise ValueError(f"Unsupported format '{self._format}'")
+
+    def _build_index(self):
+        """Call from __init__ to create a new index (PRIVATE)."""
+        index_filename = self._index_filename
+        relative_path = self._relative_path
+        filenames = self._filenames
+        fmt = self._format
+        key_function = self._key_function
+        proxy_factory = self._proxy_factory
+        max_open = self._max_open
+        random_access_proxies = self._proxies
+
+        if not fmt or not filenames:
+            raise ValueError(
+                f"Filenames to index and format required to build {index_filename!r}"
+            )
+        if not proxy_factory(fmt):
+            raise ValueError(f"Unsupported format '{fmt}'")
+        # Create the index
+        con = sqlite3.dbapi2.connect(index_filename)
+        self._con = con
+        # print("Creating index")
+        # Sqlite PRAGMA settings for speed
+        con.execute("PRAGMA synchronous=OFF")
+        con.execute("PRAGMA locking_mode=EXCLUSIVE")
+        # Don't index the key column until the end (faster)
+        # con.execute("CREATE TABLE offset_data (key TEXT PRIMARY KEY, "
+        #             "offset INTEGER);")
+        con.execute("CREATE TABLE meta_data (key TEXT, value TEXT);")
+        con.execute("INSERT INTO meta_data (key, value) VALUES (?,?);", ("count", -1))
+        con.execute("INSERT INTO meta_data (key, value) VALUES (?,?);", ("format", fmt))
+        con.execute(
+            "INSERT INTO meta_data (key, value) VALUES (?,?);",
+            ("filenames_relative_to_index", "True"),
+        )
+        # TODO - Record the file size and modified date?
+        con.execute("CREATE TABLE file_data (file_number INTEGER, name TEXT);")
+        con.execute(
+            "CREATE TABLE offset_data (key TEXT, "
+            "file_number INTEGER, offset INTEGER, length INTEGER);"
+        )
+        count = 0
+        for file_index, filename in enumerate(filenames):
+            # Default to storing as an absolute path,
+            f = os.path.abspath(filename)
+            if not os.path.isabs(filename) and not os.path.isabs(index_filename):
+                # Since user gave BOTH filename & index as relative paths,
+                # we will store this relative to the index file even though
+                # if it may now start ../ (meaning up a level)
+                # Note for cross platform use (e.g. shared drive over SAMBA),
+                # convert any Windows slash into Unix style for rel paths.
+                f = os.path.relpath(filename, relative_path).replace(os.path.sep, "/")
+            elif (os.path.dirname(os.path.abspath(filename)) + os.path.sep).startswith(
+                relative_path + os.path.sep
+            ):
+                # Since sequence file is in same directory or sub directory,
+                # might as well make this into a relative path:
+                f = os.path.relpath(filename, relative_path).replace(os.path.sep, "/")
+                assert not f.startswith("../"), f
+            # print("DEBUG - storing %r as [%r] %r" % (filename, relative_path, f))
+            con.execute(
+                "INSERT INTO file_data (file_number, name) VALUES (?,?);",
+                (file_index, f),
+            )
+            random_access_proxy = proxy_factory(fmt, filename)
+            if key_function:
+                offset_iter = (
+                    (key_function(key), file_index, offset, length)
+                    for (key, offset, length) in random_access_proxy
+                )
+            else:
+                offset_iter = (
+                    (key, file_index, offset, length)
+                    for (key, offset, length) in random_access_proxy
+                )
+            while True:
+                batch = list(itertools.islice(offset_iter, 100))
+                if not batch:
+                    break
+                # print("Inserting batch of %i offsets, %s ... %s"
+                #       % (len(batch), batch[0][0], batch[-1][0]))
+                con.executemany(
+                    "INSERT INTO offset_data (key,file_number,offset,length) VALUES (?,?,?,?);",
+                    batch,
+                )
+                con.commit()
+                count += len(batch)
+            if len(random_access_proxies) < max_open:
+                random_access_proxies[file_index] = random_access_proxy
+            else:
+                random_access_proxy._handle.close()
+        self._length = count
+        # print("About to index %i entries" % count)
+        try:
+            con.execute(
+                "CREATE UNIQUE INDEX IF NOT EXISTS key_index ON offset_data(key);"
+            )
+        except sqlite3.IntegrityError as err:
+            self._proxies = random_access_proxies
+            self.close()
+            con.close()
+            raise ValueError(f"Duplicate key? {err}") from None
+        con.execute("PRAGMA locking_mode=NORMAL")
+        con.execute("UPDATE meta_data SET value = ? WHERE key = ?;", (count, "count"))
+        con.commit()
+        # print("Index created")
+
+    def __repr__(self):
+        return self._repr
+
+    def __contains__(self, key):
+        return bool(
+            self._con.execute(
+                "SELECT key FROM offset_data WHERE key=?;", (key,)
+            ).fetchone()
+        )
+
+    def __len__(self):
+        """Return the number of records indexed."""
+        return self._length
+        # return self._con.execute("SELECT COUNT(key) FROM offset_data;").fetchone()[0]
+
+    def __iter__(self):
+        """Iterate over the keys."""
+        for row in self._con.execute(
+            "SELECT key FROM offset_data ORDER BY file_number, offset;"
+        ):
+            yield str(row[0])
+
+    def __getitem__(self, key):
+        """Return record for the specified key."""
+        # Pass the offset to the proxy
+        row = self._con.execute(
+            "SELECT file_number, offset FROM offset_data WHERE key=?;", (key,)
+        ).fetchone()
+        if not row:
+            raise KeyError
+        file_number, offset = row
+        proxies = self._proxies
+        if file_number in proxies:
+            record = proxies[file_number].get(offset)
+        else:
+            if len(proxies) >= self._max_open:
+                # Close an old handle...
+                proxies.popitem()[1]._handle.close()
+            # Open a new handle...
+            proxy = self._proxy_factory(self._format, self._filenames[file_number])
+            record = proxy.get(offset)
+            proxies[file_number] = proxy
+        if self._key_function:
+            key2 = self._key_function(record.id)
+        else:
+            key2 = record.id
+        if key != key2:
+            raise ValueError(f"Key did not match ({key} vs {key2})")
+        return record
+
+    def get_raw(self, key):
+        """Return the raw record from the file as a bytes string.
+
+        If the key is not found, a KeyError exception is raised.
+        """
+        # Pass the offset to the proxy
+        row = self._con.execute(
+            "SELECT file_number, offset, length FROM offset_data WHERE key=?;", (key,)
+        ).fetchone()
+        if not row:
+            raise KeyError
+        file_number, offset, length = row
+        proxies = self._proxies
+        if file_number in proxies:
+            if length:
+                # Shortcut if we have the length
+                h = proxies[file_number]._handle
+                h.seek(offset)
+                return h.read(length)
+            else:
+                return proxies[file_number].get_raw(offset)
+        else:
+            # This code is duplicated from __getitem__ to avoid a function call
+            if len(proxies) >= self._max_open:
+                # Close an old handle...
+                proxies.popitem()[1]._handle.close()
+            # Open a new handle...
+            proxy = self._proxy_factory(self._format, self._filenames[file_number])
+            proxies[file_number] = proxy
+            if length:
+                # Shortcut if we have the length
+                h = proxy._handle
+                h.seek(offset)
+                return h.read(length)
+            else:
+                return proxy.get_raw(offset)
+
+    def close(self):
+        """Close any open file handles."""
+        proxies = self._proxies
+        while proxies:
+            proxies.popitem()[1]._handle.close()

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

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

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

@@ -0,0 +1,1541 @@
+# Copyright 2000-2002 Andrew Dalke.  All rights reserved.
+# Copyright 2002-2004 Brad Chapman.  All rights reserved.
+# Copyright 2006-2023 by Peter Cock.  All rights reserved.
+# Copyright 2020 by Michael R. Crusoe
+#
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+"""Represent a Sequence Record, a sequence with annotation."""
+
+# NEEDS TO BE SYNCH WITH THE REST OF BIOPYTHON AND BIOPERL
+# In particular, the SeqRecord and BioSQL.BioSeq.DBSeqRecord classes
+# need to be in sync (this is the BioSQL "Database SeqRecord").
+import numbers
+from typing import Any
+from typing import cast
+from collections.abc import Iterator
+from typing import NoReturn
+from typing import Optional
+from typing import overload
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
+from typing import Union
+
+from Bio import StreamModeError
+from Bio.Seq import MutableSeq
+from Bio.Seq import Seq
+from Bio.Seq import UndefinedSequenceError
+
+if TYPE_CHECKING:
+    from Bio.SeqFeature import SeqFeature
+
+_NO_SEQRECORD_COMPARISON = "SeqRecord comparison is deliberately not implemented. Explicitly compare the attributes of interest."
+
+
+class _RestrictedDict(dict[str, Sequence[Any]]):
+    """Dict which only allows sequences of given length as values (PRIVATE).
+
+    This simple subclass of the Python dictionary is used in the SeqRecord
+    object for holding per-letter-annotations.  This class is intended to
+    prevent simple errors by only allowing python sequences (e.g. lists,
+    strings and tuples) to be stored, and only if their length matches that
+    expected (the length of the SeqRecord's seq object).  It cannot however
+    prevent the entries being edited in situ (for example appending entries
+    to a list).
+
+    >>> x = _RestrictedDict(5)
+    >>> x["test"] = "hello"
+    >>> x
+    {'test': 'hello'}
+
+    Adding entries which don't have the expected length are blocked:
+
+    >>> x["test"] = "hello world"
+    Traceback (most recent call last):
+    ...
+    TypeError: Any per-letter annotation should be a Python sequence (list, tuple or string) of the same length as the biological sequence, here 5.
+
+    The expected length is stored as a private attribute,
+
+    >>> x._length
+    5
+
+    In order that the SeqRecord (and other objects using this class) can be
+    pickled, for example for use in the multiprocessing library, we need to
+    be able to pickle the restricted dictionary objects.
+
+    Using the default protocol, which is 3 on Python 3,
+
+    >>> import pickle
+    >>> y = pickle.loads(pickle.dumps(x))
+    >>> y
+    {'test': 'hello'}
+    >>> y._length
+    5
+
+    Using the highest protocol, which is 4 on Python 3,
+
+    >>> import pickle
+    >>> z = pickle.loads(pickle.dumps(x, pickle.HIGHEST_PROTOCOL))
+    >>> z
+    {'test': 'hello'}
+    >>> z._length
+    5
+    """
+
+    def __init__(self, length: int) -> None:
+        """Create an EMPTY restricted dictionary."""
+        dict.__init__(self)
+        self._length = int(length)
+
+    def __setitem__(self, key: str, value: Sequence[Any]) -> None:
+        # The check hasattr(self, "_length") is to cope with pickle protocol 2
+        # I couldn't seem to avoid this with __getstate__ and __setstate__
+        if (
+            not hasattr(value, "__len__")
+            or not hasattr(value, "__getitem__")
+            or (hasattr(self, "_length") and len(value) != self._length)
+        ):
+            raise TypeError(
+                "Any per-letter annotation should be a Python sequence "
+                "(list, tuple or string) of the same length as the "
+                f"biological sequence, here {self._length}."
+            )
+        dict.__setitem__(self, key, value)
+
+    def update(self, new_dict):
+        # Force this to go via our strict __setitem__ method
+        for key, value in new_dict.items():
+            self[key] = value
+
+
+class SeqRecord:
+    """A SeqRecord object holds a sequence and information about it.
+
+    Main attributes:
+     - id          - Identifier such as a locus tag (string)
+     - seq         - The sequence itself (Seq object or similar)
+
+    Additional attributes:
+     - name        - Sequence name, e.g. gene name (string)
+     - description - Additional text (string)
+     - dbxrefs     - List of database cross references (list of strings)
+     - features    - Any (sub)features defined (list of SeqFeature objects)
+     - annotations - Further information about the whole sequence (dictionary).
+       Most entries are strings, or lists of strings.
+     - letter_annotations - Per letter/symbol annotation (restricted
+       dictionary). This holds Python sequences (lists, strings
+       or tuples) whose length matches that of the sequence.
+       A typical use would be to hold a list of integers
+       representing sequencing quality scores, or a string
+       representing the secondary structure.
+
+    You will typically use Bio.SeqIO to read in sequences from files as
+    SeqRecord objects.  However, you may want to create your own SeqRecord
+    objects directly (see the __init__ method for further details):
+
+    >>> from Bio.Seq import Seq
+    >>> from Bio.SeqRecord import SeqRecord
+    >>> record = SeqRecord(Seq("MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF"),
+    ...                    id="YP_025292.1", name="HokC",
+    ...                    description="toxic membrane protein")
+    >>> print(record)
+    ID: YP_025292.1
+    Name: HokC
+    Description: toxic membrane protein
+    Number of features: 0
+    Seq('MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF')
+
+    If you want to save SeqRecord objects to a sequence file, use Bio.SeqIO
+    for this.  For the special case where you want the SeqRecord turned into
+    a string in a particular file format there is a format method which uses
+    Bio.SeqIO internally:
+
+    >>> print(record.format("fasta"))
+    >YP_025292.1 toxic membrane protein
+    MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF
+    <BLANKLINE>
+
+    You can also do things like slicing a SeqRecord, checking its length, etc
+
+    >>> len(record)
+    44
+    >>> edited = record[:10] + record[11:]
+    >>> print(edited.seq)
+    MKQHKAMIVAIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF
+    >>> print(record.seq)
+    MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF
+
+    """
+
+    _AnnotationsDictValue = str | int
+    _AnnotationsDict = dict[str, _AnnotationsDictValue]
+
+    annotations: _AnnotationsDict
+    dbxrefs: list[str]
+    _per_letter_annotations: _RestrictedDict | None
+
+    def __init__(
+        self,
+        seq: Union["Seq", "MutableSeq"] | None,
+        id: str | None = "<unknown id>",
+        name: str = "<unknown name>",
+        description: str = "<unknown description>",
+        dbxrefs: list[str] | None = None,
+        features: list["SeqFeature"] | None = None,
+        annotations: _AnnotationsDict | None = None,
+        letter_annotations: dict[str, Sequence[Any]] | None = None,
+    ) -> None:
+        """Create a SeqRecord.
+
+        Arguments:
+         - seq         - Sequence, required (Seq or MutableSeq)
+         - id          - Sequence identifier, recommended (string)
+         - name        - Sequence name, optional (string)
+         - description - Sequence description, optional (string)
+         - dbxrefs     - Database cross references, optional (list of strings)
+         - features    - Any (sub)features, optional (list of SeqFeature objects)
+         - annotations - Dictionary of annotations for the whole sequence
+         - letter_annotations - Dictionary of per-letter-annotations, values
+           should be strings, list or tuples of the same length as the full
+           sequence.
+
+        You will typically use Bio.SeqIO to read in sequences from files as
+        SeqRecord objects.  However, you may want to create your own SeqRecord
+        objects directly.
+
+        Note that while an id is optional, we strongly recommend you supply a
+        unique id string for each record.  This is especially important
+        if you wish to write your sequences to a file.
+
+        You can create a 'blank' SeqRecord object, and then populate the
+        attributes later.
+        """
+        if seq is not None and not isinstance(seq, (Seq, MutableSeq)):
+            raise TypeError("seq argument should be a Seq or MutableSeq object")
+        if id is not None and not isinstance(id, str):
+            # Lots of existing code uses id=None... this may be a bad idea.
+            raise TypeError("id argument should be a string")
+        if not isinstance(name, str):
+            raise TypeError("name argument should be a string")
+        if not isinstance(description, str):
+            raise TypeError("description argument should be a string")
+
+        self._seq = seq
+        self.id = id
+        self.name = name
+        self.description = description
+
+        # database cross references (for the whole sequence)
+        if dbxrefs is None:
+            dbxrefs = []
+        elif not isinstance(dbxrefs, list):
+            raise TypeError("dbxrefs argument should be a list (of strings)")
+        self.dbxrefs = dbxrefs
+
+        # annotations about the whole sequence
+        if annotations is None:
+            annotations = {}
+        elif not isinstance(annotations, dict):
+            raise TypeError("annotations argument must be a dict or None")
+        self.annotations = annotations
+
+        self._per_letter_annotations = None
+        if letter_annotations is not None:
+            # This will be handled via the property set function, which will
+            # turn this into a _RestrictedDict and thus ensure all the values
+            # in the dict are the right length
+            self.letter_annotations = letter_annotations
+
+        # annotations about parts of the sequence
+        if features is None:
+            features = []
+        elif not isinstance(features, list):
+            raise TypeError(
+                "features argument should be a list (of SeqFeature objects)"
+            )
+        self.features = features
+
+    @property
+    def letter_annotations(self) -> dict[str, Sequence[Any]]:
+        """Dictionary of per-letter-annotation for the sequence.
+
+        For example, this can hold quality scores used in FASTQ or QUAL files.
+        Consider this example using Bio.SeqIO to read in an example Solexa
+        variant FASTQ file as a SeqRecord:
+
+        >>> from Bio import SeqIO
+        >>> record = SeqIO.read("Quality/solexa_faked.fastq", "fastq-solexa")
+        >>> print("%s %s" % (record.id, record.seq))
+        slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
+        >>> print(list(record.letter_annotations))
+        ['solexa_quality']
+        >>> print(record.letter_annotations["solexa_quality"])
+        [40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5]
+
+        The letter_annotations get sliced automatically if you slice the
+        parent SeqRecord, for example taking the last ten bases:
+
+        >>> sub_record = record[-10:]
+        >>> print("%s %s" % (sub_record.id, sub_record.seq))
+        slxa_0001_1_0001_01 ACGTNNNNNN
+        >>> print(sub_record.letter_annotations["solexa_quality"])
+        [4, 3, 2, 1, 0, -1, -2, -3, -4, -5]
+
+        Any python sequence (i.e. list, tuple or string) can be recorded in
+        the SeqRecord's letter_annotations dictionary as long as the length
+        matches that of the SeqRecord's sequence.  e.g.
+
+        >>> len(sub_record.letter_annotations)
+        1
+        >>> sub_record.letter_annotations["dummy"] = "abcdefghij"
+        >>> len(sub_record.letter_annotations)
+        2
+
+        You can delete entries from the letter_annotations dictionary as usual:
+
+        >>> del sub_record.letter_annotations["solexa_quality"]
+        >>> sub_record.letter_annotations
+        {'dummy': 'abcdefghij'}
+
+        You can completely clear the dictionary easily as follows:
+
+        >>> sub_record.letter_annotations = {}
+        >>> sub_record.letter_annotations
+        {}
+
+        Note that if replacing the record's sequence with a sequence of a
+        different length you must first clear the letter_annotations dict.
+        """
+        if self._per_letter_annotations is None:
+            length = 0 if self.seq is None else len(self.seq)
+            self._per_letter_annotations = _RestrictedDict(length=length)
+        return self._per_letter_annotations
+
+    # TODO - Just make this a read only property?
+    @letter_annotations.setter
+    def letter_annotations(self, value: dict[str, Sequence[Any]]) -> None:
+        if not isinstance(value, dict):
+            raise TypeError(
+                "The per-letter-annotations should be a (restricted) dictionary."
+            )
+        # Turn this into a restricted-dictionary (and check the entries)
+        length = 0 if self.seq is None else len(self.seq)
+        if any(len(val) != length for val in value.values()):
+            raise ValueError(
+                f"The per-letter-annotations have the same length as the sequence, but found: \n {','.join([f'{key}={val}' for key, val in value.items() if len(val) != length])}"
+            )
+        if self._per_letter_annotations is None:
+            self._per_letter_annotations = _RestrictedDict(length=length)
+        else:
+            self._per_letter_annotations.clear()
+        dict.update(self._per_letter_annotations, value)  # type: ignore
+
+    @property
+    def seq(self) -> Union["Seq", "MutableSeq"] | None:
+        """The sequence itself, as a Seq or MutableSeq object."""
+        return self._seq
+
+    @seq.setter
+    def seq(self, value: Union["Seq", "MutableSeq"]) -> None:
+        # Adding this here for users who are not type-checking their code.
+        if value is not None and not isinstance(value, (Seq, MutableSeq)):
+            raise TypeError("seq must be a Seq or MutableSeq object")
+        # TODO - Add a deprecation warning that the seq should be write only?
+        if self._per_letter_annotations:
+            if len(self) != len(value):
+                # TODO - Make this a warning? Silently empty the dictionary?
+                raise ValueError("You must empty the letter annotations first!")
+            else:
+                # Leave the existing per letter annotations unchanged:
+                self._seq = value
+        else:
+            self._seq = value
+            # Reset the (empty) letter annotations dict with new length:
+            length = 0 if self.seq is None else len(self.seq)
+            self._per_letter_annotations = _RestrictedDict(length=length)
+
+    @classmethod
+    def _from_validated(
+        cls,
+        seq: Seq | MutableSeq | None,
+        id: str | None = "<unknown id>",
+        name: str = "<unknown name>",
+        description: str = "<unknown description>",
+        dbxrefs: list[str] | None = None,
+        features: list["SeqFeature"] | None = None,
+        annotations: dict[str, str | int] | None = None,
+        letter_annotations: dict[str, Sequence] | None = None,
+    ) -> "SeqRecord":
+        """Faster constructor for post-validated data like copies or validated parsed data"""
+
+        if cls is not SeqRecord:
+            # If we subclassed, we'll default to that class's initializer just to be careful
+            return cls(
+                seq,
+                id,
+                name,
+                description,
+                dbxrefs,
+                features,
+                annotations,
+                letter_annotations,
+            )
+
+        inst = cls.__new__(cls)
+
+        inst._seq = seq
+        inst.id = id
+        inst.name = name
+        inst.description = description
+        if dbxrefs is None:
+            dbxrefs = []
+        inst.dbxrefs = dbxrefs
+        if features is None:
+            features = []
+        inst.features = features
+        if annotations is None:
+            annotations = {}
+        inst.annotations = annotations
+
+        inst._per_letter_annotations = None
+        if letter_annotations is not None:
+            length = 0 if seq is None else len(seq)
+            inst._per_letter_annotations = _RestrictedDict(length=length)
+            dict.update(inst._per_letter_annotations, letter_annotations)  # type: ignore
+        return inst
+
+    @overload
+    def __getitem__(self, index: int) -> str: ...
+
+    @overload
+    def __getitem__(self, index: slice) -> "SeqRecord": ...
+
+    def __getitem__(self, index):
+        """Return a sub-sequence or an individual letter.
+
+        Slicing, e.g. my_record[5:10], returns a new SeqRecord for
+        that sub-sequence with some annotation preserved as follows:
+
+        * The name, id and description are kept as-is.
+        * Any per-letter-annotations are sliced to match the requested
+          sub-sequence.
+        * Unless a stride is used, all those features which fall fully
+          within the subsequence are included (with their locations
+          adjusted accordingly). If you want to preserve any truncated
+          features (e.g. GenBank/EMBL source features), you must
+          explicitly add them to the new SeqRecord yourself.
+        * With the exception of any molecule type, the annotations
+          dictionary and the dbxrefs list are not used for the new
+          SeqRecord, as in general they may not apply to the
+          subsequence. If you want to preserve them, you must explicitly
+          copy them to the new SeqRecord yourself.
+
+        Using an integer index, e.g. my_record[5] is shorthand for
+        extracting that letter from the sequence, my_record.seq[5].
+
+        For example, consider this short protein and its secondary
+        structure as encoded by the PDB (e.g. H for alpha helices),
+        plus a simple feature for its histidine self phosphorylation
+        site:
+
+        >>> from Bio.Seq import Seq
+        >>> from Bio.SeqRecord import SeqRecord
+        >>> from Bio.SeqFeature import SeqFeature, SimpleLocation
+        >>> rec = SeqRecord(Seq("MAAGVKQLADDRTLLMAGVSHDLRTPLTRIRLAT"
+        ...                     "EMMSEQDGYLAESINKDIEECNAIIEQFIDYLR"),
+        ...                 id="1JOY", name="EnvZ",
+        ...                 description="Homodimeric domain of EnvZ from E. coli")
+        >>> rec.letter_annotations["secondary_structure"] = "  S  SSSSSSHHHHHTTTHHHHHHHHHHHHHHHHHHHHHHTHHHHHHHHHHHHHHHHHHHHHTT  "
+        >>> rec.features.append(SeqFeature(SimpleLocation(20, 21),
+        ...                     type = "Site"))
+
+        Now let's have a quick look at the full record,
+
+        >>> print(rec)
+        ID: 1JOY
+        Name: EnvZ
+        Description: Homodimeric domain of EnvZ from E. coli
+        Number of features: 1
+        Per letter annotation for: secondary_structure
+        Seq('MAAGVKQLADDRTLLMAGVSHDLRTPLTRIRLATEMMSEQDGYLAESINKDIEE...YLR')
+        >>> rec.letter_annotations["secondary_structure"]
+        '  S  SSSSSSHHHHHTTTHHHHHHHHHHHHHHHHHHHHHHTHHHHHHHHHHHHHHHHHHHHHTT  '
+        >>> print(rec.features[0].location)
+        [20:21]
+
+        Now let's take a sub sequence, here chosen as the first (fractured)
+        alpha helix which includes the histidine phosphorylation site:
+
+        >>> sub = rec[11:41]
+        >>> print(sub)
+        ID: 1JOY
+        Name: EnvZ
+        Description: Homodimeric domain of EnvZ from E. coli
+        Number of features: 1
+        Per letter annotation for: secondary_structure
+        Seq('RTLLMAGVSHDLRTPLTRIRLATEMMSEQD')
+        >>> sub.letter_annotations["secondary_structure"]
+        'HHHHHTTTHHHHHHHHHHHHHHHHHHHHHH'
+        >>> print(sub.features[0].location)
+        [9:10]
+
+        You can also of course omit the start or end values, for
+        example to get the first ten letters only:
+
+        >>> print(rec[:10])
+        ID: 1JOY
+        Name: EnvZ
+        Description: Homodimeric domain of EnvZ from E. coli
+        Number of features: 0
+        Per letter annotation for: secondary_structure
+        Seq('MAAGVKQLAD')
+
+        Or for the last ten letters:
+
+        >>> print(rec[-10:])
+        ID: 1JOY
+        Name: EnvZ
+        Description: Homodimeric domain of EnvZ from E. coli
+        Number of features: 0
+        Per letter annotation for: secondary_structure
+        Seq('IIEQFIDYLR')
+
+        If you omit both, then you get a copy of the original record (although
+        lacking the annotations and dbxrefs):
+
+        >>> print(rec[:])
+        ID: 1JOY
+        Name: EnvZ
+        Description: Homodimeric domain of EnvZ from E. coli
+        Number of features: 1
+        Per letter annotation for: secondary_structure
+        Seq('MAAGVKQLADDRTLLMAGVSHDLRTPLTRIRLATEMMSEQDGYLAESINKDIEE...YLR')
+
+        Finally, indexing with a simple integer is shorthand for pulling out
+        that letter from the sequence directly:
+
+        >>> rec[5]
+        'K'
+        >>> rec.seq[5]
+        'K'
+        """
+        if isinstance(index, numbers.Integral):
+            # NOTE - The sequence level annotation like the id, name, etc
+            # do not really apply to a single character.  However, should
+            # we try and expose any per-letter-annotation here?  If so how?
+            if self.seq is None:
+                raise ValueError(
+                    "Seq in SeqRecord is None, it doesn't support indexing"
+                )
+            return self.seq[index]
+        elif isinstance(index, slice):
+            if self.seq is None:
+                raise ValueError("Seq in SeqRecord is None, we cannot slice it")
+            parent_length = len(self)
+            try:
+                from BioSQL.BioSeq import DBSeqRecord
+
+                biosql_available = True
+            except ImportError:
+                biosql_available = False
+
+            if biosql_available and isinstance(self, DBSeqRecord):
+                answer = SeqRecord._from_validated(
+                    self.seq[index],
+                    id=self.id,
+                    name=self.name,
+                    description=self.description,
+                )
+            else:
+                answer = self._from_validated(
+                    self.seq[index],
+                    id=self.id,
+                    name=self.name,
+                    description=self.description,
+                )
+            # TODO - The description may no longer apply.
+            # It would be safer to change it to something
+            # generic like "edited" or the default value.
+
+            # Don't copy the annotation dict and dbxefs list,
+            # they may not apply to a subsequence.
+            # answer.annotations = dict(self.annotations.items())
+            # answer.dbxrefs = self.dbxrefs[:]
+            # TODO - Review this in light of adding SeqRecord objects?
+
+            if "molecule_type" in self.annotations:
+                # This will still apply, and we need it for GenBank/EMBL etc output
+                answer.annotations["molecule_type"] = self.annotations["molecule_type"]
+
+            # TODO - Cope with strides by generating ambiguous locations?
+            start, stop, step = index.indices(parent_length)
+            if step == 1:
+                # Select relevant features, add them with shifted locations
+                # assert str(self.seq)[index] == str(self.seq)[start:stop]
+                for f in self.features:
+                    if f.location.ref or f.location.ref_db:
+                        # TODO - Implement this (with lots of tests)?
+                        import warnings
+
+                        warnings.warn(
+                            "When slicing SeqRecord objects, any "
+                            "SeqFeature referencing other sequences (e.g. "
+                            "from segmented GenBank records) are ignored."
+                        )
+                        continue
+                    try:
+                        if start <= f.location.start and f.location.end <= stop:
+                            answer.features.append(f._shift(-start))
+                    except TypeError:
+                        # Will fail on UnknownPosition
+                        pass
+
+            # Slice all the values to match the sliced sequence
+            # (this should also work with strides, even negative strides):
+            for key, value in self.letter_annotations.items():
+                answer.letter_annotations[key] = value[index]
+
+            return answer
+        raise ValueError("Invalid index")
+
+    def __iter__(self) -> Iterator[str]:
+        """Iterate over the letters in the sequence.
+
+        For example, using Bio.SeqIO to read in a protein FASTA file:
+
+        >>> from Bio import SeqIO
+        >>> record = SeqIO.read("Fasta/loveliesbleeding.pro", "fasta")
+        >>> for amino in record:
+        ...     print(amino)
+        ...     if amino == "L": break
+        X
+        A
+        G
+        L
+        >>> print(record.seq[3])
+        L
+
+        This is just a shortcut for iterating over the sequence directly:
+
+        >>> for amino in record.seq:
+        ...     print(amino)
+        ...     if amino == "L": break
+        X
+        A
+        G
+        L
+        >>> print(record.seq[3])
+        L
+
+        Note that this does not facilitate iteration together with any
+        per-letter-annotation.  However, you can achieve that using the
+        python zip function on the record (or its sequence) and the relevant
+        per-letter-annotation:
+
+        >>> from Bio import SeqIO
+        >>> rec = SeqIO.read("Quality/solexa_faked.fastq", "fastq-solexa")
+        >>> print("%s %s" % (rec.id, rec.seq))
+        slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
+        >>> print(list(rec.letter_annotations))
+        ['solexa_quality']
+        >>> for nuc, qual in zip(rec, rec.letter_annotations["solexa_quality"]):
+        ...     if qual > 35:
+        ...         print("%s %i" % (nuc, qual))
+        A 40
+        C 39
+        G 38
+        T 37
+        A 36
+
+        You may agree that using zip(rec.seq, ...) is more explicit than using
+        zip(rec, ...) as shown above.
+        """
+        if self._seq is None:
+            raise ValueError("Seq in SeqRecord is None, can't iterate over it")
+        return iter(self._seq)
+
+    def __contains__(self, char: str) -> bool:
+        """Implement the 'in' keyword, searches the sequence.
+
+        e.g.
+
+        >>> from Bio import SeqIO
+        >>> record = SeqIO.read("Fasta/sweetpea.nu", "fasta")
+        >>> "GAATTC" in record
+        False
+        >>> "AAA" in record
+        True
+
+        This essentially acts as a proxy for using "in" on the sequence:
+
+        >>> "GAATTC" in record.seq
+        False
+        >>> "AAA" in record.seq
+        True
+
+        Note that you can also use Seq objects as the query,
+
+        >>> from Bio.Seq import Seq
+        >>> Seq("AAA") in record
+        True
+
+        See also the Seq object's __contains__ method.
+        """
+        if self._seq is None:
+            raise ValueError("Seq in SeqRecord is None, can't convert to bytes")
+        return char in self._seq
+
+    def __bytes__(self) -> bytes:
+        if self._seq is None:
+            raise ValueError("Seq in SeqRecord is None, can't convert to bytes")
+        return bytes(self._seq)
+
+    def __str__(self) -> str:
+        """Return a human readable summary of the record and its annotation (string).
+
+        The python built in function str works by calling the object's __str__
+        method.  e.g.
+
+        >>> from Bio.Seq import Seq
+        >>> from Bio.SeqRecord import SeqRecord
+        >>> record = SeqRecord(Seq("MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF"),
+        ...                    id="YP_025292.1", name="HokC",
+        ...                    description="toxic membrane protein, small")
+        >>> print(str(record))
+        ID: YP_025292.1
+        Name: HokC
+        Description: toxic membrane protein, small
+        Number of features: 0
+        Seq('MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF')
+
+        In this example you don't actually need to call str explicitly, as the
+        print command does this automatically:
+
+        >>> print(record)
+        ID: YP_025292.1
+        Name: HokC
+        Description: toxic membrane protein, small
+        Number of features: 0
+        Seq('MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF')
+
+        Note that long sequences are shown truncated.
+        """
+        lines: list[str] = []
+        if self.id:
+            lines.append(f"ID: {self.id}")
+        if self.name:
+            lines.append(f"Name: {self.name}")
+        if self.description:
+            lines.append(f"Description: {self.description}")
+        if self.dbxrefs:
+            lines.append("Database cross-references: " + ", ".join(self.dbxrefs))
+        lines.append(f"Number of features: {len(self.features)}")
+        for a in self.annotations:
+            lines.append(f"/{a}={self.annotations[a]!s}")
+        if self.letter_annotations:
+            lines.append(
+                "Per letter annotation for: " + ", ".join(self.letter_annotations)
+            )
+        if self.seq is not None:
+            try:
+                bytes(self.seq)
+            except UndefinedSequenceError:
+                lines.append(f"Undefined sequence of length {len(self.seq)}")
+            else:
+                # Don't want to include the entire sequence
+                seq = repr(self.seq)
+                lines.append(seq)
+        else:
+            lines.append("Missing Sequence (None)")
+
+        return "\n".join(lines)
+
+    def __repr__(self) -> str:
+        """Return a concise summary of the record for debugging (string).
+
+        The python built in function repr works by calling the object's __repr__
+        method.  e.g.
+
+        >>> from Bio.Seq import Seq
+        >>> from Bio.SeqRecord import SeqRecord
+        >>> rec = SeqRecord(Seq("MASRGVNKVILVGNLGQDPEVRYMPNGGAVANITLATSESWRDKAT"
+        ...                     "GEMKEQTEWHRVVLFGKLAEVASEYLRKGSQVYIEGQLRTRKWTDQ"
+        ...                     "SGQDRYTTEVVVNVGGTMQMLGGRQGGGAPAGGNIGGGQPQGGWGQ"
+        ...                     "PQQPQGGNQFSGGAQSRPQQSAPAAPSNEPPMDFDDDIPF"),
+        ...                 id="NP_418483.1", name="b4059",
+        ...                 description="ssDNA-binding protein",
+        ...                 dbxrefs=["ASAP:13298", "GI:16131885", "GeneID:948570"])
+        >>> print(repr(rec))
+        SeqRecord(seq=Seq('MASRGVNKVILVGNLGQDPEVRYMPNGGAVANITLATSESWRDKATGEMKEQTE...IPF'), id='NP_418483.1', name='b4059', description='ssDNA-binding protein', dbxrefs=['ASAP:13298', 'GI:16131885', 'GeneID:948570'])
+
+        At the python prompt you can also use this shorthand:
+
+        >>> rec
+        SeqRecord(seq=Seq('MASRGVNKVILVGNLGQDPEVRYMPNGGAVANITLATSESWRDKATGEMKEQTE...IPF'), id='NP_418483.1', name='b4059', description='ssDNA-binding protein', dbxrefs=['ASAP:13298', 'GI:16131885', 'GeneID:948570'])
+
+        Note that long sequences are shown truncated. Also note that any
+        annotations, letter_annotations and features are not shown (as they
+        would lead to a very long string).
+        """
+        return (
+            f"{self.__class__.__name__}(seq={self.seq!r}, id={self.id!r},"
+            f" name={self.name!r}, description={self.description!r},"
+            f" dbxrefs={self.dbxrefs!r})"
+        )
+
+    def format(self, format: str) -> str:
+        r"""Return the record as a string in the specified file format.
+
+        The format should be a lower case string supported as an output
+        format by Bio.SeqIO, which is used to turn the SeqRecord into a
+        string.  e.g.
+
+        >>> from Bio.Seq import Seq
+        >>> from Bio.SeqRecord import SeqRecord
+        >>> record = SeqRecord(Seq("MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF"),
+        ...                    id="YP_025292.1", name="HokC",
+        ...                    description="toxic membrane protein")
+        >>> record.format("fasta")
+        '>YP_025292.1 toxic membrane protein\nMKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF\n'
+        >>> print(record.format("fasta"))
+        >YP_025292.1 toxic membrane protein
+        MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF
+        <BLANKLINE>
+
+        The Python print function automatically appends a new line, meaning
+        in this example a blank line is shown.  If you look at the string
+        representation you can see there is a trailing new line (shown as
+        slash n) which is important when writing to a file or if
+        concatenating multiple sequence strings together.
+
+        Note that this method will NOT work on every possible file format
+        supported by Bio.SeqIO (e.g. some are for multiple sequences only,
+        and binary formats are not supported).
+        """
+        # See also the __format__ method
+        return self.__format__(format)
+
+    def __format__(self, format_spec: str) -> str:
+        r"""Return the record as a string in the specified file format.
+
+        This method supports the Python format() function and f-strings.
+        The format_spec should be a lower case string supported by
+        Bio.SeqIO as a text output file format. Requesting a binary file
+        format raises a ValueError. e.g.
+
+        >>> from Bio.Seq import Seq
+        >>> from Bio.SeqRecord import SeqRecord
+        >>> record = SeqRecord(Seq("MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF"),
+        ...                    id="YP_025292.1", name="HokC",
+        ...                    description="toxic membrane protein")
+        ...
+        >>> format(record, "fasta")
+        '>YP_025292.1 toxic membrane protein\nMKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF\n'
+        >>> print(f"Here is {record.id} in FASTA format:\n{record:fasta}")
+        Here is YP_025292.1 in FASTA format:
+        >YP_025292.1 toxic membrane protein
+        MKQHKAMIVALIVICITAVVAALVTRKDLCEVHIRTGQTEVAVF
+        <BLANKLINE>
+
+        See also the SeqRecord's format() method.
+        """
+        if not format_spec:
+            # Follow python convention and default to using __str__
+            return str(self)
+        from Bio import SeqIO
+
+        cls = SeqIO._FormatToWriter[format_spec]
+        try:
+            return cls.to_string(self)  # type: ignore
+        except StreamModeError:
+            raise ValueError(
+                "Binary format %s cannot be used with SeqRecord format method"
+                % format_spec
+            ) from None
+
+    def __len__(self) -> int:
+        """Return the length of the sequence.
+
+        For example, using Bio.SeqIO to read in a FASTA nucleotide file:
+
+        >>> from Bio import SeqIO
+        >>> record = SeqIO.read("Fasta/sweetpea.nu", "fasta")
+        >>> len(record)
+        309
+        >>> len(record.seq)
+        309
+        """
+        return len(self._seq) if self._seq is not None else 0
+
+    def __lt__(self, other: Any) -> NoReturn:
+        """Define the less-than operand (not implemented)."""
+        raise NotImplementedError(_NO_SEQRECORD_COMPARISON)
+
+    def __le__(self, other: Any) -> NoReturn:
+        """Define the less-than-or-equal-to operand (not implemented)."""
+        raise NotImplementedError(_NO_SEQRECORD_COMPARISON)
+
+    def __eq__(self, other: object) -> NoReturn:
+        """Define the equal-to operand (not implemented)."""
+        raise NotImplementedError(_NO_SEQRECORD_COMPARISON)
+
+    def __ne__(self, other: object) -> NoReturn:
+        """Define the not-equal-to operand (not implemented)."""
+        raise NotImplementedError(_NO_SEQRECORD_COMPARISON)
+
+    def __gt__(self, other: Any) -> NoReturn:
+        """Define the greater-than operand (not implemented)."""
+        raise NotImplementedError(_NO_SEQRECORD_COMPARISON)
+
+    def __ge__(self, other: Any) -> NoReturn:
+        """Define the greater-than-or-equal-to operand (not implemented)."""
+        raise NotImplementedError(_NO_SEQRECORD_COMPARISON)
+
+    def __bool__(self) -> bool:
+        """Boolean value of an instance of this class (True).
+
+        This behaviour is for backwards compatibility, since until the
+        __len__ method was added, a SeqRecord always evaluated as True.
+
+        Note that in comparison, a Seq object will evaluate to False if it
+        has a zero length sequence.
+
+        WARNING: The SeqRecord may in future evaluate to False when its
+        sequence is of zero length (in order to better match the Seq
+        object behaviour)!
+        """
+        return True
+
+    def __add__(
+        self, other: Union["SeqRecord", "Seq", "MutableSeq", str]
+    ) -> "SeqRecord":
+        """Add another sequence or string to this sequence.
+
+        The other sequence can be a SeqRecord object, a Seq object (or
+        similar, e.g. a MutableSeq) or a plain Python string. If you add
+        a plain string or a Seq (like) object, the new SeqRecord will simply
+        have this appended to the existing data. However, any per letter
+        annotation will be lost:
+
+        >>> from Bio import SeqIO
+        >>> record = SeqIO.read("Quality/solexa_faked.fastq", "fastq-solexa")
+        >>> print("%s %s" % (record.id, record.seq))
+        slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
+        >>> print(list(record.letter_annotations))
+        ['solexa_quality']
+
+        >>> new = record + "ACT"
+        >>> print("%s %s" % (new.id, new.seq))
+        slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNNACT
+        >>> print(list(new.letter_annotations))
+        []
+
+        The new record will attempt to combine the annotation, but for any
+        ambiguities (e.g. different names) it defaults to omitting that
+        annotation.
+
+        >>> from Bio import SeqIO
+        >>> with open("GenBank/pBAD30.gb") as handle:
+        ...     plasmid = SeqIO.read(handle, "gb")
+        >>> print("%s %i" % (plasmid.id, len(plasmid)))
+        pBAD30 4923
+
+        Now let's cut the plasmid into two pieces, and join them back up the
+        other way round (i.e. shift the starting point on this plasmid, have
+        a look at the annotated features in the original file to see why this
+        particular split point might make sense):
+
+        >>> left = plasmid[:3765]
+        >>> right = plasmid[3765:]
+        >>> new = right + left
+        >>> print("%s %i" % (new.id, len(new)))
+        pBAD30 4923
+        >>> str(new.seq) == str(right.seq + left.seq)
+        True
+        >>> len(new.features) == len(left.features) + len(right.features)
+        True
+
+        When we add the left and right SeqRecord objects, their annotation
+        is all consistent, so it is all conserved in the new SeqRecord:
+
+        >>> new.id == left.id == right.id == plasmid.id
+        True
+        >>> new.name == left.name == right.name == plasmid.name
+        True
+        >>> new.description == plasmid.description
+        True
+        >>> new.annotations == left.annotations == right.annotations
+        True
+        >>> new.letter_annotations == plasmid.letter_annotations
+        True
+        >>> new.dbxrefs == left.dbxrefs == right.dbxrefs
+        True
+
+        However, we should point out that when we sliced the SeqRecord,
+        any annotations dictionary or dbxrefs list entries were lost.
+        You can explicitly copy them like this:
+
+        >>> new.annotations = plasmid.annotations.copy()
+        >>> new.dbxrefs = plasmid.dbxrefs[:]
+        """
+
+        if self._seq is None:
+            raise ValueError("Left operand seq=None, can't add")
+
+        if not isinstance(other, SeqRecord):
+            # Assume it is a string or a Seq.
+            # Note can't transfer any per-letter-annotations
+            return type(self)(
+                self._seq + other,
+                id=self.id,
+                name=self.name,
+                description=self.description,
+                features=self.features[:],
+                annotations=self.annotations.copy(),
+                dbxrefs=self.dbxrefs[:],
+            )
+
+        if other._seq is None:
+            raise ValueError("Right SeqRecord has seq=None, can't add")
+
+        # Adding two SeqRecord objects... must merge annotation
+        answer = self._from_validated(
+            self._seq + other._seq, features=self.features[:], dbxrefs=self.dbxrefs[:]
+        )
+        # Will take all the features and all the db cross refs,
+        length = len(self)
+        for f in other.features:
+            answer.features.append(f._shift(length))
+        del length
+        for ref in other.dbxrefs:
+            if ref not in answer.dbxrefs:
+                answer.dbxrefs.append(ref)
+
+        # Take common id/name/description/annotation
+        if self.id == other.id:
+            answer.id = self.id
+        if self.name == other.name:
+            answer.name = self.name
+        if self.description == other.description:
+            answer.description = self.description
+        for k, v in self.annotations.items():
+            if k in other.annotations and other.annotations[k] == v:
+                answer.annotations[k] = v
+        # Can append matching per-letter-annotation
+        try:
+            # To make this type safe, we would need to make sure the types are compatible, eg: no adding tuples and str
+            for k, v in self.letter_annotations.items():  # type: ignore
+                if k in other.letter_annotations:
+                    # avoid length checks, but otherwise equivalent to answer.letter_annotations[k] = v + other.letter_annotations[k]
+                    dict.__setitem__(
+                        answer.letter_annotations,
+                        k,
+                        v + other.letter_annotations[k],  # type: ignore
+                    )
+        except TypeError:
+            print("Failed while try to concatenate letter annotations")
+            raise
+
+        return answer
+
+    def __radd__(self, other: Union["Seq", "MutableSeq", str]) -> "SeqRecord":
+        """Add another sequence or string to this sequence (from the left).
+
+        This method handles adding a Seq object (or similar, e.g. MutableSeq)
+        or a plain Python string (on the left) to a SeqRecord (on the right).
+        See the __add__ method for more details, but for example:
+
+        >>> from Bio import SeqIO
+        >>> record = SeqIO.read("Quality/solexa_faked.fastq", "fastq-solexa")
+        >>> print("%s %s" % (record.id, record.seq))
+        slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
+        >>> print(list(record.letter_annotations))
+        ['solexa_quality']
+
+        >>> new = "ACT" + record
+        >>> print("%s %s" % (new.id, new.seq))
+        slxa_0001_1_0001_01 ACTACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
+        >>> print(list(new.letter_annotations))
+        []
+        """
+        if isinstance(other, SeqRecord):
+            raise RuntimeError(
+                "This should have happened via the __add__ of "
+                "the other SeqRecord being added!"
+            )
+        if self.seq is None:
+            raise TypeError("Can't add (right hand side) SeqRecord with seq = None")
+        # Assume it is a string or a Seq.
+        # Note can't transfer any per-letter-annotations
+        offset = len(other)
+        return type(self)(
+            cast(Seq | MutableSeq, other + self.seq),
+            id=self.id,
+            name=self.name,
+            description=self.description,
+            features=[f._shift(offset) for f in self.features],
+            annotations=self.annotations.copy(),
+            dbxrefs=self.dbxrefs[:],
+        )
+
+    def count(self, sub, start=None, end=None):
+        """Return the number of non-overlapping occurrences of sub in seq[start:end].
+
+        Optional arguments start and end are interpreted as in slice notation.
+        This method behaves as the count method of Python strings.
+        """
+        if self._seq is None:
+            raise ValueError(
+                "seq is SeqRecord is None, assign it a sequence before applying count"
+            )
+        return self.seq.count(sub, start, end)
+
+    def upper(self) -> "SeqRecord":
+        """Return a copy of the record with an upper case sequence.
+
+        All the annotation is preserved unchanged. e.g.
+
+        >>> from Bio.Seq import Seq
+        >>> from Bio.SeqRecord import SeqRecord
+        >>> record = SeqRecord(Seq("acgtACGT"), id="Test",
+        ...                    description = "Made up for this example")
+        >>> record.letter_annotations["phred_quality"] = [1, 2, 3, 4, 5, 6, 7, 8]
+        >>> print(record.upper().format("fastq"))
+        @Test Made up for this example
+        ACGTACGT
+        +
+        "#$%&'()
+        <BLANKLINE>
+
+        Naturally, there is a matching lower method:
+
+        >>> print(record.lower().format("fastq"))
+        @Test Made up for this example
+        acgtacgt
+        +
+        "#$%&'()
+        <BLANKLINE>
+        """
+        if self.seq is None:
+            raise ValueError(
+                "seq is SeqRecord is None, assign it a sequence before applying upper"
+            )
+        return self._from_validated(
+            self.seq.upper(),
+            id=self.id,
+            name=self.name,
+            description=self.description,
+            dbxrefs=self.dbxrefs[:],
+            features=self.features[:],
+            annotations=self.annotations.copy(),
+            letter_annotations=(
+                None
+                if self._per_letter_annotations is None
+                else self.letter_annotations.copy()
+            ),
+        )
+
+    def lower(self) -> "SeqRecord":
+        """Return a copy of the record with a lower case sequence.
+
+        All the annotation is preserved unchanged. e.g.
+
+        >>> from Bio import SeqIO
+        >>> record = SeqIO.read("Fasta/aster.pro", "fasta")
+        >>> print(record.format("fasta"))
+        >gi|3298468|dbj|BAA31520.1| SAMIPF
+        GGHVNPAVTFGAFVGGNITLLRGIVYIIAQLLGSTVACLLLKFVTNDMAVGVFSLSAGVG
+        VTNALVFEIVMTFGLVYTVYATAIDPKKGSLGTIAPIAIGFIVGANI
+        <BLANKLINE>
+        >>> print(record.lower().format("fasta"))
+        >gi|3298468|dbj|BAA31520.1| SAMIPF
+        gghvnpavtfgafvggnitllrgivyiiaqllgstvaclllkfvtndmavgvfslsagvg
+        vtnalvfeivmtfglvytvyataidpkkgslgtiapiaigfivgani
+        <BLANKLINE>
+
+        To take a more annotation rich example,
+
+        >>> from Bio import SeqIO
+        >>> old = SeqIO.read("EMBL/TRBG361.embl", "embl")
+        >>> len(old.features)
+        3
+        >>> new = old.lower()
+        >>> len(old.features) == len(new.features)
+        True
+        >>> old.annotations["organism"] == new.annotations["organism"]
+        True
+        >>> old.dbxrefs == new.dbxrefs
+        True
+        """
+        if self.seq is None:
+            raise ValueError(
+                "seq is SeqRecord is None, assign it a sequence before applying lower"
+            )
+        return self._from_validated(
+            self.seq.lower(),
+            id=self.id,
+            name=self.name,
+            description=self.description,
+            dbxrefs=self.dbxrefs[:],
+            features=self.features[:],
+            annotations=self.annotations.copy(),
+            letter_annotations=(
+                None
+                if self._per_letter_annotations is None
+                else self.letter_annotations.copy()
+            ),
+        )
+
+    def isupper(self):
+        """Return True if all ASCII characters in the record's sequence are uppercase.
+
+        If there are no cased characters, the method returns False.
+        """
+        return self.seq.isupper()
+
+    def islower(self):
+        """Return True if all ASCII characters in the record's sequence are lowercase.
+
+        If there are no cased characters, the method returns False.
+        """
+        return self.seq.islower()
+
+    def reverse_complement(
+        self,
+        id: bool = False,
+        name: bool = False,
+        description: bool = False,
+        features: bool = True,
+        annotations: bool = False,
+        letter_annotations: bool = True,
+        dbxrefs: bool = False,
+    ) -> "SeqRecord":
+        """Return new SeqRecord with reverse complement sequence.
+
+        By default the new record does NOT preserve the sequence identifier,
+        name, description, general annotation or database cross-references -
+        these are unlikely to apply to the reversed sequence.
+
+        You can specify the returned record's id, name and description as
+        strings, or True to keep that of the parent, or False for a default.
+
+        You can specify the returned record's features with a list of
+        SeqFeature objects, or True to keep that of the parent, or False to
+        omit them. The default is to keep the original features (with the
+        strand and locations adjusted).
+
+        You can also specify both the returned record's annotations and
+        letter_annotations as dictionaries, True to keep that of the parent,
+        or False to omit them. The default is to keep the original
+        annotations (with the letter annotations reversed).
+
+        To show what happens to the pre-letter annotations, consider an
+        example Solexa variant FASTQ file with a single entry, which we'll
+        read in as a SeqRecord:
+
+        >>> from Bio import SeqIO
+        >>> record = SeqIO.read("Quality/solexa_faked.fastq", "fastq-solexa")
+        >>> print("%s %s" % (record.id, record.seq))
+        slxa_0001_1_0001_01 ACGTACGTACGTACGTACGTACGTACGTACGTACGTACGTNNNNNN
+        >>> print(list(record.letter_annotations))
+        ['solexa_quality']
+        >>> print(record.letter_annotations["solexa_quality"])
+        [40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3, -4, -5]
+
+        Now take the reverse complement, here we explicitly give a new
+        identifier (the old identifier with a suffix):
+
+        >>> rc_record = record.reverse_complement(id=record.id + "_rc")
+        >>> print("%s %s" % (rc_record.id, rc_record.seq))
+        slxa_0001_1_0001_01_rc NNNNNNACGTACGTACGTACGTACGTACGTACGTACGTACGTACGT
+
+        Notice that the per-letter-annotations have also been reversed,
+        although this may not be appropriate for all cases.
+
+        >>> print(rc_record.letter_annotations["solexa_quality"])
+        [-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40]
+
+        Now for the features, we need a different example. Parsing a GenBank
+        file is probably the easiest way to get an nice example with features
+        in it...
+
+        >>> from Bio import SeqIO
+        >>> with open("GenBank/pBAD30.gb") as handle:
+        ...     plasmid = SeqIO.read(handle, "gb")
+        >>> print("%s %i" % (plasmid.id, len(plasmid)))
+        pBAD30 4923
+        >>> plasmid.seq
+        Seq('GCTAGCGGAGTGTATACTGGCTTACTATGTTGGCACTGATGAGGGTGTCAGTGA...ATG')
+        >>> len(plasmid.features)
+        13
+
+        Now, let's take the reverse complement of this whole plasmid:
+
+        >>> rc_plasmid = plasmid.reverse_complement(id=plasmid.id+"_rc")
+        >>> print("%s %i" % (rc_plasmid.id, len(rc_plasmid)))
+        pBAD30_rc 4923
+        >>> rc_plasmid.seq
+        Seq('CATGGGCAAATATTATACGCAAGGCGACAAGGTGCTGATGCCGCTGGCGATTCA...AGC')
+        >>> len(rc_plasmid.features)
+        13
+
+        Let's compare the first CDS feature - it has gone from being the
+        second feature (index 1) to the second last feature (index -2), its
+        strand has changed, and the location switched round.
+
+        >>> print(plasmid.features[1])
+        type: CDS
+        location: [1081:1960](-)
+        qualifiers:
+            Key: label, Value: ['araC']
+            Key: note, Value: ['araC regulator of the arabinose BAD promoter']
+            Key: vntifkey, Value: ['4']
+        <BLANKLINE>
+        >>> print(rc_plasmid.features[-2])
+        type: CDS
+        location: [2963:3842](+)
+        qualifiers:
+            Key: label, Value: ['araC']
+            Key: note, Value: ['araC regulator of the arabinose BAD promoter']
+            Key: vntifkey, Value: ['4']
+        <BLANKLINE>
+
+        You can check this new location, based on the length of the plasmid:
+
+        >>> len(plasmid) - 1081
+        3842
+        >>> len(plasmid) - 1960
+        2963
+
+        Note that if the SeqFeature annotation includes any strand specific
+        information (e.g. base changes for a SNP), this information is not
+        amended, and would need correction after the reverse complement.
+
+        Note trying to reverse complement a protein SeqRecord raises an
+        exception:
+
+        >>> from Bio.Seq import Seq
+        >>> from Bio.SeqRecord import SeqRecord
+        >>> protein_rec = SeqRecord(Seq("MAIVMGR"), id="Test",
+        ...                         annotations={"molecule_type": "protein"})
+        >>> protein_rec.reverse_complement()
+        Traceback (most recent call last):
+           ...
+        ValueError: Proteins do not have complements!
+
+        If you have RNA without any U bases, it must be annotated as RNA
+        otherwise it will be treated as DNA by default with A mapped to T:
+
+        >>> from Bio.Seq import Seq
+        >>> from Bio.SeqRecord import SeqRecord
+        >>> rna1 = SeqRecord(Seq("ACG"), id="Test")
+        >>> rna2 = SeqRecord(Seq("ACG"), id="Test", annotations={"molecule_type": "RNA"})
+        >>> print(rna1.reverse_complement(id="RC", description="unk").format("fasta"))
+        >RC unk
+        CGT
+        <BLANKLINE>
+        >>> print(rna2.reverse_complement(id="RC", description="RNA").format("fasta"))
+        >RC RNA
+        CGU
+        <BLANKLINE>
+
+        Also note you can reverse complement a SeqRecord using a MutableSeq:
+
+        >>> from Bio.Seq import MutableSeq
+        >>> from Bio.SeqRecord import SeqRecord
+        >>> rec = SeqRecord(MutableSeq("ACGT"), id="Test")
+        >>> rec.seq[0] = "T"
+        >>> print("%s %s" % (rec.id, rec.seq))
+        Test TCGT
+        >>> rc = rec.reverse_complement(id=True)
+        >>> print("%s %s" % (rc.id, rc.seq))
+        Test ACGA
+        """
+
+        if self.seq is None:
+            raise ValueError(
+                "Seq in SeqRecord is None, so can't construct the reverse_complement. Please assign it a sequence first"
+            )
+
+        if "protein" in cast(str, self.annotations.get("molecule_type", "")):
+            raise ValueError("Proteins do not have complements!")
+        if "RNA" in cast(str, self.annotations.get("molecule_type", "")):
+            seq = self.seq.reverse_complement_rna()
+        else:
+            # Default to DNA
+            seq = self.seq.reverse_complement()
+        if isinstance(self.seq, MutableSeq):
+            seq = Seq(seq)
+        answer = self._from_validated(seq)
+        if isinstance(id, str):
+            answer.id = id
+        elif id:
+            answer.id = self.id
+        if isinstance(name, str):
+            answer.name = name
+        elif name:
+            answer.name = self.name
+        if isinstance(description, str):
+            answer.description = description
+        elif description:
+            answer.description = self.description
+        if isinstance(dbxrefs, list):
+            answer.dbxrefs = dbxrefs
+        elif dbxrefs:
+            # Copy the old dbxrefs
+            answer.dbxrefs = self.dbxrefs[:]
+        if isinstance(features, list):
+            answer.features = features
+        elif features:
+            # Copy the old features, adjusting location and string
+            length = len(answer)
+            answer.features = [f._flip(length) for f in self.features]
+
+            # The old list should have been sorted by start location,
+            # reversing it will leave it sorted by what is now the end position,
+            # so we need to resort in case of overlapping features.
+            # NOTE - In the common case of gene before CDS (and similar) with
+            # the exact same locations, this will still maintain gene before CDS
+
+            def key_fun(f):
+                """Sort on start position."""
+                try:
+                    return int(f.location.start)
+                except TypeError:  # Expected for UnknownPosition
+                    return None
+
+            answer.features.sort(key=key_fun)
+        if isinstance(annotations, dict):
+            answer.annotations = annotations
+        elif annotations:
+            # Copy the old annotations,
+            answer.annotations = self.annotations.copy()
+        if self._per_letter_annotations is not None:
+            if isinstance(letter_annotations, dict):
+                answer.letter_annotations = letter_annotations
+            elif letter_annotations:
+                # Copy the old per letter annotations, reversing them
+                for key, value in self.letter_annotations.items():
+                    answer.letter_annotations[key] = value[::-1]
+        return answer
+
+    def translate(
+        self,
+        # Seq translation arguments:
+        table: str = "Standard",
+        stop_symbol: str = "*",
+        to_stop: bool = False,
+        cds: bool = False,
+        gap: str | None = None,
+        # SeqRecord annotation arguments:
+        id: bool = False,
+        name: bool = False,
+        description: bool = False,
+        features: bool = False,
+        annotations: bool = False,
+        letter_annotations: bool = False,
+        dbxrefs: bool = False,
+    ) -> "SeqRecord":
+        """Return new SeqRecord with translated sequence.
+
+        This calls the record's .seq.translate() method (which describes
+        the translation related arguments, like table for the genetic code),
+
+        By default the new record does NOT preserve the sequence identifier,
+        name, description, general annotation or database cross-references -
+        these are unlikely to apply to the translated sequence.
+
+        You can specify the returned record's id, name and description as
+        strings, or True to keep that of the parent, or False for a default.
+
+        You can specify the returned record's features with a list of
+        SeqFeature objects, or False (default) to omit them.
+
+        You can also specify both the returned record's annotations and
+        letter_annotations as dictionaries, True to keep that of the parent
+        (annotations only), or False (default) to omit them.
+
+        e.g. Loading a FASTA gene and translating it,
+
+        >>> from Bio import SeqIO
+        >>> gene_record = SeqIO.read("Fasta/sweetpea.nu", "fasta")
+        >>> print(gene_record.format("fasta"))
+        >gi|3176602|gb|U78617.1|LOU78617 Lathyrus odoratus phytochrome A (PHYA) gene, partial cds
+        CAGGCTGCGCGGTTTCTATTTATGAAGAACAAGGTCCGTATGATAGTTGATTGTCATGCA
+        AAACATGTGAAGGTTCTTCAAGACGAAAAACTCCCATTTGATTTGACTCTGTGCGGTTCG
+        ACCTTAAGAGCTCCACATAGTTGCCATTTGCAGTACATGGCTAACATGGATTCAATTGCT
+        TCATTGGTTATGGCAGTGGTCGTCAATGACAGCGATGAAGATGGAGATAGCCGTGACGCA
+        GTTCTACCACAAAAGAAAAAGAGACTTTGGGGTTTGGTAGTTTGTCATAACACTACTCCG
+        AGGTTTGTT
+        <BLANKLINE>
+
+        And now translating the record, specifying the new ID and description:
+
+        >>> protein_record = gene_record.translate(table=11,
+        ...                                        id="phya",
+        ...                                        description="translation")
+        >>> print(protein_record.format("fasta"))
+        >phya translation
+        QAARFLFMKNKVRMIVDCHAKHVKVLQDEKLPFDLTLCGSTLRAPHSCHLQYMANMDSIA
+        SLVMAVVVNDSDEDGDSRDAVLPQKKKRLWGLVVCHNTTPRFV
+        <BLANKLINE>
+
+        """
+        if "protein" == self.annotations.get("molecule_type", ""):
+            raise ValueError("Proteins cannot be translated!")
+
+        if self.seq is None:
+            raise ValueError("Seq in SeqRecord is None, can't be translated")
+
+        answer = SeqRecord(
+            self.seq.translate(
+                table=table, stop_symbol=stop_symbol, to_stop=to_stop, cds=cds, gap=gap
+            )
+        )
+        if isinstance(id, str):
+            answer.id = id
+        elif id:
+            answer.id = self.id
+        if isinstance(name, str):
+            answer.name = name
+        elif name:
+            answer.name = self.name
+        if isinstance(description, str):
+            answer.description = description
+        elif description:
+            answer.description = self.description
+        if isinstance(dbxrefs, list):
+            answer.dbxrefs = dbxrefs
+        elif dbxrefs:
+            # Copy the old dbxrefs
+            answer.dbxrefs = self.dbxrefs[:]
+        if isinstance(features, list):
+            answer.features = features
+        elif features:
+            # Does not make sense to copy old features as locations wrong
+            raise TypeError(f"Unexpected features argument {features!r}")
+        if isinstance(annotations, dict):
+            answer.annotations = annotations
+        elif annotations:
+            # Copy the old annotations
+            answer.annotations = self.annotations.copy()
+        # Set/update to protein:
+        answer.annotations["molecule_type"] = "protein"
+        if self._per_letter_annotations is not None:
+            if isinstance(letter_annotations, dict):
+                answer.letter_annotations = letter_annotations
+            elif letter_annotations:
+                # Does not make sense to copy these as length now wrong
+                raise TypeError(
+                    f"Unexpected letter_annotations argument {letter_annotations!r}"
+                )
+        return answer
+
+
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()

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

@@ -0,0 +1,147 @@
+# Copyright 1999-2003 by Jeffrey Chang.  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.
+"""Collection of modules for dealing with biological data in Python.
+
+The Biopython Project is an international association of developers
+of freely available Python tools for computational molecular biology.
+
+https://biopython.org
+"""
+
+import os
+import warnings
+
+__version__ = "1.87"
+
+
+class MissingExternalDependencyError(Exception):
+    """Missing an external dependency.
+
+    Used for things like missing command line tools. Important for our unit
+    tests to allow skipping tests with missing external dependencies.
+    """
+
+
+class MissingPythonDependencyError(MissingExternalDependencyError, ImportError):
+    """Missing an external python dependency (subclass of ImportError).
+
+    Used for missing Python modules (rather than just a typical ImportError).
+    Important for our unit tests to allow skipping tests with missing external
+    python dependencies, while also allowing the exception to be caught as an
+    ImportError.
+    """
+
+
+class StreamModeError(ValueError):
+    """Incorrect stream mode (text vs binary).
+
+    This error should be raised when a stream (file or file-like object)
+    argument is in text mode while the receiving function expects binary mode,
+    or vice versa.
+    """
+
+
+class BiopythonWarning(Warning):
+    """Biopython warning.
+
+    Biopython should use this warning (or subclasses of it), making it easy to
+    silence all our warning messages should you wish to:
+
+    >>> import warnings
+    >>> from Bio import BiopythonWarning
+    >>> warnings.simplefilter('ignore', BiopythonWarning)
+
+    Consult the warnings module documentation for more details.
+    """
+
+
+class BiopythonParserWarning(BiopythonWarning):
+    """Biopython parser warning.
+
+    Some in-valid data files cannot be parsed and will trigger an exception.
+    Where a reasonable interpretation is possible, Biopython will issue this
+    warning to indicate a potential problem. To silence these warnings, use:
+
+    >>> import warnings
+    >>> from Bio import BiopythonParserWarning
+    >>> warnings.simplefilter('ignore', BiopythonParserWarning)
+
+    Consult the warnings module documentation for more details.
+    """
+
+
+class BiopythonDeprecationWarning(BiopythonWarning):
+    """Biopython deprecation warning.
+
+    Biopython uses this warning instead of the built in DeprecationWarning
+    since those are ignored by default since Python 2.7.
+
+    To silence all our deprecation warning messages, use:
+
+    >>> import warnings
+    >>> from Bio import BiopythonDeprecationWarning
+    >>> warnings.simplefilter('ignore', BiopythonDeprecationWarning)
+
+    Code marked as deprecated is likely to be removed in a future version
+    of Biopython. To avoid removal of this code, please contact the Biopython
+    developers via the mailing list or GitHub.
+    """
+
+
+class BiopythonExperimentalWarning(BiopythonWarning):
+    """Biopython experimental code warning.
+
+    Biopython uses this warning for experimental code ('alpha' or 'beta'
+    level code) which is released as part of the standard releases to mark
+    sub-modules or functions for early adopters to test & give feedback.
+
+    Code issuing this warning is likely to change (or even be removed) in
+    a subsequent release of Biopython. Such code should NOT be used for
+    production/stable code. It should only be used if:
+
+    - You are running the latest release of Biopython, or ideally the
+      latest code from our repository.
+    - You are subscribed to the biopython-dev mailing list to provide
+      feedback on this code, and to be alerted of changes to it.
+
+    If all goes well, experimental code would be promoted to stable in
+    a subsequent release, and this warning removed from it.
+    """
+
+
+_parent_dir = os.path.dirname(os.path.dirname(__file__))
+if os.path.exists(os.path.join(_parent_dir, "pyproject.toml")):
+    # Looks like we are running from our source directory,
+    # a bad idea except if installed in development mode.
+    #
+    # See https://setuptools.readthedocs.io/en/latest/userguide/development_mode.html
+    # Do we have .../site-packages/biopython.egg-link present?
+    #
+    # Note "pip install -e ." currently calls setuptools internally
+    import site
+
+    _dev_mode = False
+    for _p in site.getsitepackages():
+        if os.path.isfile(os.path.join(_p, "biopython.egg-link")):
+            _dev_mode = True
+            break
+    # Also check the user specific site packages
+    if not _dev_mode and os.path.isfile(
+        os.path.join(site.getusersitepackages(), "biopython.egg-link")
+    ):
+        _dev_mode = True
+    if not _dev_mode:
+        warnings.warn(
+            "You may be importing Biopython from inside the source tree."
+            " This is bad practice and might lead to downstream issues."
+            " In particular, you might encounter ImportErrors due to"
+            " missing compiled C extensions. We recommend that you"
+            " try running your code from outside the source tree."
+            " If you are outside the source tree then you have a"
+            " pyproject.toml file in an unexpected directory: " + _parent_dir,
+            BiopythonWarning,
+        )

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

@@ -0,0 +1,92 @@
+# Copyright 2010 by Eric Talevich. All rights reserved.
+# Copyright 2012 by Wibowo Arindrarto. All rights reserved.
+#
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+"""Common utility functions for various Bio submodules."""
+
+import os
+from typing import Any
+from collections.abc import Callable
+from typing import cast
+from typing import Optional
+from typing import Protocol
+from typing import TypeVar
+
+# workaround type checking method attributes from https://github.com/python/mypy/issues/2087#issuecomment-587741762
+
+F = TypeVar("F", bound=Callable[..., object])
+
+
+class _FunctionWithPrevious(Protocol[F]):
+    previous: int | None
+    __call__: F
+
+
+def function_with_previous(func: F) -> _FunctionWithPrevious[F]:
+    """Decorate a function as having an attribute named 'previous'."""
+    function_with_previous = cast(_FunctionWithPrevious[F], func)
+    # Make sure the cast isn't a lie.
+    function_with_previous.previous = None
+    return function_with_previous
+
+
+def find_test_dir(start_dir: str | None = None) -> str:
+    """Find the absolute path of Biopython's Tests directory.
+
+    Arguments:
+    start_dir -- Initial directory to begin lookup (default to current dir)
+
+    If the directory is not found up the filesystem's root directory, an
+    exception will be raised.
+
+    """
+    if not start_dir:
+        # no callbacks in function signatures!
+        # defaults to the current directory
+        # (using __file__ would give the installed Biopython)
+        start_dir = "."
+
+    target = os.path.abspath(start_dir)
+    while True:
+        if os.path.isdir(os.path.join(target, "Bio")) and os.path.isdir(
+            os.path.join(target, "Tests")
+        ):
+            # Good, we're in the Biopython root now
+            return os.path.abspath(os.path.join(target, "Tests"))
+        # Recurse up the tree
+        # TODO - Test this on Windows
+        new, tmp = os.path.split(target)
+        if target == new:
+            # Reached root
+            break
+        target = new
+    raise ValueError(
+        f"Not within Biopython source tree: {os.path.abspath(start_dir)!r}"
+    )
+
+
+def run_doctest(target_dir: str | None = None, *args: Any, **kwargs: Any) -> None:
+    """Run doctest for the importing module."""
+    import doctest
+
+    # default doctest options
+    doctest_attributes: dict[str, Any] = {"optionflags": doctest.ELLIPSIS}
+    doctest_attributes.update(kwargs)
+
+    cur_dir = os.path.abspath(os.curdir)
+
+    print("Running doctests...")
+    try:
+        os.chdir(find_test_dir(target_dir))
+        doctest.testmod(*args, **doctest_attributes)
+    finally:
+        # and revert back to initial directory
+        os.chdir(cur_dir)
+    print("Done")
+
+
+if __name__ == "__main__":
+    run_doctest()

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

@@ -0,0 +1,960 @@
+#!/usr/bin/env python
+# Copyright 2010-2018 by Peter Cock.
+# All rights reserved.
+#
+# This file is part of the Biopython distribution and governed by your
+# choice of the "Biopython License Agreement" or the "BSD 3-Clause License".
+# Please see the LICENSE file that should have been included as part of this
+# package.
+r"""Read and write BGZF compressed files (the GZIP variant used in BAM).
+
+The SAM/BAM file format (Sequence Alignment/Map) comes in a plain text
+format (SAM), and a compressed binary format (BAM). The latter uses a
+modified form of gzip compression called BGZF (Blocked GNU Zip Format),
+which can be applied to any file format to provide compression with
+efficient random access. BGZF is described together with the SAM/BAM
+file format at https://samtools.sourceforge.net/SAM1.pdf
+
+Please read the text below about 'virtual offsets' before using BGZF
+files for random access.
+
+Aim of this module
+------------------
+The Python gzip library can be used to read BGZF files, since for
+decompression they are just (specialised) gzip files. What this
+module aims to facilitate is random access to BGZF files (using the
+'virtual offset' idea), and writing BGZF files (which means using
+suitably sized gzip blocks and writing the extra 'BC' field in the
+gzip headers). As in the gzip library, the zlib library is used
+internally.
+
+In addition to being required for random access to and writing of
+BAM files, the BGZF format can also be used on other sequential
+data (in the sense of one record after another), such as most of
+the sequence data formats supported in Bio.SeqIO (like FASTA,
+FASTQ, GenBank, etc) or large MAF alignments.
+
+The Bio.SeqIO indexing functions use this module to support BGZF files.
+
+Technical Introduction to BGZF
+------------------------------
+The gzip file format allows multiple compressed blocks, each of which
+could be a stand alone gzip file. As an interesting bonus, this means
+you can use Unix ``cat`` to combine two or more gzip files into one by
+concatenating them. Also, each block can have one of several compression
+levels (including uncompressed, which actually takes up a little bit
+more space due to the gzip header).
+
+What the BAM designers realised was that while random access to data
+stored in traditional gzip files was slow, breaking the file into
+gzip blocks would allow fast random access to each block. To access
+a particular piece of the decompressed data, you just need to know
+which block it starts in (the offset of the gzip block start), and
+how far into the (decompressed) contents of the block you need to
+read.
+
+One problem with this is finding the gzip block sizes efficiently.
+You can do it with a standard gzip file, but it requires every block
+to be decompressed -- and that would be rather slow. Additionally
+typical gzip files may use very large blocks.
+
+All that differs in BGZF is that compressed size of each gzip block
+is limited to 2^16 bytes, and an extra 'BC' field in the gzip header
+records this size. Traditional decompression tools can ignore this,
+and unzip the file just like any other gzip file.
+
+The point of this is you can look at the first BGZF block, find out
+how big it is from this 'BC' header, and thus seek immediately to
+the second block, and so on.
+
+The BAM indexing scheme records read positions using a 64 bit
+'virtual offset', comprising ``coffset << 16 | uoffset``, where ``coffset``
+is the file offset of the BGZF block containing the start of the read
+(unsigned integer using up to 64-16 = 48 bits), and ``uoffset`` is the
+offset within the (decompressed) block (unsigned 16 bit integer).
+
+This limits you to BAM files where the last block starts by 2^48
+bytes, or 256 petabytes, and the decompressed size of each block
+is at most 2^16 bytes, or 64kb. Note that this matches the BGZF
+'BC' field size which limits the compressed size of each block to
+2^16 bytes, allowing for BAM files to use BGZF with no gzip
+compression (useful for intermediate files in memory to reduce
+CPU load).
+
+Warning about namespaces
+------------------------
+It is considered a bad idea to use "from XXX import ``*``" in Python, because
+it pollutes the namespace. This is a real issue with Bio.bgzf (and the
+standard Python library gzip) because they contain a function called open
+i.e. Suppose you do this:
+
+>>> from Bio.bgzf import *
+>>> print(open.__module__)
+Bio.bgzf
+
+Or,
+
+>>> from gzip import *
+>>> print(open.__module__)
+gzip
+
+Notice that the open function has been replaced. You can "fix" this if you
+need to by importing the built-in open function:
+
+>>> from builtins import open
+
+However, what we recommend instead is to use the explicit namespace, e.g.
+
+>>> from Bio import bgzf
+>>> print(bgzf.open.__module__)
+Bio.bgzf
+
+
+Examples
+--------
+This is an ordinary GenBank file compressed using BGZF, so it can
+be decompressed using gzip,
+
+>>> import gzip
+>>> handle = gzip.open("GenBank/NC_000932.gb.bgz", "r")
+>>> assert 0 == handle.tell()
+>>> line = handle.readline()
+>>> assert 80 == handle.tell()
+>>> line = handle.readline()
+>>> assert 143 == handle.tell()
+>>> data = handle.read(70000)
+>>> assert 70143 == handle.tell()
+>>> handle.close()
+
+We can also access the file using the BGZF reader - but pay
+attention to the file offsets which will be explained below:
+
+>>> handle = BgzfReader("GenBank/NC_000932.gb.bgz", "r")
+>>> assert 0 == handle.tell()
+>>> print(handle.readline().rstrip())
+LOCUS       NC_000932             154478 bp    DNA     circular PLN 15-APR-2009
+>>> assert 80 == handle.tell()
+>>> print(handle.readline().rstrip())
+DEFINITION  Arabidopsis thaliana chloroplast, complete genome.
+>>> assert 143 == handle.tell()
+>>> data = handle.read(70000)
+>>> assert 987828735 == handle.tell()
+>>> print(handle.readline().rstrip())
+f="GeneID:844718"
+>>> print(handle.readline().rstrip())
+     CDS             complement(join(84337..84771,85454..85843))
+>>> offset = handle.seek(make_virtual_offset(55074, 126))
+>>> print(handle.readline().rstrip())
+    68521 tatgtcattc gaaattgtat aaagacaact cctatttaat agagctattt gtgcaagtat
+>>> handle.close()
+
+Notice the handle's offset looks different as a BGZF file. This
+brings us to the key point about BGZF, which is the block structure:
+
+>>> handle = open("GenBank/NC_000932.gb.bgz", "rb")
+>>> for values in BgzfBlocks(handle):
+...     print("Raw start %i, raw length %i; data start %i, data length %i" % values)
+Raw start 0, raw length 15073; data start 0, data length 65536
+Raw start 15073, raw length 17857; data start 65536, data length 65536
+Raw start 32930, raw length 22144; data start 131072, data length 65536
+Raw start 55074, raw length 22230; data start 196608, data length 65536
+Raw start 77304, raw length 14939; data start 262144, data length 43478
+Raw start 92243, raw length 28; data start 305622, data length 0
+>>> handle.close()
+
+In this example the first three blocks are 'full' and hold 65536 bytes
+of uncompressed data. The fourth block isn't full and holds 43478 bytes.
+Finally there is a special empty fifth block which takes 28 bytes on
+disk and serves as an 'end of file' (EOF) marker. If this is missing,
+it is possible your BGZF file is incomplete.
+
+By reading ahead 70,000 bytes we moved into the second BGZF block,
+and at that point the BGZF virtual offsets start to look different
+to a simple offset into the decompressed data as exposed by the gzip
+library.
+
+As an example, consider seeking to the decompressed position 196734.
+Since 196734 = 65536 + 65536 + 65536 + 126 = 65536*3 + 126, this
+is equivalent to jumping the first three blocks (which in this
+specific example are all size 65536 after decompression - which
+does not always hold) and starting at byte 126 of the fourth block
+(after decompression). For BGZF, we need to know the fourth block's
+offset of 55074 and the offset within the block of 126 to get the
+BGZF virtual offset.
+
+>>> print(55074 << 16 | 126)
+3609329790
+>>> print(bgzf.make_virtual_offset(55074, 126))
+3609329790
+
+Thus for this BGZF file, decompressed position 196734 corresponds
+to the virtual offset 3609329790. However, another BGZF file with
+different contents would have compressed more or less efficiently,
+so the compressed blocks would be different sizes. What this means
+is the mapping between the uncompressed offset and the compressed
+virtual offset depends on the BGZF file you are using.
+
+If you are accessing a BGZF file via this module, just use the
+handle.tell() method to note the virtual offset of a position you
+may later want to return to using handle.seek().
+
+The catch with BGZF virtual offsets is while they can be compared
+(which offset comes first in the file), you cannot safely subtract
+them to get the size of the data between them, nor add/subtract
+a relative offset.
+
+Of course you can parse this file with Bio.SeqIO using BgzfReader,
+although there isn't any benefit over using gzip.open(...), unless
+you want to index BGZF compressed sequence files:
+
+>>> from Bio import SeqIO
+>>> handle = BgzfReader("GenBank/NC_000932.gb.bgz")
+>>> record = SeqIO.read(handle, "genbank")
+>>> handle.close()
+>>> print(record.id)
+NC_000932.1
+
+Text Mode
+---------
+
+Like the standard library gzip.open(...), the BGZF code defaults to opening
+files in binary mode.
+
+You can request the file be opened in text mode, but beware that this is hard
+coded to the simple "latin1" (aka "iso-8859-1") encoding (which includes all
+the ASCII characters), which works well with most Western European languages.
+However, it is not fully compatible with the more widely used UTF-8 encoding.
+
+In variable width encodings like UTF-8, some single characters in the unicode
+text output are represented by multiple bytes in the raw binary form. This is
+problematic with BGZF, as we cannot always decode each block in isolation - a
+single unicode character could be split over two blocks. This can even happen
+with fixed width unicode encodings, as the BGZF block size is not fixed.
+
+Therefore, this module is currently restricted to only support single byte
+unicode encodings, such as ASCII, "latin1" (which is a superset of ASCII), or
+potentially other character maps (not implemented).
+
+Furthermore, unlike the default text mode on Python 3, we do not attempt to
+implement universal new line mode. This transforms the various operating system
+new line conventions like Windows (CR LF or "\r\n"), Unix (just LF, "\n"), or
+old Macs (just CR, "\r"), into just LF ("\n"). Here we have the same problem -
+is "\r" at the end of a block an incomplete Windows style new line?
+
+Instead, you will get the CR ("\r") and LF ("\n") characters as is.
+
+If your data is in UTF-8 or any other incompatible encoding, you must use
+binary mode, and decode the appropriate fragments yourself.
+"""
+
+import io
+import struct
+import sys
+import zlib
+from builtins import open as _open
+
+_bgzf_magic = b"\x1f\x8b\x08\x04"
+_bgzf_header = b"\x1f\x8b\x08\x04\x00\x00\x00\x00\x00\xff\x06\x00\x42\x43\x02\x00"
+_bgzf_eof = b"\x1f\x8b\x08\x04\x00\x00\x00\x00\x00\xff\x06\x00BC\x02\x00\x1b\x00\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+_bytes_BC = b"BC"
+
+
+def open(filename, mode="rb"):
+    r"""Open a BGZF file for reading, writing or appending.
+
+    If text mode is requested, in order to avoid multi-byte characters, this is
+    hard coded to use the "latin1" encoding, and "\r" and "\n" are passed as is
+    (without implementing universal new line mode).
+
+    If your data is in UTF-8 or any other incompatible encoding, you must use
+    binary mode, and decode the appropriate fragments yourself.
+    """
+    if "r" in mode.lower():
+        return BgzfReader(filename, mode)
+    elif "w" in mode.lower() or "a" in mode.lower():
+        return BgzfWriter(filename, mode)
+    else:
+        raise ValueError(f"Bad mode {mode!r}")
+
+
+def make_virtual_offset(block_start_offset, within_block_offset):
+    """Compute a BGZF virtual offset from block start and within block offsets.
+
+    The BAM indexing scheme records read positions using a 64 bit
+    'virtual offset', comprising in C terms:
+
+    block_start_offset << 16 | within_block_offset
+
+    Here block_start_offset is the file offset of the BGZF block
+    start (unsigned integer using up to 64-16 = 48 bits), and
+    within_block_offset within the (decompressed) block (unsigned
+    16 bit integer).
+
+    >>> make_virtual_offset(0, 0)
+    0
+    >>> make_virtual_offset(0, 1)
+    1
+    >>> make_virtual_offset(0, 2**16 - 1)
+    65535
+    >>> make_virtual_offset(0, 2**16)
+    Traceback (most recent call last):
+    ...
+    ValueError: Require 0 <= within_block_offset < 2**16, got 65536
+
+    >>> 65536 == make_virtual_offset(1, 0)
+    True
+    >>> 65537 == make_virtual_offset(1, 1)
+    True
+    >>> 131071 == make_virtual_offset(1, 2**16 - 1)
+    True
+
+    >>> 6553600000 == make_virtual_offset(100000, 0)
+    True
+    >>> 6553600001 == make_virtual_offset(100000, 1)
+    True
+    >>> 6553600010 == make_virtual_offset(100000, 10)
+    True
+
+    >>> make_virtual_offset(2**48, 0)
+    Traceback (most recent call last):
+    ...
+    ValueError: Require 0 <= block_start_offset < 2**48, got 281474976710656
+
+    """
+    if within_block_offset < 0 or within_block_offset >= 65536:
+        raise ValueError(
+            "Require 0 <= within_block_offset < 2**16, got %i" % within_block_offset
+        )
+    if block_start_offset < 0 or block_start_offset >= 281474976710656:
+        raise ValueError(
+            "Require 0 <= block_start_offset < 2**48, got %i" % block_start_offset
+        )
+    return (block_start_offset << 16) | within_block_offset
+
+
+def split_virtual_offset(virtual_offset):
+    """Divides a 64-bit BGZF virtual offset into block start & within block offsets.
+
+    >>> (100000, 0) == split_virtual_offset(6553600000)
+    True
+    >>> (100000, 10) == split_virtual_offset(6553600010)
+    True
+
+    """
+    start = virtual_offset >> 16
+    return start, virtual_offset ^ (start << 16)
+
+
+def BgzfBlocks(handle):
+    """Low level debugging function to inspect BGZF blocks.
+
+    Expects a BGZF compressed file opened in binary read mode using
+    the builtin open function. Do not use a handle from this bgzf
+    module or the gzip module's open function which will decompress
+    the file.
+
+    Returns the block start offset (see virtual offsets), the block
+    length (add these for the start of the next block), and the
+    decompressed length of the blocks contents (limited to 65536 in
+    BGZF), as an iterator - one tuple per BGZF block.
+
+    >>> from builtins import open
+    >>> handle = open("SamBam/ex1.bam", "rb")
+    >>> for values in BgzfBlocks(handle):
+    ...     print("Raw start %i, raw length %i; data start %i, data length %i" % values)
+    Raw start 0, raw length 18239; data start 0, data length 65536
+    Raw start 18239, raw length 18223; data start 65536, data length 65536
+    Raw start 36462, raw length 18017; data start 131072, data length 65536
+    Raw start 54479, raw length 17342; data start 196608, data length 65536
+    Raw start 71821, raw length 17715; data start 262144, data length 65536
+    Raw start 89536, raw length 17728; data start 327680, data length 65536
+    Raw start 107264, raw length 17292; data start 393216, data length 63398
+    Raw start 124556, raw length 28; data start 456614, data length 0
+    >>> handle.close()
+
+    Indirectly we can tell this file came from an old version of
+    samtools because all the blocks (except the final one and the
+    dummy empty EOF marker block) are 65536 bytes.  Later versions
+    avoid splitting a read between two blocks, and give the header
+    its own block (useful to speed up replacing the header). You
+    can see this in ex1_refresh.bam created using samtools 0.1.18:
+
+    samtools view -b ex1.bam > ex1_refresh.bam
+
+    >>> handle = open("SamBam/ex1_refresh.bam", "rb")
+    >>> for values in BgzfBlocks(handle):
+    ...     print("Raw start %i, raw length %i; data start %i, data length %i" % values)
+    Raw start 0, raw length 53; data start 0, data length 38
+    Raw start 53, raw length 18195; data start 38, data length 65434
+    Raw start 18248, raw length 18190; data start 65472, data length 65409
+    Raw start 36438, raw length 18004; data start 130881, data length 65483
+    Raw start 54442, raw length 17353; data start 196364, data length 65519
+    Raw start 71795, raw length 17708; data start 261883, data length 65411
+    Raw start 89503, raw length 17709; data start 327294, data length 65466
+    Raw start 107212, raw length 17390; data start 392760, data length 63854
+    Raw start 124602, raw length 28; data start 456614, data length 0
+    >>> handle.close()
+
+    The above example has no embedded SAM header (thus the first block
+    is very small at just 38 bytes of decompressed data), while the next
+    example does (a larger block of 103 bytes). Notice that the rest of
+    the blocks show the same sizes (they contain the same read data):
+
+    >>> handle = open("SamBam/ex1_header.bam", "rb")
+    >>> for values in BgzfBlocks(handle):
+    ...     print("Raw start %i, raw length %i; data start %i, data length %i" % values)
+    Raw start 0, raw length 104; data start 0, data length 103
+    Raw start 104, raw length 18195; data start 103, data length 65434
+    Raw start 18299, raw length 18190; data start 65537, data length 65409
+    Raw start 36489, raw length 18004; data start 130946, data length 65483
+    Raw start 54493, raw length 17353; data start 196429, data length 65519
+    Raw start 71846, raw length 17708; data start 261948, data length 65411
+    Raw start 89554, raw length 17709; data start 327359, data length 65466
+    Raw start 107263, raw length 17390; data start 392825, data length 63854
+    Raw start 124653, raw length 28; data start 456679, data length 0
+    >>> handle.close()
+
+    """
+    if isinstance(handle, BgzfReader):
+        raise TypeError("Function BgzfBlocks expects a binary handle")
+    data_start = 0
+    while True:
+        start_offset = handle.tell()
+        try:
+            block_length, data = _load_bgzf_block(handle)
+        except StopIteration:
+            break
+        data_len = len(data)
+        yield start_offset, block_length, data_start, data_len
+        data_start += data_len
+
+
+def _load_bgzf_block(handle, text_mode=False):
+    """Load the next BGZF block of compressed data (PRIVATE).
+
+    Returns a tuple (block size and data), or at end of file
+    will raise StopIteration.
+    """
+    magic = handle.read(4)
+    if not magic:
+        # End of file - should we signal this differently now?
+        # See https://www.python.org/dev/peps/pep-0479/
+        raise StopIteration
+    if magic != _bgzf_magic:
+        raise ValueError(
+            r"A BGZF block should start with %r, not %r; handle.tell() now says %r"
+            % (_bgzf_magic, magic, handle.tell())
+        )
+    gzip_mod_time, gzip_extra_flags, gzip_os, extra_len = struct.unpack(
+        "<LBBH", handle.read(8)
+    )
+
+    block_size = None
+    x_len = 0
+    while x_len < extra_len:
+        subfield_id = handle.read(2)
+        subfield_len = struct.unpack("<H", handle.read(2))[0]  # uint16_t
+        subfield_data = handle.read(subfield_len)
+        x_len += subfield_len + 4
+        if subfield_id == _bytes_BC:
+            if subfield_len != 2:
+                raise ValueError("Wrong BC payload length")
+            if block_size is not None:
+                raise ValueError("Two BC subfields?")
+            block_size = struct.unpack("<H", subfield_data)[0] + 1  # uint16_t
+    if x_len != extra_len:
+        raise ValueError(f"x_len and extra_len differ {x_len}, {extra_len}")
+    if block_size is None:
+        raise ValueError("Missing BC, this isn't a BGZF file!")
+    # Now comes the compressed data, CRC, and length of uncompressed data.
+    deflate_size = block_size - 1 - extra_len - 19
+    d = zlib.decompressobj(-15)  # Negative window size means no headers
+    data = d.decompress(handle.read(deflate_size)) + d.flush()
+    expected_crc = handle.read(4)
+    expected_size = struct.unpack("<I", handle.read(4))[0]
+    if expected_size != len(data):
+        raise RuntimeError("Decompressed to %i, not %i" % (len(data), expected_size))
+    # Should cope with a mix of Python platforms...
+    crc = zlib.crc32(data)
+    if crc < 0:
+        crc = struct.pack("<i", crc)
+    else:
+        crc = struct.pack("<I", crc)
+    if expected_crc != crc:
+        raise RuntimeError(f"CRC is {crc}, not {expected_crc}")
+    if text_mode:
+        # Note ISO-8859-1 aka Latin-1 preserves first 256 chars
+        # (i.e. ASCII), but critically is a single byte encoding
+        return block_size, data.decode("latin-1")
+    else:
+        return block_size, data
+
+
+class BgzfReader:
+    r"""BGZF reader, acts like a read only handle but seek/tell differ.
+
+    Let's use the BgzfBlocks function to have a peek at the BGZF blocks
+    in an example BAM file,
+
+    >>> from builtins import open
+    >>> handle = open("SamBam/ex1.bam", "rb")
+    >>> for values in BgzfBlocks(handle):
+    ...     print("Raw start %i, raw length %i; data start %i, data length %i" % values)
+    Raw start 0, raw length 18239; data start 0, data length 65536
+    Raw start 18239, raw length 18223; data start 65536, data length 65536
+    Raw start 36462, raw length 18017; data start 131072, data length 65536
+    Raw start 54479, raw length 17342; data start 196608, data length 65536
+    Raw start 71821, raw length 17715; data start 262144, data length 65536
+    Raw start 89536, raw length 17728; data start 327680, data length 65536
+    Raw start 107264, raw length 17292; data start 393216, data length 63398
+    Raw start 124556, raw length 28; data start 456614, data length 0
+    >>> handle.close()
+
+    Now let's see how to use this block information to jump to
+    specific parts of the decompressed BAM file:
+
+    >>> handle = BgzfReader("SamBam/ex1.bam", "rb")
+    >>> assert 0 == handle.tell()
+    >>> magic = handle.read(4)
+    >>> assert 4 == handle.tell()
+
+    So far nothing so strange, we got the magic marker used at the
+    start of a decompressed BAM file, and the handle position makes
+    sense. Now however, let's jump to the end of this block and 4
+    bytes into the next block by reading 65536 bytes,
+
+    >>> data = handle.read(65536)
+    >>> len(data)
+    65536
+    >>> assert 1195311108 == handle.tell()
+
+    Expecting 4 + 65536 = 65540 were you? Well this is a BGZF 64-bit
+    virtual offset, which means:
+
+    >>> split_virtual_offset(1195311108)
+    (18239, 4)
+
+    You should spot 18239 as the start of the second BGZF block, while
+    the 4 is the offset into this block. See also make_virtual_offset,
+
+    >>> make_virtual_offset(18239, 4)
+    1195311108
+
+    Let's jump back to almost the start of the file,
+
+    >>> make_virtual_offset(0, 2)
+    2
+    >>> handle.seek(2)
+    2
+    >>> handle.close()
+
+    Note that you can use the max_cache argument to limit the number of
+    BGZF blocks cached in memory. The default is 100, and since each
+    block can be up to 64kb, the default cache could take up to 6MB of
+    RAM. The cache is not important for reading through the file in one
+    pass, but is important for improving performance of random access.
+    """
+
+    def __init__(self, filename=None, mode="r", fileobj=None, max_cache=100):
+        r"""Initialize the class for reading a BGZF file.
+
+        You would typically use the top level ``bgzf.open(...)`` function
+        which will call this class internally. Direct use is discouraged.
+
+        Either the ``filename`` (string) or ``fileobj`` (input file object in
+        binary mode) arguments must be supplied, but not both.
+
+        Argument ``mode`` controls if the data will be returned as strings in
+        text mode ("rt", "tr", or default "r"), or bytes binary mode ("rb"
+        or "br"). The argument name matches the built-in ``open(...)`` and
+        standard library ``gzip.open(...)`` function.
+
+        If text mode is requested, in order to avoid multi-byte characters,
+        this is hard coded to use the "latin1" encoding, and "\r" and "\n"
+        are passed as is (without implementing universal new line mode). There
+        is no ``encoding`` argument.
+
+        If your data is in UTF-8 or any other incompatible encoding, you must
+        use binary mode, and decode the appropriate fragments yourself.
+
+        Argument ``max_cache`` controls the maximum number of BGZF blocks to
+        cache in memory. Each can be up to 64kb thus the default of 100 blocks
+        could take up to 6MB of RAM. This is important for efficient random
+        access, a small value is fine for reading the file in one pass.
+        """
+        # TODO - Assuming we can seek, check for 28 bytes EOF empty block
+        # and if missing warn about possible truncation (as in samtools)?
+        if max_cache < 1:
+            raise ValueError("Use max_cache with a minimum of 1")
+        # Must open the BGZF file in binary mode, but we may want to
+        # treat the contents as either text or binary (unicode or
+        # bytes under Python 3)
+        if filename and fileobj:
+            raise ValueError("Supply either filename or fileobj, not both")
+        # Want to reject output modes like w, a, x, +
+        if mode.lower() not in ("r", "tr", "rt", "rb", "br"):
+            raise ValueError(
+                "Must use a read mode like 'r' (default), 'rt', or 'rb' for binary"
+            )
+        # If an open file was passed, make sure it was opened in binary mode.
+        if fileobj:
+            if fileobj.read(0) != b"":
+                raise ValueError("fileobj not opened in binary mode")
+            handle = fileobj
+        else:
+            handle = _open(filename, "rb")
+        self._text = "b" not in mode.lower()
+        if self._text:
+            self._newline = "\n"
+        else:
+            self._newline = b"\n"
+        self._handle = handle
+        self.max_cache = max_cache
+        self._buffers = {}
+        self._block_start_offset = None
+        self._block_raw_length = None
+        self._load_block(handle.tell())
+
+    def _load_block(self, start_offset=None):
+        if start_offset is None:
+            # If the file is being read sequentially, then _handle.tell()
+            # should be pointing at the start of the next block.
+            # However, if seek has been used, we can't assume that.
+            start_offset = self._block_start_offset + self._block_raw_length
+        if start_offset == self._block_start_offset:
+            self._within_block_offset = 0
+            return
+        elif start_offset in self._buffers:
+            # Already in cache
+            self._buffer, self._block_raw_length = self._buffers[start_offset]
+            self._within_block_offset = 0
+            self._block_start_offset = start_offset
+            return
+        # Must hit the disk... first check cache limits,
+        while len(self._buffers) >= self.max_cache:
+            # TODO - Implement LRU cache removal?
+            self._buffers.popitem()
+        # Now load the block
+        handle = self._handle
+        if start_offset is not None:
+            handle.seek(start_offset)
+        self._block_start_offset = handle.tell()
+        try:
+            block_size, self._buffer = _load_bgzf_block(handle, self._text)
+        except StopIteration:
+            # EOF
+            block_size = 0
+            if self._text:
+                self._buffer = ""
+            else:
+                self._buffer = b""
+        self._within_block_offset = 0
+        self._block_raw_length = block_size
+        # Finally save the block in our cache,
+        self._buffers[self._block_start_offset] = self._buffer, block_size
+
+    def tell(self):
+        """Return a 64-bit unsigned BGZF virtual offset."""
+        if 0 < self._within_block_offset and self._within_block_offset == len(
+            self._buffer
+        ):
+            # Special case where we're right at the end of a (non empty) block.
+            # For non-maximal blocks could give two possible virtual offsets,
+            # but for a maximal block can't use 65536 as the within block
+            # offset. Therefore for consistency, use the next block and a
+            # within block offset of zero.
+            return (self._block_start_offset + self._block_raw_length) << 16
+        else:
+            # return make_virtual_offset(self._block_start_offset,
+            #                           self._within_block_offset)
+            # TODO - Include bounds checking as in make_virtual_offset?
+            return (self._block_start_offset << 16) | self._within_block_offset
+
+    def seek(self, virtual_offset):
+        """Seek to a 64-bit unsigned BGZF virtual offset."""
+        # Do this inline to avoid a function call,
+        # start_offset, within_block = split_virtual_offset(virtual_offset)
+        start_offset = virtual_offset >> 16
+        within_block = virtual_offset ^ (start_offset << 16)
+        if start_offset != self._block_start_offset:
+            # Don't need to load the block if already there
+            # (this avoids a function call since _load_block would do nothing)
+            self._load_block(start_offset)
+            if start_offset != self._block_start_offset:
+                raise ValueError("start_offset not loaded correctly")
+        if within_block > len(self._buffer):
+            if not (within_block == 0 and len(self._buffer) == 0):
+                raise ValueError(
+                    "Within offset %i but block size only %i"
+                    % (within_block, len(self._buffer))
+                )
+        self._within_block_offset = within_block
+        # assert virtual_offset == self.tell(), \
+        #    "Did seek to %i (%i, %i), but tell says %i (%i, %i)" \
+        #    % (virtual_offset, start_offset, within_block,
+        #       self.tell(), self._block_start_offset,
+        #       self._within_block_offset)
+        return virtual_offset
+
+    def read(self, size=-1):
+        """Read method for the BGZF module."""
+        if size < 0:
+            raise NotImplementedError("Don't be greedy, that could be massive!")
+
+        result = "" if self._text else b""
+        while size and self._block_raw_length:
+            if self._within_block_offset + size <= len(self._buffer):
+                # This may leave us right at the end of a block
+                # (lazy loading, don't load the next block unless we have too)
+                data = self._buffer[
+                    self._within_block_offset : self._within_block_offset + size
+                ]
+                self._within_block_offset += size
+                if not data:
+                    raise ValueError("Must be at least 1 byte")
+                result += data
+                break
+            else:
+                data = self._buffer[self._within_block_offset :]
+                size -= len(data)
+                self._load_block()  # will reset offsets
+                result += data
+
+        return result
+
+    def readline(self):
+        """Read a single line for the BGZF file."""
+        result = "" if self._text else b""
+        while self._block_raw_length:
+            i = self._buffer.find(self._newline, self._within_block_offset)
+            # Three cases to consider,
+            if i == -1:
+                # No newline, need to read in more data
+                data = self._buffer[self._within_block_offset :]
+                self._load_block()  # will reset offsets
+                result += data
+            elif i + 1 == len(self._buffer):
+                # Found new line, but right at end of block (SPECIAL)
+                data = self._buffer[self._within_block_offset :]
+                # Must now load the next block to ensure tell() works
+                self._load_block()  # will reset offsets
+                if not data:
+                    raise ValueError("Must be at least 1 byte")
+                result += data
+                break
+            else:
+                # Found new line, not at end of block (easy case, no IO)
+                data = self._buffer[self._within_block_offset : i + 1]
+                self._within_block_offset = i + 1
+                # assert data.endswith(self._newline)
+                result += data
+                break
+
+        return result
+
+    def __next__(self):
+        """Return the next line."""
+        line = self.readline()
+        if not line:
+            raise StopIteration
+        return line
+
+    def __iter__(self):
+        """Iterate over the lines in the BGZF file."""
+        return self
+
+    def close(self):
+        """Close BGZF file."""
+        self._handle.close()
+        self._buffer = None
+        self._block_start_offset = None
+        self._buffers = None
+
+    def seekable(self):
+        """Return True indicating the BGZF supports random access."""
+        return True
+
+    def isatty(self):
+        """Return True if connected to a TTY device."""
+        return False
+
+    def fileno(self):
+        """Return integer file descriptor."""
+        return self._handle.fileno()
+
+    def __enter__(self):
+        """Open a file operable with WITH statement."""
+        return self
+
+    def __exit__(self, type, value, traceback):
+        """Close a file with WITH statement."""
+        self.close()
+
+
+class BgzfWriter:
+    """Define a BGZFWriter object."""
+
+    def __init__(self, filename=None, mode="w", fileobj=None, compresslevel=6):
+        """Initialize the class."""
+        if filename and fileobj:
+            raise ValueError("Supply either filename or fileobj, not both")
+        if fileobj:
+            # If an open file was passed, make sure it was opened in binary mode.
+            # This is a courtesy -- we can't detect mode for all file-like objects.
+            # Notably, `StringIO` does not have a `mode` attribute but plain files *do*.
+            if isinstance(fileobj, io.StringIO) or "b" not in getattr(
+                fileobj, "mode", "wb"
+            ):
+                raise ValueError("fileobj not opened in binary mode")
+            handle = fileobj
+        else:
+            if "w" not in mode.lower() and "a" not in mode.lower():
+                raise ValueError(f"Must use write or append mode, not {mode!r}")
+            if "a" in mode.lower():
+                handle = _open(filename, "ab")
+            else:
+                handle = _open(filename, "wb")
+        self._text = "b" not in mode.lower()
+        self._handle = handle
+        self._buffer = b""
+        self.compresslevel = compresslevel
+
+    def _write_block(self, block):
+        """Write provided data to file as a single BGZF compressed block (PRIVATE)."""
+        # print("Saving %i bytes" % len(block))
+        if len(block) > 65536:
+            raise ValueError(f"{len(block)} Block length > 65536")
+        # Giving a negative window bits means no gzip/zlib headers,
+        # -15 used in samtools
+        c = zlib.compressobj(
+            self.compresslevel, zlib.DEFLATED, -15, zlib.DEF_MEM_LEVEL, 0
+        )
+        compressed = c.compress(block) + c.flush()
+        del c
+        if len(compressed) > 65536:
+            raise RuntimeError(
+                "TODO - Didn't compress enough, try less data in this block"
+            )
+        crc = zlib.crc32(block)
+        # Should cope with a mix of Python platforms...
+        if crc < 0:
+            crc = struct.pack("<i", crc)
+        else:
+            crc = struct.pack("<I", crc)
+        bsize = struct.pack("<H", len(compressed) + 25)  # includes -1
+        crc = struct.pack("<I", zlib.crc32(block) & 0xFFFFFFFF)
+        uncompressed_length = struct.pack("<I", len(block))
+        # Fixed 16 bytes,
+        # gzip magic bytes (4) mod time (4),
+        # gzip flag (1), os (1), extra length which is six (2),
+        # sub field which is BC (2), sub field length of two (2),
+        # Variable data,
+        # 2 bytes: block length as BC sub field (2)
+        # X bytes: the data
+        # 8 bytes: crc (4), uncompressed data length (4)
+        data = _bgzf_header + bsize + compressed + crc + uncompressed_length
+        self._handle.write(data)
+
+    def write(self, data):
+        """Write method for the class."""
+        # TODO - Check bytes vs unicode
+        if isinstance(data, str):
+            # When reading we can't cope with multi-byte characters
+            # being split between BGZF blocks, so we restrict to a
+            # single byte encoding - like ASCII or latin-1.
+            # On output we could probably allow any encoding, as we
+            # don't care about splitting unicode characters between blocks
+            data = data.encode("latin-1")
+        # block_size = 2**16 = 65536
+        data_len = len(data)
+        if len(self._buffer) + data_len < 65536:
+            # print("Cached %r" % data)
+            self._buffer += data
+        else:
+            # print("Got %r, writing out some data..." % data)
+            self._buffer += data
+            while len(self._buffer) >= 65536:
+                self._write_block(self._buffer[:65536])
+                self._buffer = self._buffer[65536:]
+
+    def flush(self):
+        """Flush data explicitally."""
+        while len(self._buffer) >= 65536:
+            self._write_block(self._buffer[:65535])
+            self._buffer = self._buffer[65535:]
+        self._write_block(self._buffer)
+        self._buffer = b""
+        self._handle.flush()
+
+    def close(self):
+        """Flush data, write 28 bytes BGZF EOF marker, and close BGZF file.
+
+        samtools will look for a magic EOF marker, just a 28 byte empty BGZF
+        block, and if it is missing warns the BAM file may be truncated. In
+        addition to samtools writing this block, so too does bgzip - so this
+        implementation does too.
+        """
+        if self._buffer:
+            self.flush()
+        self._handle.write(_bgzf_eof)
+        self._handle.flush()
+        self._handle.close()
+
+    def tell(self):
+        """Return a BGZF 64-bit virtual offset."""
+        return make_virtual_offset(self._handle.tell(), len(self._buffer))
+
+    def seekable(self):
+        """Return True indicating the BGZF supports random access."""
+        # Not seekable, but we do support tell...
+        return False
+
+    def isatty(self):
+        """Return True if connected to a TTY device."""
+        return False
+
+    def fileno(self):
+        """Return integer file descriptor."""
+        return self._handle.fileno()
+
+    def __enter__(self):
+        """Open a file operable with WITH statement."""
+        return self
+
+    def __exit__(self, type, value, traceback):
+        """Close a file with WITH statement."""
+        self.close()
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1:
+        print("Call this with no arguments and pipe uncompressed data in on stdin")
+        print("and it will produce BGZF compressed data on stdout. e.g.")
+        print("")
+        print("./bgzf.py < example.fastq > example.fastq.bgz")
+        print("")
+        print("The extension convention of *.bgz is to distinugish these from *.gz")
+        print("used for standard gzipped files without the block structure of BGZF.")
+        print("You can use the standard gunzip command to decompress BGZF files,")
+        print("if it complains about the extension try something like this:")
+        print("")
+        print("cat example.fastq.bgz | gunzip > example.fastq")
+        print("")
+        print("See also the tool bgzip that comes with samtools")
+        sys.exit(0)
+
+    # Ensure we have binary mode handles
+    # (leave stderr as default text mode)
+    stdin = sys.stdin.buffer
+    stdout = sys.stdout.buffer
+
+    sys.stderr.write("Producing BGZF output from stdin...\n")
+    w = BgzfWriter(fileobj=stdout)
+    while True:
+        data = stdin.read(65536)
+        w.write(data)
+        if not data:
+            break
+    # Doing close will write an empty BGZF block as EOF marker:
+    w.close()
+    sys.stderr.write("BGZF data produced\n")

.venv_haddock/lib/python3.12/site-packages/Bio/cpairwise2module.c

@@ -0,0 +1,479 @@
+/* Copyright 2002 by Jeffrey Chang.
+ * Copyright 2016, 2019 by Markus Piotrowski.
+ * 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.
+ *
+ * cpairwise2module.c
+ * Created 30 Sep 2001
+ *
+ * Optimized C routines that complement pairwise2.py.
+ */
+
+#include "Python.h"
+
+
+#define _PRECISION 1000
+#define rint(x) (int)((x)*_PRECISION+0.5)
+
+/* Functions in this module. */
+
+static double calc_affine_penalty(int length, double open, double extend,
+    int penalize_extend_when_opening)
+{
+    double penalty;
+
+    if(length <= 0)
+        return 0.0;
+    penalty = open + extend * length;
+    if(!penalize_extend_when_opening)
+        penalty -= extend;
+    return penalty;
+}
+
+static double _get_match_score(PyObject *py_sequenceA, PyObject *py_sequenceB,
+                               PyObject *py_match_fn, int i, int j,
+                               char *sequenceA, char *sequenceB,
+                               int use_sequence_cstring,
+                               double match, double mismatch,
+                               int use_match_mismatch_scores)
+{
+    PyObject *py_A=NULL, *py_B=NULL;
+    PyObject *py_arglist=NULL, *py_result=NULL;
+    double score = 0;
+
+    if(use_sequence_cstring && use_match_mismatch_scores) {
+        score = (sequenceA[i] == sequenceB[j]) ? match : mismatch;
+        return score;
+    }
+    /* Calculate the match score. */
+    if(!(py_A = PySequence_GetItem(py_sequenceA, i)))
+        goto _get_match_score_cleanup;
+    if(!(py_B = PySequence_GetItem(py_sequenceB, j)))
+        goto _get_match_score_cleanup;
+    if(!(py_arglist = Py_BuildValue("(OO)", py_A, py_B)))
+        goto _get_match_score_cleanup;
+
+    if(!(py_result = PyObject_CallObject(py_match_fn, py_arglist)))
+        goto _get_match_score_cleanup;
+    score = PyFloat_AsDouble(py_result);
+
+ _get_match_score_cleanup:
+    if(py_A) {
+        Py_DECREF(py_A);
+    }
+    if(py_B) {
+        Py_DECREF(py_B);
+    }
+    if(py_arglist) {
+        Py_DECREF(py_arglist);
+    }
+    if(py_result) {
+        Py_DECREF(py_result);
+    }
+    return score;
+}
+
+#if PY_MAJOR_VERSION >= 3
+static PyObject* _create_bytes_object(PyObject* o)
+{
+    PyObject* b;
+    if (PyBytes_Check(o)) {
+        return o;
+    }
+    if (!PyUnicode_Check(o)) {
+        return NULL;
+    }
+    b = PyUnicode_AsASCIIString(o);
+    if (!b) {
+        PyErr_Clear();
+        return NULL;
+    }
+    return b;
+}
+#endif
+
+/* This function is a more-or-less straightforward port of the
+ * equivalent function in pairwise2. Please see there for algorithm
+ * documentation.
+ */
+static PyObject *cpairwise2__make_score_matrix_fast(PyObject *self,
+                                                    PyObject *args)
+{
+    int i;
+    int row, col;
+    PyObject *py_sequenceA, *py_sequenceB, *py_match_fn;
+#if PY_MAJOR_VERSION >= 3
+    PyObject *py_bytesA, *py_bytesB;
+#endif
+    char *sequenceA=NULL, *sequenceB=NULL;
+    int use_sequence_cstring;
+    double open_A, extend_A, open_B, extend_B;
+    int penalize_extend_when_opening, penalize_end_gaps_A, penalize_end_gaps_B;
+    int align_globally, score_only;
+
+    PyObject *py_match=NULL, *py_mismatch=NULL;
+    double first_A_gap, first_B_gap;
+    double match, mismatch;
+    double score;
+    double best_score = 0;
+    double local_max_score = 0;
+    int use_match_mismatch_scores;
+    int lenA, lenB;
+    double *score_matrix = NULL;
+    unsigned char *trace_matrix = NULL;
+    PyObject *py_score_matrix=NULL, *py_trace_matrix=NULL;
+
+    double *col_cache_score = NULL;
+    PyObject *py_retval = NULL;
+
+    if(!PyArg_ParseTuple(args, "OOOddddi(ii)ii", &py_sequenceA, &py_sequenceB,
+                         &py_match_fn, &open_A, &extend_A, &open_B, &extend_B,
+                         &penalize_extend_when_opening,
+                         &penalize_end_gaps_A, &penalize_end_gaps_B,
+                         &align_globally, &score_only))
+        return NULL;
+    if(!PySequence_Check(py_sequenceA) || !PySequence_Check(py_sequenceB)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "py_sequenceA and py_sequenceB should be sequences.");
+        return NULL;
+    }
+
+    /* Optimize for the common case. Check to see if py_sequenceA and
+       py_sequenceB are strings.  If they are, use the c string
+       representation. */
+#if PY_MAJOR_VERSION < 3
+    use_sequence_cstring = 0;
+    if(PyString_Check(py_sequenceA) && PyString_Check(py_sequenceB)) {
+        sequenceA = PyString_AS_STRING(py_sequenceA);
+        sequenceB = PyString_AS_STRING(py_sequenceB);
+        use_sequence_cstring = 1;
+    }
+#else
+    py_bytesA = _create_bytes_object(py_sequenceA);
+    py_bytesB = _create_bytes_object(py_sequenceB);
+    if (py_bytesA && py_bytesB) {
+        sequenceA = PyBytes_AS_STRING(py_bytesA);
+        sequenceB = PyBytes_AS_STRING(py_bytesB);
+        use_sequence_cstring = 1;
+    }
+    else {
+        Py_XDECREF(py_bytesA);
+        Py_XDECREF(py_bytesB);
+        use_sequence_cstring = 0;
+    }
+#endif
+
+    if(!PyCallable_Check(py_match_fn)) {
+        PyErr_SetString(PyExc_TypeError, "py_match_fn must be callable.");
+        return NULL;
+    }
+    /* Optimize for the common case. Check to see if py_match_fn is
+       an identity_match. If so, pull out the match and mismatch
+       member variables and calculate the scores myself. */
+    match = mismatch = 0;
+    use_match_mismatch_scores = 0;
+    if(!(py_match = PyObject_GetAttrString(py_match_fn, "match")))
+        goto cleanup_after_py_match_fn;
+    match = PyFloat_AsDouble(py_match);
+    if(match==-1.0 && PyErr_Occurred())
+        goto cleanup_after_py_match_fn;
+    if(!(py_mismatch = PyObject_GetAttrString(py_match_fn, "mismatch")))
+        goto cleanup_after_py_match_fn;
+    mismatch = PyFloat_AsDouble(py_mismatch);
+    if(mismatch==-1.0 && PyErr_Occurred())
+        goto cleanup_after_py_match_fn;
+    use_match_mismatch_scores = 1;
+
+ cleanup_after_py_match_fn:
+    if(PyErr_Occurred())
+        PyErr_Clear();
+    if(py_match) {
+        Py_DECREF(py_match);
+    }
+    if(py_mismatch) {
+        Py_DECREF(py_mismatch);
+    }
+    /* Cache some commonly used gap penalties */
+    first_A_gap = calc_affine_penalty(1, open_A, extend_A,
+                                      penalize_extend_when_opening);
+    first_B_gap = calc_affine_penalty(1, open_B, extend_B,
+                                      penalize_extend_when_opening);
+
+    /* Allocate matrices for storing the results and initialize first row and col. */
+    lenA = PySequence_Length(py_sequenceA);
+    lenB = PySequence_Length(py_sequenceB);
+    score_matrix = malloc((lenA+1)*(lenB+1)*sizeof(*score_matrix));
+    if(!score_matrix) {
+        PyErr_SetString(PyExc_MemoryError, "Out of memory");
+        goto _cleanup_make_score_matrix_fast;
+    }
+    for(i=0; i<(lenB+1); i++)
+        score_matrix[i] = 0;
+    for(i=0; i<(lenA+1)*(lenB+1); i += (lenB+1))
+        score_matrix[i] = 0;
+    /* If we only want the score, we don't need the trace matrix. */
+    if (!score_only){
+        trace_matrix = malloc((lenA+1)*(lenB+1)*sizeof(*trace_matrix));
+        if(!trace_matrix) {
+            PyErr_SetString(PyExc_MemoryError, "Out of memory");
+            goto _cleanup_make_score_matrix_fast;
+        }
+        for(i=0; i<(lenB+1); i++)
+            trace_matrix[i] = 0;
+        for(i=0; i<(lenA+1)*(lenB+1); i += (lenB+1))
+            trace_matrix[i] = 0;
+        }
+    else
+        trace_matrix = malloc(1);
+
+    /* Initialize the first row and col of the score matrix. */
+    for(i=0; i<=lenA; i++) {
+        if(penalize_end_gaps_B)
+            score = calc_affine_penalty(i, open_B, extend_B,
+                                        penalize_extend_when_opening);
+        else
+            score = 0;
+        score_matrix[i*(lenB+1)] = score;
+    }
+    for(i=0; i<=lenB; i++) {
+        if(penalize_end_gaps_A)
+            score = calc_affine_penalty(i, open_A, extend_A,
+                                        penalize_extend_when_opening);
+        else
+            score = 0;
+        score_matrix[i] = score;
+    }
+
+    /* Now initialize the col cache. */
+    col_cache_score = malloc((lenB+1)*sizeof(*col_cache_score));
+    memset((void *)col_cache_score, 0, (lenB+1)*sizeof(*col_cache_score));
+    for(i=0; i<=lenB; i++) {
+        col_cache_score[i] = calc_affine_penalty(i, (2*open_B), extend_B,
+                             penalize_extend_when_opening);
+    }
+
+    /* Fill in the score matrix. The row cache is calculated on the fly.*/
+    for(row=1; row<=lenA; row++) {
+        double row_cache_score = calc_affine_penalty(row, (2*open_A), extend_A,
+                                 penalize_extend_when_opening);
+        for(col=1; col<=lenB; col++) {
+            double match_score, nogap_score;
+            double row_open, row_extend, col_open, col_extend;
+            int best_score_rint, row_score_rint, col_score_rint;
+            unsigned char row_trace_score, col_trace_score, trace_score;
+
+            /* Calculate the best score. */
+            match_score = _get_match_score(py_sequenceA, py_sequenceB,
+                                           py_match_fn, row-1, col-1,
+                                           sequenceA, sequenceB,
+                                           use_sequence_cstring,
+                                           match, mismatch,
+                                           use_match_mismatch_scores);
+            if(match_score==-1.0 && PyErr_Occurred())
+                goto _cleanup_make_score_matrix_fast;
+            nogap_score = score_matrix[(row-1)*(lenB+1)+col-1] + match_score;
+
+            if (!penalize_end_gaps_A && row==lenA) {
+                row_open = score_matrix[(row)*(lenB+1)+col-1];
+                row_extend = row_cache_score;
+            }
+            else {
+                row_open = score_matrix[(row)*(lenB+1)+col-1] + first_A_gap;
+                row_extend = row_cache_score + extend_A;
+            }
+            row_cache_score = (row_open > row_extend) ? row_open : row_extend;
+
+            if (!penalize_end_gaps_B && col==lenB){
+                col_open = score_matrix[(row-1)*(lenB+1)+col];
+                col_extend = col_cache_score[col];
+            }
+            else {
+                col_open = score_matrix[(row-1)*(lenB+1)+col] + first_B_gap;
+                col_extend = col_cache_score[col] + extend_B;
+            }
+            col_cache_score[col] = (col_open > col_extend) ? col_open : col_extend;
+
+            best_score = (row_cache_score > col_cache_score[col]) ? row_cache_score : col_cache_score[col];
+            if(nogap_score > best_score)
+                best_score = nogap_score;
+
+            if (best_score > local_max_score)
+                local_max_score = best_score;
+
+            if(!align_globally && best_score < 0)
+                score_matrix[row*(lenB+1)+col] = 0;
+            else
+                score_matrix[row*(lenB+1)+col] = best_score;
+
+            if (!score_only) {
+                row_score_rint = rint(row_cache_score);
+                col_score_rint = rint(col_cache_score[col]);
+                row_trace_score = 0;
+                col_trace_score = 0;
+                if (rint(row_open) == row_score_rint)
+                    row_trace_score = row_trace_score|1;
+                if (rint(row_extend) == row_score_rint)
+                    row_trace_score = row_trace_score|8;
+                if (rint(col_open) == col_score_rint)
+                    col_trace_score = col_trace_score|4;
+                if (rint(col_extend) == col_score_rint)
+                    col_trace_score = col_trace_score|16;
+
+                trace_score = 0;
+                best_score_rint = rint(best_score);
+                if (rint(nogap_score) == best_score_rint)
+                    trace_score = trace_score|2;
+                if (row_score_rint == best_score_rint)
+                    trace_score += row_trace_score;
+                if (col_score_rint == best_score_rint)
+                    trace_score += col_trace_score;
+                trace_matrix[row*(lenB+1)+col] = trace_score;
+            }
+        }
+    }
+
+    if (!align_globally)
+        best_score = local_max_score;
+
+    /* Save the score and traceback matrices into real python objects. */
+    if(!score_only) {
+            if(!(py_score_matrix = PyList_New(lenA+1)))
+                    goto _cleanup_make_score_matrix_fast;
+            if(!(py_trace_matrix = PyList_New(lenA+1)))
+                    goto _cleanup_make_score_matrix_fast;
+
+            for(row=0; row<=lenA; row++) {
+                    PyObject *py_score_row, *py_trace_row;
+                    if(!(py_score_row = PyList_New(lenB+1)))
+                            goto _cleanup_make_score_matrix_fast;
+                    PyList_SET_ITEM(py_score_matrix, row, py_score_row);
+                    if(!(py_trace_row = PyList_New(lenB+1)))
+                            goto _cleanup_make_score_matrix_fast;
+                    PyList_SET_ITEM(py_trace_matrix, row, py_trace_row);
+
+                    for(col=0; col<=lenB; col++) {
+                            PyObject *py_score, *py_trace;
+                            int offset = row*(lenB+1) + col;
+
+                            /* Set py_score_matrix[row][col] to the score. */
+                            if(!(py_score = PyFloat_FromDouble(score_matrix[offset])))
+                                    goto _cleanup_make_score_matrix_fast;
+                            PyList_SET_ITEM(py_score_row, col, py_score);
+
+                            /* Set py_trace_matrix[row][col] to a list of indexes.  On
+                               the edges of the matrix (row or column is 0), the
+                               matrix should be [None]. */
+                            if(!row || !col) {
+                                    if(!(py_trace = Py_BuildValue("B", 1)))
+                                            goto _cleanup_make_score_matrix_fast;
+                                    Py_INCREF(Py_None);
+                                    PyList_SET_ITEM(py_trace_row, col, Py_None);
+                            }
+                            else {
+                                    if(!(py_trace = Py_BuildValue("B", trace_matrix[offset])))
+                                            goto _cleanup_make_score_matrix_fast;
+                                    PyList_SET_ITEM(py_trace_row, col, py_trace);
+
+                            }
+                    }
+            }
+    }
+    else {
+            py_score_matrix = PyList_New(1);
+            py_trace_matrix = PyList_New(1);
+    }
+    py_retval = Py_BuildValue("(OOd)", py_score_matrix, py_trace_matrix, best_score);
+
+ _cleanup_make_score_matrix_fast:
+    if(score_matrix)
+        free(score_matrix);
+    if(trace_matrix)
+        free(trace_matrix);
+    if(col_cache_score)
+        free(col_cache_score);
+    if(py_score_matrix){
+        Py_DECREF(py_score_matrix);
+    }
+    if(py_trace_matrix){
+        Py_DECREF(py_trace_matrix);
+    }
+
+#if PY_MAJOR_VERSION >= 3
+    if (py_bytesA != NULL && py_bytesA != py_sequenceA) Py_DECREF(py_bytesA);
+    if (py_bytesB != NULL && py_bytesB != py_sequenceB) Py_DECREF(py_bytesB);
+#endif
+
+    return py_retval;
+}
+
+static PyObject *cpairwise2_rint(PyObject *self, PyObject *args,
+                                 PyObject *keywds)
+{
+    double x;
+    int precision = _PRECISION;
+    int rint_x;
+
+    static char *kwlist[] = {"x", "precision", NULL};
+
+    if(!PyArg_ParseTupleAndKeywords(args, keywds, "d|l", kwlist,
+                                    &x, &precision))
+        return NULL;
+    rint_x = (int)(x * precision + 0.5);
+#if PY_MAJOR_VERSION >= 3
+    return PyLong_FromLong((long)rint_x);
+#else
+    return PyInt_FromLong((long)rint_x);
+#endif
+}
+
+/* Module definition stuff */
+
+static PyMethodDef cpairwise2Methods[] = {
+    {"_make_score_matrix_fast",
+     (PyCFunction)cpairwise2__make_score_matrix_fast, METH_VARARGS, ""},
+    {"rint", (PyCFunction)cpairwise2_rint, METH_VARARGS|METH_KEYWORDS, ""},
+    {NULL, NULL, 0, NULL}
+};
+
+static char cpairwise2__doc__[] =
+"Optimized C routines that complement pairwise2.py. These are called from within pairwise2.py.\n\
+\n\
+";
+
+#if PY_MAJOR_VERSION >= 3
+
+static struct PyModuleDef moduledef = {
+        PyModuleDef_HEAD_INIT,
+        "cpairwise2",
+        cpairwise2__doc__,
+        -1,
+        cpairwise2Methods,
+        NULL,
+        NULL,
+        NULL,
+        NULL
+};
+
+PyObject *
+PyInit_cpairwise2(void)
+
+#else
+
+void
+/* for Windows: _declspec(dllexport) initcpairwise2(void) */
+initcpairwise2(void)
+#endif
+
+{
+#if PY_MAJOR_VERSION >= 3
+    PyObject* module = PyModule_Create(&moduledef);
+    if (module==NULL) return NULL;
+    return module;
+#else
+    (void) Py_InitModule3("cpairwise2", cpairwise2Methods, cpairwise2__doc__);
+#endif
+}

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

@@ -0,0 +1,1441 @@
+# Copyright 2002 by Jeffrey Chang.
+# Copyright 2016, 2019, 2020 by Markus Piotrowski.
+# 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.
+
+"""Pairwise sequence alignment using a dynamic programming algorithm.
+
+This provides functions to get global and local alignments between two
+sequences. A global alignment finds the best concordance between all
+characters in two sequences. A local alignment finds just the
+subsequences that align the best. Local alignments must have a positive
+score to be reported and they will not be extended for 'zero counting'
+matches. This means a local alignment will always start and end with
+a positive counting match.
+
+When doing alignments, you can specify the match score and gap
+penalties.  The match score indicates the compatibility between an
+alignment of two characters in the sequences. Highly compatible
+characters should be given positive scores, and incompatible ones
+should be given negative scores or 0.  The gap penalties should be
+negative.
+
+The names of the alignment functions in this module follow the
+convention
+<alignment type>XX
+where <alignment type> is either "global" or "local" and XX is a 2
+character code indicating the parameters it takes.  The first
+character indicates the parameters for matches (and mismatches), and
+the second indicates the parameters for gap penalties.
+
+The match parameters are::
+
+    CODE  DESCRIPTION & OPTIONAL KEYWORDS
+    x     No parameters. Identical characters have score of 1, otherwise 0.
+    m     A match score is the score of identical chars, otherwise mismatch
+          score. Keywords ``match``, ``mismatch``.
+    d     A dictionary returns the score of any pair of characters.
+          Keyword ``match_dict``.
+    c     A callback function returns scores. Keyword ``match_fn``.
+
+The gap penalty parameters are::
+
+    CODE  DESCRIPTION & OPTIONAL KEYWORDS
+    x     No gap penalties.
+    s     Same open and extend gap penalties for both sequences.
+          Keywords ``open``, ``extend``.
+    d     The sequences have different open and extend gap penalties.
+          Keywords ``openA``, ``extendA``, ``openB``, ``extendB``.
+    c     A callback function returns the gap penalties.
+          Keywords ``gap_A_fn``, ``gap_B_fn``.
+
+All the different alignment functions are contained in an object
+``align``. For example:
+
+    >>> from Bio import pairwise2
+    >>> alignments = pairwise2.align.globalxx("ACCGT", "ACG")
+
+For better readability, the required arguments can be used with optional keywords:
+
+    >>> alignments = pairwise2.align.globalxx(sequenceA="ACCGT", sequenceB="ACG")
+
+The result is a list of the alignments between the two strings. Each alignment
+is a named tuple consisting of the two aligned sequences, the score and the
+start and end positions of the alignment:
+
+   >>> print(alignments)
+   [Alignment(seqA='ACCGT', seqB='A-CG-', score=3.0, start=0, end=5), ...
+
+You can access each element of an alignment by index or name:
+
+   >>> alignments[0][2]
+   3.0
+   >>> alignments[0].score
+   3.0
+
+For a nice printout of an alignment, use the ``format_alignment`` method of
+the module:
+
+    >>> from Bio.pairwise2 import format_alignment
+    >>> print(format_alignment(*alignments[0]))
+    ACCGT
+    | || 
+    A-CG-
+      Score=3
+    <BLANKLINE>
+
+All alignment functions have the following arguments:
+
+- Two sequences: strings, Biopython sequence objects or lists.
+  Lists are useful for supplying sequences which contain residues that are
+  encoded by more than one letter.
+
+- ``penalize_extend_when_opening``: boolean (default: False).
+  Whether to count an extension penalty when opening a gap. If false, a gap of
+  1 is only penalized an "open" penalty, otherwise it is penalized
+  "open+extend".
+
+- ``penalize_end_gaps``: boolean.
+  Whether to count the gaps at the ends of an alignment. By default, they are
+  counted for global alignments but not for local ones. Setting
+  ``penalize_end_gaps`` to (boolean, boolean) allows you to specify for the
+  two sequences separately whether gaps at the end of the alignment should be
+  counted.
+
+- ``gap_char``: string (default: ``'-'``).
+  Which character to use as a gap character in the alignment returned. If your
+  input sequences are lists, you must change this to ``['-']``.
+
+- ``force_generic``: boolean (default: False).
+  Always use the generic, non-cached, dynamic programming function (slow!).
+  For debugging.
+
+- ``score_only``: boolean (default: False).
+  Only get the best score, don't recover any alignments. The return value of
+  the function is the score. Faster and uses less memory.
+
+- ``one_alignment_only``: boolean (default: False).
+  Only recover one alignment.
+
+The other parameters of the alignment function depend on the function called.
+Some examples:
+
+- Find the best global alignment between the two sequences. Identical
+  characters are given 1 point. No points are deducted for mismatches or gaps.
+
+    >>> for a in pairwise2.align.globalxx("ACCGT", "ACG"):
+    ...     print(format_alignment(*a))
+    ACCGT
+    | || 
+    A-CG-
+      Score=3
+    <BLANKLINE>
+    ACCGT
+    || | 
+    AC-G-
+      Score=3
+    <BLANKLINE>
+
+- Same thing as before, but with a local alignment. Note that
+  ``format_alignment`` will only show the aligned parts of the sequences,
+  together with the starting positions.
+
+    >>> for a in pairwise2.align.localxx("ACCGT", "ACG"):
+    ...     print(format_alignment(*a))
+    1 ACCG
+      | ||
+    1 A-CG
+      Score=3
+    <BLANKLINE>
+    1 ACCG
+      || |
+    1 AC-G
+      Score=3
+    <BLANKLINE>
+
+  To restore the 'historic' behaviour of ``format_alignemt``, i.e., showing
+  also the un-aligned parts of both sequences, use the new keyword parameter
+  ``full_sequences``:
+
+    >>> for a in pairwise2.align.localxx("ACCGT", "ACG"):
+    ...     print(format_alignment(*a, full_sequences=True))
+    ACCGT
+    | || 
+    A-CG-
+      Score=3
+    <BLANKLINE>
+    ACCGT
+    || | 
+    AC-G-
+      Score=3
+    <BLANKLINE>
+
+
+- Do a global alignment. Identical characters are given 2 points, 1 point is
+  deducted for each non-identical character. Don't penalize gaps.
+
+    >>> for a in pairwise2.align.globalmx("ACCGT", "ACG", 2, -1):
+    ...     print(format_alignment(*a))
+    ACCGT
+    | || 
+    A-CG-
+      Score=6
+    <BLANKLINE>
+    ACCGT
+    || | 
+    AC-G-
+      Score=6
+    <BLANKLINE>
+
+- Same as above, except now 0.5 points are deducted when opening a gap, and
+  0.1 points are deducted when extending it.
+
+    >>> for a in pairwise2.align.globalms("ACCGT", "ACG", 2, -1, -.5, -.1):
+    ...     print(format_alignment(*a))
+    ACCGT
+    | || 
+    A-CG-
+      Score=5
+    <BLANKLINE>
+    ACCGT
+    || | 
+    AC-G-
+      Score=5
+    <BLANKLINE>
+
+- Note that you can use keywords to increase the readability, e.g.:
+
+    >>> a = pairwise2.align.globalms("ACGT", "ACG", match=2, mismatch=-1, open=-.5,
+    ...                              extend=-.1)
+
+- Depending on the penalties, a gap in one sequence may be followed by a gap in
+  the other sequence.If you don't like this behaviour, increase the gap-open
+  penalty:
+
+    >>> for a in pairwise2.align.globalms("A", "T", 5, -4, -1, -.1):
+    ...     print(format_alignment(*a))
+    A-
+    <BLANKLINE>
+    -T
+      Score=-2
+    <BLANKLINE>
+    >>> for a in pairwise2.align.globalms("A", "T", 5, -4, -3, -.1):
+    ...	    print(format_alignment(*a))
+    A
+    .
+    T
+      Score=-4
+    <BLANKLINE>
+
+- The alignment function can also use known matrices already included in
+  Biopython (in ``Bio.Align.substitution_matrices``):
+
+    >>> from Bio.Align import substitution_matrices
+    >>> matrix = substitution_matrices.load("BLOSUM62")
+    >>> for a in pairwise2.align.globaldx("KEVLA", "EVL", matrix):
+    ...     print(format_alignment(*a))
+    KEVLA
+     ||| 
+    -EVL-
+      Score=13
+    <BLANKLINE>
+
+- With the parameter ``c`` you can define your own match- and gap functions.
+  E.g. to define an affine logarithmic gap function and using it:
+
+    >>> from math import log
+    >>> def gap_function(x, y):  # x is gap position in seq, y is gap length
+    ...     if y == 0:  # No gap
+    ...         return 0
+    ...     elif y == 1:  # Gap open penalty
+    ...         return -2
+    ...     return - (2 + y/4.0 + log(y)/2.0)
+    ...
+    >>> alignment = pairwise2.align.globalmc("ACCCCCGT", "ACG", 5, -4,
+    ...                                      gap_function, gap_function)
+
+  You can define different gap functions for each sequence.
+  Self-defined match functions must take the two residues to be compared and
+  return a score.
+
+To see a description of the parameters for a function, please look at
+the docstring for the function via the help function, e.g.
+type ``help(pairwise2.align.localds)`` at the Python prompt.
+
+"""  # noqa: W291
+
+import warnings
+from collections import namedtuple
+
+from Bio import BiopythonDeprecationWarning
+from Bio import BiopythonWarning
+from Bio.Align import substitution_matrices
+
+warnings.warn(
+    "Bio.pairwise2 has been deprecated, and we intend to remove it in a "
+    "future release of Biopython. As an alternative, please consider using "
+    "Bio.Align.PairwiseAligner as a replacement, and contact the "
+    "Biopython developers if you still need the Bio.pairwise2 module.",
+    BiopythonDeprecationWarning,
+)
+
+
+MAX_ALIGNMENTS = 1000  # maximum alignments recovered in traceback
+
+Alignment = namedtuple("Alignment", ("seqA, seqB, score, start, end"))
+
+
+class align:
+    """Provide functions that do alignments.
+
+    Alignment functions are called as:
+
+      pairwise2.align.globalXX
+
+    or
+
+      pairwise2.align.localXX
+
+    Where XX is a 2 character code indicating the match/mismatch parameters
+    (first character, either x, m, d or c) and the gap penalty parameters
+    (second character, either x, s, d, or c).
+
+    For a detailed description read the main module's docstring (e.g.,
+    type ``help(pairwise2)``).
+    To see a description of the parameters for a function, please
+    look at the docstring for the function, e.g. type
+    ``help(pairwise2.align.localds)`` at the Python prompt.
+    """
+
+    class alignment_function:
+        """Callable class which impersonates an alignment function.
+
+        The constructor takes the name of the function.  This class
+        will decode the name of the function to figure out how to
+        interpret the parameters.
+        """
+
+        # match code -> tuple of (parameters, docstring)
+        match2args = {
+            "x": ([], ""),
+            "m": (
+                ["match", "mismatch"],
+                "match is the score to given to identical characters.\n"
+                "mismatch is the score given to non-identical ones.",
+            ),
+            "d": (
+                ["match_dict"],
+                "match_dict is a dictionary where the keys are tuples\n"
+                "of pairs of characters and the values are the scores,\n"
+                "e.g. ('A', 'C') : 2.5.",
+            ),
+            "c": (
+                ["match_fn"],
+                "match_fn is a callback function that takes two "
+                "characters and returns the score between them.",
+            ),
+        }
+        # penalty code -> tuple of (parameters, docstring)
+        penalty2args = {
+            "x": ([], ""),
+            "s": (
+                ["open", "extend"],
+                "open and extend are the gap penalties when a gap is\n"
+                "opened and extended.  They should be negative.",
+            ),
+            "d": (
+                ["openA", "extendA", "openB", "extendB"],
+                "openA and extendA are the gap penalties for sequenceA,\n"
+                "and openB and extendB for sequenceB.  The penalties\n"
+                "should be negative.",
+            ),
+            "c": (
+                ["gap_A_fn", "gap_B_fn"],
+                "gap_A_fn and gap_B_fn are callback functions that takes\n"
+                "(1) the index where the gap is opened, and (2) the length\n"
+                "of the gap.  They should return a gap penalty.",
+            ),
+        }
+
+        def __init__(self, name):
+            """Check to make sure the name of the function is reasonable."""
+            if name.startswith("global"):
+                if len(name) != 8:
+                    raise AttributeError("function should be globalXX")
+            elif name.startswith("local"):
+                if len(name) != 7:
+                    raise AttributeError("function should be localXX")
+            else:
+                raise AttributeError(name)
+            align_type, match_type, penalty_type = name[:-2], name[-2], name[-1]
+            try:
+                match_args, match_doc = self.match2args[match_type]
+            except KeyError:
+                raise AttributeError(f"unknown match type {match_type!r}")
+            try:
+                penalty_args, penalty_doc = self.penalty2args[penalty_type]
+            except KeyError:
+                raise AttributeError(f"unknown penalty type {penalty_type!r}")
+
+            # Now get the names of the parameters to this function.
+            param_names = ["sequenceA", "sequenceB"]
+            param_names.extend(match_args)
+            param_names.extend(penalty_args)
+            self.function_name = name
+            self.align_type = align_type
+            self.param_names = param_names
+
+            self.__name__ = self.function_name
+            # Set the doc string.
+            doc = f"{self.__name__}({', '.join(self.param_names)}) -> alignments\n"
+            doc += """\
+\nThe following parameters can also be used with optional
+keywords of the same name.\n\n
+sequenceA and sequenceB must be of the same type, either
+strings, lists or Biopython sequence objects.\n
+"""
+            if match_doc:
+                doc += f"\n{match_doc}\n"
+            if penalty_doc:
+                doc += f"\n{penalty_doc}\n"
+            doc += """\
+\nalignments is a list of named tuples (seqA, seqB, score,
+begin, end). seqA and seqB are strings showing the alignment
+between the sequences.  score is the score of the alignment.
+begin and end are indexes of seqA and seqB that indicate
+where the alignment occurs.
+"""
+            self.__doc__ = doc
+
+        def decode(self, *args, **keywds):
+            """Decode the arguments for the _align function.
+
+            keywds will get passed to it, so translate the arguments
+            to this function into forms appropriate for _align.
+            """
+            keywds = keywds.copy()
+
+            # Replace possible "keywords" with arguments:
+            args += (len(self.param_names) - len(args)) * (None,)
+            for key in keywds.copy():
+                if key in self.param_names:
+                    _index = self.param_names.index(key)
+                    args = args[:_index] + (keywds[key],) + args[_index:]
+                    del keywds[key]
+            args = tuple(arg for arg in args if arg is not None)
+
+            if len(args) != len(self.param_names):
+                raise TypeError(
+                    "%s takes exactly %d argument (%d given)"
+                    % (self.function_name, len(self.param_names), len(args))
+                )
+
+            i = 0
+            while i < len(self.param_names):
+                if self.param_names[i] in [
+                    "sequenceA",
+                    "sequenceB",
+                    "gap_A_fn",
+                    "gap_B_fn",
+                    "match_fn",
+                ]:
+                    keywds[self.param_names[i]] = args[i]
+                    i += 1
+                elif self.param_names[i] == "match":
+                    assert self.param_names[i + 1] == "mismatch"
+                    match, mismatch = args[i], args[i + 1]
+                    keywds["match_fn"] = identity_match(match, mismatch)
+                    i += 2
+                elif self.param_names[i] == "match_dict":
+                    keywds["match_fn"] = dictionary_match(args[i])
+                    i += 1
+                elif self.param_names[i] == "open":
+                    assert self.param_names[i + 1] == "extend"
+                    open, extend = args[i], args[i + 1]
+                    pe = keywds.get("penalize_extend_when_opening", 0)
+                    keywds["gap_A_fn"] = affine_penalty(open, extend, pe)
+                    keywds["gap_B_fn"] = affine_penalty(open, extend, pe)
+                    i += 2
+                elif self.param_names[i] == "openA":
+                    assert self.param_names[i + 3] == "extendB"
+                    openA, extendA, openB, extendB = args[i : i + 4]
+                    pe = keywds.get("penalize_extend_when_opening", 0)
+                    keywds["gap_A_fn"] = affine_penalty(openA, extendA, pe)
+                    keywds["gap_B_fn"] = affine_penalty(openB, extendB, pe)
+                    i += 4
+                else:
+                    raise ValueError(f"unknown parameter {self.param_names[i]!r}")
+
+            # Here are the default parameters for _align.  Assign
+            # these to keywds, unless already specified.
+            pe = keywds.get("penalize_extend_when_opening", 0)
+            default_params = [
+                ("match_fn", identity_match(1, 0)),
+                ("gap_A_fn", affine_penalty(0, 0, pe)),
+                ("gap_B_fn", affine_penalty(0, 0, pe)),
+                ("penalize_extend_when_opening", 0),
+                ("penalize_end_gaps", self.align_type == "global"),
+                ("align_globally", self.align_type == "global"),
+                ("gap_char", "-"),
+                ("force_generic", 0),
+                ("score_only", 0),
+                ("one_alignment_only", 0),
+            ]
+            for name, default in default_params:
+                keywds[name] = keywds.get(name, default)
+            value = keywds["penalize_end_gaps"]
+            try:
+                n = len(value)
+            except TypeError:
+                keywds["penalize_end_gaps"] = tuple([value] * 2)
+            else:
+                assert n == 2
+            return keywds
+
+        def __call__(self, *args, **keywds):
+            """Call the alignment instance already created."""
+            keywds = self.decode(*args, **keywds)
+            return _align(**keywds)
+
+    def __getattr__(self, attr):
+        """Call alignment_function() to check and decode the attributes."""
+        # The following 'magic' is needed to rewrite the class docstring
+        # dynamically:
+        wrapper = self.alignment_function(attr)
+        wrapper_type = type(wrapper)
+        wrapper_dict = wrapper_type.__dict__.copy()
+        wrapper_dict["__doc__"] = wrapper.__doc__
+        new_alignment_function = type("alignment_function", (object,), wrapper_dict)
+
+        return new_alignment_function(attr)
+
+
+align = align()
+
+
+def _align(
+    sequenceA,
+    sequenceB,
+    match_fn,
+    gap_A_fn,
+    gap_B_fn,
+    penalize_extend_when_opening,
+    penalize_end_gaps,
+    align_globally,
+    gap_char,
+    force_generic,
+    score_only,
+    one_alignment_only,
+):
+    """Return optimal alignments between two sequences (PRIVATE).
+
+    This method either returns a list of optimal alignments (with the same
+    score) or just the optimal score.
+    """
+    if not sequenceA or not sequenceB:
+        return []
+    try:
+        sequenceA + gap_char
+        sequenceB + gap_char
+    except TypeError:
+        raise TypeError(
+            "both sequences must be of the same type, either "
+            "string/sequence object or list. Gap character must "
+            "fit the sequence type (string or list)"
+        )
+
+    if not isinstance(sequenceA, list):
+        sequenceA = str(sequenceA)
+    if not isinstance(sequenceB, list):
+        sequenceB = str(sequenceB)
+    if not align_globally and (penalize_end_gaps[0] or penalize_end_gaps[1]):
+        warnings.warn(
+            '"penalize_end_gaps" should not be used in local '
+            "alignments. The resulting score may be wrong.",
+            BiopythonWarning,
+        )
+
+    if (
+        (not force_generic)
+        and isinstance(gap_A_fn, affine_penalty)
+        and isinstance(gap_B_fn, affine_penalty)
+    ):
+        open_A, extend_A = gap_A_fn.open, gap_A_fn.extend
+        open_B, extend_B = gap_B_fn.open, gap_B_fn.extend
+        matrices = _make_score_matrix_fast(
+            sequenceA,
+            sequenceB,
+            match_fn,
+            open_A,
+            extend_A,
+            open_B,
+            extend_B,
+            penalize_extend_when_opening,
+            penalize_end_gaps,
+            align_globally,
+            score_only,
+        )
+    else:
+        matrices = _make_score_matrix_generic(
+            sequenceA,
+            sequenceB,
+            match_fn,
+            gap_A_fn,
+            gap_B_fn,
+            penalize_end_gaps,
+            align_globally,
+            score_only,
+        )
+
+    score_matrix, trace_matrix, best_score = matrices
+
+    # print("SCORE %s" % print_matrix(score_matrix))
+    # print("TRACEBACK %s" % print_matrix(trace_matrix))
+
+    # If they only want the score, then return it.
+    if score_only:
+        return best_score
+
+    starts = _find_start(score_matrix, best_score, align_globally)
+
+    # Recover the alignments and return them.
+    alignments = _recover_alignments(
+        sequenceA,
+        sequenceB,
+        starts,
+        best_score,
+        score_matrix,
+        trace_matrix,
+        align_globally,
+        gap_char,
+        one_alignment_only,
+        gap_A_fn,
+        gap_B_fn,
+    )
+    if not alignments:
+        # This may happen, see recover_alignments for explanation
+        score_matrix, trace_matrix = _reverse_matrices(score_matrix, trace_matrix)
+        starts = [(z, (y, x)) for z, (x, y) in starts]
+        alignments = _recover_alignments(
+            sequenceB,
+            sequenceA,
+            starts,
+            best_score,
+            score_matrix,
+            trace_matrix,
+            align_globally,
+            gap_char,
+            one_alignment_only,
+            gap_B_fn,
+            gap_A_fn,
+            reverse=True,
+        )
+    return alignments
+
+
+def _make_score_matrix_generic(
+    sequenceA,
+    sequenceB,
+    match_fn,
+    gap_A_fn,
+    gap_B_fn,
+    penalize_end_gaps,
+    align_globally,
+    score_only,
+):
+    """Generate a score and traceback matrix (PRIVATE).
+
+    This implementation according to Needleman-Wunsch allows the usage of
+    general gap functions and is rather slow. It is automatically called if
+    you define your own gap functions. You can force the usage of this method
+    with ``force_generic=True``.
+    """
+    local_max_score = 0
+    # Create the score and traceback matrices. These should be in the
+    # shape:
+    # sequenceA (down) x sequenceB (across)
+    lenA, lenB = len(sequenceA), len(sequenceB)
+    score_matrix, trace_matrix = [], []
+    for i in range(lenA + 1):
+        score_matrix.append([None] * (lenB + 1))
+        if not score_only:
+            trace_matrix.append([None] * (lenB + 1))
+
+    # Initialize first row and column with gap scores. This is like opening up
+    # i gaps at the beginning of sequence A or B.
+    for i in range(lenA + 1):
+        if penalize_end_gaps[1]:  # [1]:gap in sequence B
+            score = gap_B_fn(0, i)
+        else:
+            score = 0.0
+        score_matrix[i][0] = score
+    for i in range(lenB + 1):
+        if penalize_end_gaps[0]:  # [0]:gap in sequence A
+            score = gap_A_fn(0, i)
+        else:
+            score = 0.0
+        score_matrix[0][i] = score
+
+    # Fill in the score matrix.  Each position in the matrix
+    # represents an alignment between a character from sequence A to
+    # one in sequence B.  As I iterate through the matrix, find the
+    # alignment by choose the best of:
+    #    1) extending a previous alignment without gaps
+    #    2) adding a gap in sequenceA
+    #    3) adding a gap in sequenceB
+    for row in range(1, lenA + 1):
+        for col in range(1, lenB + 1):
+            # First, calculate the score that would occur by extending
+            # the alignment without gaps.
+            # fmt: off
+            nogap_score = (
+                score_matrix[row - 1][col - 1]
+                + match_fn(sequenceA[row - 1], sequenceB[col - 1])
+            )
+
+            # fmt: on
+            # Try to find a better score by opening gaps in sequenceA.
+            # Do this by checking alignments from each column in the row.
+            # Each column represents a different character to align from,
+            # and thus a different length gap.
+            # Although the gap function does not distinguish between opening
+            # and extending a gap, we distinguish them for the backtrace.
+            if not penalize_end_gaps[0] and row == lenA:
+                row_open = score_matrix[row][col - 1]
+                row_extend = max(score_matrix[row][x] for x in range(col))
+            else:
+                row_open = score_matrix[row][col - 1] + gap_A_fn(row, 1)
+                row_extend = max(
+                    score_matrix[row][x] + gap_A_fn(row, col - x) for x in range(col)
+                )
+
+            # Try to find a better score by opening gaps in sequenceB.
+            if not penalize_end_gaps[1] and col == lenB:
+                col_open = score_matrix[row - 1][col]
+                col_extend = max(score_matrix[x][col] for x in range(row))
+            else:
+                col_open = score_matrix[row - 1][col] + gap_B_fn(col, 1)
+                col_extend = max(
+                    score_matrix[x][col] + gap_B_fn(col, row - x) for x in range(row)
+                )
+
+            best_score = max(nogap_score, row_open, row_extend, col_open, col_extend)
+            local_max_score = max(local_max_score, best_score)
+            if not align_globally and best_score < 0:
+                score_matrix[row][col] = 0.0
+            else:
+                score_matrix[row][col] = best_score
+
+            # The backtrace is encoded binary. See _make_score_matrix_fast
+            # for details.
+            if not score_only:
+                trace_score = 0
+                if rint(nogap_score) == rint(best_score):
+                    trace_score += 2
+                if rint(row_open) == rint(best_score):
+                    trace_score += 1
+                if rint(row_extend) == rint(best_score):
+                    trace_score += 8
+                if rint(col_open) == rint(best_score):
+                    trace_score += 4
+                if rint(col_extend) == rint(best_score):
+                    trace_score += 16
+                trace_matrix[row][col] = trace_score
+
+    if not align_globally:
+        best_score = local_max_score
+
+    return score_matrix, trace_matrix, best_score
+
+
+def _make_score_matrix_fast(
+    sequenceA,
+    sequenceB,
+    match_fn,
+    open_A,
+    extend_A,
+    open_B,
+    extend_B,
+    penalize_extend_when_opening,
+    penalize_end_gaps,
+    align_globally,
+    score_only,
+):
+    """Generate a score and traceback matrix according to Gotoh (PRIVATE).
+
+    This is an implementation of the Needleman-Wunsch dynamic programming
+    algorithm as modified by Gotoh, implementing affine gap penalties.
+    In short, we have three matrices, holding scores for alignments ending
+    in (1) a match/mismatch, (2) a gap in sequence A, and (3) a gap in
+    sequence B, respectively. However, we can combine them in one matrix,
+    which holds the best scores, and store only those values from the
+    other matrices that are actually used for the next step of calculation.
+    The traceback matrix holds the positions for backtracing the alignment.
+    """
+    first_A_gap = calc_affine_penalty(1, open_A, extend_A, penalize_extend_when_opening)
+    first_B_gap = calc_affine_penalty(1, open_B, extend_B, penalize_extend_when_opening)
+    local_max_score = 0
+
+    # Create the score and traceback matrices. These should be in the
+    # shape:
+    # sequenceA (down) x sequenceB (across)
+    lenA, lenB = len(sequenceA), len(sequenceB)
+    score_matrix, trace_matrix = [], []
+    for i in range(lenA + 1):
+        score_matrix.append([None] * (lenB + 1))
+        if not score_only:
+            trace_matrix.append([None] * (lenB + 1))
+
+    # Initialize first row and column with gap scores. This is like opening up
+    # i gaps at the beginning of sequence A or B.
+    for i in range(lenA + 1):
+        if penalize_end_gaps[1]:  # [1]:gap in sequence B
+            score = calc_affine_penalty(
+                i, open_B, extend_B, penalize_extend_when_opening
+            )
+        else:
+            score = 0
+        score_matrix[i][0] = score
+    for i in range(lenB + 1):
+        if penalize_end_gaps[0]:  # [0]:gap in sequence A
+            score = calc_affine_penalty(
+                i, open_A, extend_A, penalize_extend_when_opening
+            )
+        else:
+            score = 0
+        score_matrix[0][i] = score
+
+    # Now initialize the col 'matrix'. Actually this is only a one dimensional
+    # list, since we only need the col scores from the last row.
+    col_score = [0]  # Best score, if actual alignment ends with gap in seqB
+    for i in range(1, lenB + 1):
+        col_score.append(
+            calc_affine_penalty(i, 2 * open_B, extend_B, penalize_extend_when_opening)
+        )
+
+    # The row 'matrix' is calculated on the fly. Here we only need the actual
+    # score.
+    # Now, filling up the score and traceback matrices:
+    for row in range(1, lenA + 1):
+        row_score = calc_affine_penalty(
+            row, 2 * open_A, extend_A, penalize_extend_when_opening
+        )
+        for col in range(1, lenB + 1):
+            # Calculate the score that would occur by extending the
+            # alignment without gaps.
+            # fmt: off
+            nogap_score = (
+                score_matrix[row - 1][col - 1]
+                + match_fn(sequenceA[row - 1], sequenceB[col - 1])
+            )
+            # fmt: on
+            # Check the score that would occur if there were a gap in
+            # sequence A. This could come from opening a new gap or
+            # extending an existing one.
+            # A gap in sequence A can also be opened if it follows a gap in
+            # sequence B:  A-
+            #              -B
+            if not penalize_end_gaps[0] and row == lenA:
+                row_open = score_matrix[row][col - 1]
+                row_extend = row_score
+            else:
+                row_open = score_matrix[row][col - 1] + first_A_gap
+                row_extend = row_score + extend_A
+            row_score = max(row_open, row_extend)
+
+            # The same for sequence B:
+            if not penalize_end_gaps[1] and col == lenB:
+                col_open = score_matrix[row - 1][col]
+                col_extend = col_score[col]
+            else:
+                col_open = score_matrix[row - 1][col] + first_B_gap
+                col_extend = col_score[col] + extend_B
+            col_score[col] = max(col_open, col_extend)
+
+            best_score = max(nogap_score, col_score[col], row_score)
+            local_max_score = max(local_max_score, best_score)
+            if not align_globally and best_score < 0:
+                score_matrix[row][col] = 0
+            else:
+                score_matrix[row][col] = best_score
+
+            # Now the trace_matrix. The edges of the backtrace are encoded
+            # binary: 1 = open gap in seqA, 2 = match/mismatch of seqA and
+            # seqB, 4 = open gap in seqB, 8 = extend gap in seqA, and
+            # 16 = extend gap in seqB. This values can be summed up.
+            # Thus, the trace score 7 means that the best score can either
+            # come from opening a gap in seqA (=1), pairing two characters
+            # of seqA and seqB (+2=3) or opening a gap in seqB (+4=7).
+            # However, if we only want the score we don't care about the trace.
+            if not score_only:
+                row_score_rint = rint(row_score)
+                col_score_rint = rint(col_score[col])
+                row_trace_score = 0
+                col_trace_score = 0
+                if rint(row_open) == row_score_rint:
+                    row_trace_score += 1  # Open gap in seqA
+                if rint(row_extend) == row_score_rint:
+                    row_trace_score += 8  # Extend gap in seqA
+                if rint(col_open) == col_score_rint:
+                    col_trace_score += 4  # Open gap in seqB
+                if rint(col_extend) == col_score_rint:
+                    col_trace_score += 16  # Extend gap in seqB
+
+                trace_score = 0
+                best_score_rint = rint(best_score)
+                if rint(nogap_score) == best_score_rint:
+                    trace_score += 2  # Align seqA with seqB
+                if row_score_rint == best_score_rint:
+                    trace_score += row_trace_score
+                if col_score_rint == best_score_rint:
+                    trace_score += col_trace_score
+                trace_matrix[row][col] = trace_score
+
+    if not align_globally:
+        best_score = local_max_score
+
+    return score_matrix, trace_matrix, best_score
+
+
+def _recover_alignments(
+    sequenceA,
+    sequenceB,
+    starts,
+    best_score,
+    score_matrix,
+    trace_matrix,
+    align_globally,
+    gap_char,
+    one_alignment_only,
+    gap_A_fn,
+    gap_B_fn,
+    reverse=False,
+):
+    """Do the backtracing and return a list of alignments (PRIVATE).
+
+    Recover the alignments by following the traceback matrix.  This
+    is a recursive procedure, but it's implemented here iteratively
+    with a stack.
+
+    sequenceA and sequenceB may be sequences, including strings,
+    lists, or list-like objects.  In order to preserve the type of
+    the object, we need to use slices on the sequences instead of
+    indexes.  For example, sequenceA[row] may return a type that's
+    not compatible with sequenceA, e.g. if sequenceA is a list and
+    sequenceA[row] is a string.  Thus, avoid using indexes and use
+    slices, e.g. sequenceA[row:row+1].  Assume that client-defined
+    sequence classes preserve these semantics.
+    """
+    lenA, lenB = len(sequenceA), len(sequenceB)
+    ali_seqA, ali_seqB = sequenceA[0:0], sequenceB[0:0]
+    tracebacks = []
+    in_process = []
+
+    for start in starts:
+        score, (row, col) = start
+        begin = 0
+        if align_globally:
+            end = None
+        else:
+            # If this start is a zero-extension: don't start here!
+            if (score, (row - 1, col - 1)) in starts:
+                continue
+            # Local alignments should start with a positive score!
+            if score <= 0:
+                continue
+            # Local alignments should not end with a gap!:
+            trace = trace_matrix[row][col]
+            if (trace - trace % 2) % 4 == 2:  # Trace contains 'nogap', fine!
+                trace_matrix[row][col] = 2
+            # If not, don't start here!
+            else:
+                continue
+            end = -max(lenA - row, lenB - col)
+            if not end:
+                end = None
+            col_distance = lenB - col
+            row_distance = lenA - row
+
+            # fmt: off
+            ali_seqA = (
+                (col_distance - row_distance) * gap_char
+                + sequenceA[lenA - 1 : row - 1 : -1]
+            )
+            ali_seqB = (
+                (row_distance - col_distance) * gap_char
+                + sequenceB[lenB - 1 : col - 1 : -1]
+            )
+            # fmt: on
+        in_process += [
+            (ali_seqA, ali_seqB, end, row, col, False, trace_matrix[row][col])
+        ]
+    while in_process and len(tracebacks) < MAX_ALIGNMENTS:
+        # Although we allow a gap in seqB to be followed by a gap in seqA,
+        # we don't want to allow it the other way round, since this would
+        # give redundant alignments of type: A-  vs.  -A
+        #                                    -B       B-
+        # Thus we need to keep track if a gap in seqA was opened (col_gap)
+        # and stop the backtrace (dead_end) if a gap in seqB follows.
+        #
+        # Attention: This may fail, if the gap-penalties for both strands are
+        # different. In this case the second alignment may be the only optimal
+        # alignment. Thus it can happen that no alignment is returned. For
+        # this case a workaround was implemented, which reverses the input and
+        # the matrices (this happens in _reverse_matrices) and repeats the
+        # backtrace. The variable 'reverse' keeps track of this.
+        dead_end = False
+        ali_seqA, ali_seqB, end, row, col, col_gap, trace = in_process.pop()
+
+        while (row > 0 or col > 0) and not dead_end:
+            cache = (ali_seqA[:], ali_seqB[:], end, row, col, col_gap)
+
+            # If trace is empty we have reached at least one border of the
+            # matrix or the end of a local alignment. Just add the rest of
+            # the sequence(s) and fill with gaps if necessary.
+            if not trace:
+                if col and col_gap:
+                    dead_end = True
+                else:
+                    ali_seqA, ali_seqB = _finish_backtrace(
+                        sequenceA, sequenceB, ali_seqA, ali_seqB, row, col, gap_char
+                    )
+                break
+            elif trace % 2 == 1:  # = row open = open gap in seqA
+                trace -= 1
+                if col_gap:
+                    dead_end = True
+                else:
+                    col -= 1
+                    ali_seqA += gap_char
+                    ali_seqB += sequenceB[col : col + 1]
+                    col_gap = False
+            elif trace % 4 == 2:  # = match/mismatch of seqA with seqB
+                trace -= 2
+                row -= 1
+                col -= 1
+                ali_seqA += sequenceA[row : row + 1]
+                ali_seqB += sequenceB[col : col + 1]
+                col_gap = False
+            elif trace % 8 == 4:  # = col open = open gap in seqB
+                trace -= 4
+                row -= 1
+                ali_seqA += sequenceA[row : row + 1]
+                ali_seqB += gap_char
+                col_gap = True
+            elif trace in (8, 24):  # = row extend = extend gap in seqA
+                trace -= 8
+                if col_gap:
+                    dead_end = True
+                else:
+                    col_gap = False
+                    # We need to find the starting point of the extended gap
+                    x = _find_gap_open(
+                        sequenceA,
+                        sequenceB,
+                        ali_seqA,
+                        ali_seqB,
+                        end,
+                        row,
+                        col,
+                        col_gap,
+                        gap_char,
+                        score_matrix,
+                        trace_matrix,
+                        in_process,
+                        gap_A_fn,
+                        col,
+                        row,
+                        "col",
+                        best_score,
+                        align_globally,
+                    )
+                    ali_seqA, ali_seqB, row, col, in_process, dead_end = x
+            elif trace == 16:  # = col extend = extend gap in seqB
+                trace -= 16
+                col_gap = True
+                x = _find_gap_open(
+                    sequenceA,
+                    sequenceB,
+                    ali_seqA,
+                    ali_seqB,
+                    end,
+                    row,
+                    col,
+                    col_gap,
+                    gap_char,
+                    score_matrix,
+                    trace_matrix,
+                    in_process,
+                    gap_B_fn,
+                    row,
+                    col,
+                    "row",
+                    best_score,
+                    align_globally,
+                )
+                ali_seqA, ali_seqB, row, col, in_process, dead_end = x
+
+            if trace:  # There is another path to follow...
+                cache += (trace,)
+                in_process.append(cache)
+            trace = trace_matrix[row][col]
+            if not align_globally:
+                if score_matrix[row][col] == best_score:
+                    # We have gone through a 'zero-score' extension, discard it
+                    dead_end = True
+                elif score_matrix[row][col] <= 0:
+                    # We have reached the end of the backtrace
+                    begin = max(row, col)
+                    trace = 0
+        if not dead_end:
+            if not reverse:
+                tracebacks.append((ali_seqA[::-1], ali_seqB[::-1], score, begin, end))
+            else:
+                tracebacks.append((ali_seqB[::-1], ali_seqA[::-1], score, begin, end))
+            if one_alignment_only:
+                break
+    return _clean_alignments(tracebacks)
+
+
+def _find_start(score_matrix, best_score, align_globally):
+    """Return a list of starting points (score, (row, col)) (PRIVATE).
+
+    Indicating every possible place to start the tracebacks.
+    """
+    nrows, ncols = len(score_matrix), len(score_matrix[0])
+    # In this implementation of the global algorithm, the start will always be
+    # the bottom right corner of the matrix.
+    if align_globally:
+        starts = [(best_score, (nrows - 1, ncols - 1))]
+    else:
+        # For local alignments, there may be many different start points.
+        starts = []
+        tolerance = 0  # XXX do anything with this?
+        # Now find all the positions within some tolerance of the best
+        # score.
+        for row in range(nrows):
+            for col in range(ncols):
+                score = score_matrix[row][col]
+                if rint(abs(score - best_score)) <= rint(tolerance):
+                    starts.append((score, (row, col)))
+    return starts
+
+
+def _reverse_matrices(score_matrix, trace_matrix):
+    """Reverse score and trace matrices (PRIVATE)."""
+    reverse_score_matrix = []
+    reverse_trace_matrix = []
+    # fmt: off
+    reverse_trace = {
+        1: 4, 2: 2, 3: 6, 4: 1, 5: 5, 6: 3, 7: 7, 8: 16, 9: 20, 10: 18, 11: 22, 12: 17,
+        13: 21, 14: 19, 15: 23, 16: 8, 17: 12, 18: 10, 19: 14, 20: 9, 21: 13, 22: 11,
+        23: 15, 24: 24, 25: 28, 26: 26, 27: 30, 28: 25, 29: 29, 30: 27, 31: 31,
+        None: None,
+    }
+    # fmt: on
+    for col in range(len(score_matrix[0])):
+        new_score_row = []
+        new_trace_row = []
+        for row in range(len(score_matrix)):
+            new_score_row.append(score_matrix[row][col])
+            new_trace_row.append(reverse_trace[trace_matrix[row][col]])
+        reverse_score_matrix.append(new_score_row)
+        reverse_trace_matrix.append(new_trace_row)
+    return reverse_score_matrix, reverse_trace_matrix
+
+
+def _clean_alignments(alignments):
+    """Take a list of alignments and return a cleaned version (PRIVATE).
+
+    Remove duplicates, make sure begin and end are set correctly, remove
+    empty alignments.
+    """
+    unique_alignments = []
+    for align in alignments:
+        if align not in unique_alignments:
+            unique_alignments.append(align)
+    i = 0
+    while i < len(unique_alignments):
+        seqA, seqB, score, begin, end = unique_alignments[i]
+        # Make sure end is set reasonably.
+        if end is None:  # global alignment
+            end = len(seqA)
+        elif end < 0:
+            end = end + len(seqA)
+        # If there's no alignment here, get rid of it.
+        if begin >= end:
+            del unique_alignments[i]
+            continue
+        unique_alignments[i] = Alignment(seqA, seqB, score, begin, end)
+        i += 1
+    return unique_alignments
+
+
+def _finish_backtrace(sequenceA, sequenceB, ali_seqA, ali_seqB, row, col, gap_char):
+    """Add remaining sequences and fill with gaps if necessary (PRIVATE)."""
+    if row:
+        ali_seqA += sequenceA[row - 1 :: -1]
+    if col:
+        ali_seqB += sequenceB[col - 1 :: -1]
+    if row > col:
+        ali_seqB += gap_char * (len(ali_seqA) - len(ali_seqB))
+    elif col > row:
+        ali_seqA += gap_char * (len(ali_seqB) - len(ali_seqA))
+    return ali_seqA, ali_seqB
+
+
+def _find_gap_open(
+    sequenceA,
+    sequenceB,
+    ali_seqA,
+    ali_seqB,
+    end,
+    row,
+    col,
+    col_gap,
+    gap_char,
+    score_matrix,
+    trace_matrix,
+    in_process,
+    gap_fn,
+    target,
+    index,
+    direction,
+    best_score,
+    align_globally,
+):
+    """Find the starting point(s) of the extended gap (PRIVATE)."""
+    dead_end = False
+    target_score = score_matrix[row][col]
+    for n in range(target):
+        if direction == "col":
+            col -= 1
+            ali_seqA += gap_char
+            ali_seqB += sequenceB[col : col + 1]
+        else:
+            row -= 1
+            ali_seqA += sequenceA[row : row + 1]
+            ali_seqB += gap_char
+        actual_score = score_matrix[row][col] + gap_fn(index, n + 1)
+        if not align_globally and score_matrix[row][col] == best_score:
+            # We have run through a 'zero-score' extension and discard it
+            dead_end = True
+            break
+        if rint(actual_score) == rint(target_score) and n > 0:
+            if not trace_matrix[row][col]:
+                break
+            else:
+                in_process.append(
+                    (
+                        ali_seqA[:],
+                        ali_seqB[:],
+                        end,
+                        row,
+                        col,
+                        col_gap,
+                        trace_matrix[row][col],
+                    )
+                )
+        if not trace_matrix[row][col]:
+            dead_end = True
+    return ali_seqA, ali_seqB, row, col, in_process, dead_end
+
+
+_PRECISION = 1000
+
+
+def rint(x, precision=_PRECISION):
+    """Print number with declared precision."""
+    return int(x * precision + 0.5)
+
+
+class identity_match:
+    """Create a match function for use in an alignment.
+
+    match and mismatch are the scores to give when two residues are equal
+    or unequal.  By default, match is 1 and mismatch is 0.
+    """
+
+    def __init__(self, match=1, mismatch=0):
+        """Initialize the class."""
+        self.match = match
+        self.mismatch = mismatch
+
+    def __call__(self, charA, charB):
+        """Call a match function instance already created."""
+        if charA == charB:
+            return self.match
+        return self.mismatch
+
+
+class dictionary_match:
+    """Create a match function for use in an alignment.
+
+    Attributes:
+     - score_dict     - A dictionary where the keys are tuples (residue 1,
+       residue 2) and the values are the match scores between those residues.
+     - symmetric      - A flag that indicates whether the scores are symmetric.
+
+    """
+
+    def __init__(self, score_dict, symmetric=1):
+        """Initialize the class."""
+        if isinstance(score_dict, substitution_matrices.Array):
+            score_dict = dict(score_dict)  # Access to dict is much faster
+        self.score_dict = score_dict
+        self.symmetric = symmetric
+
+    def __call__(self, charA, charB):
+        """Call a dictionary match instance already created."""
+        if self.symmetric and (charA, charB) not in self.score_dict:
+            # If the score dictionary is symmetric, then look up the
+            # score both ways.
+            charB, charA = charA, charB
+        return self.score_dict[(charA, charB)]
+
+
+class affine_penalty:
+    """Create a gap function for use in an alignment."""
+
+    def __init__(self, open, extend, penalize_extend_when_opening=0):
+        """Initialize the class."""
+        if open > 0 or extend > 0:
+            raise ValueError("Gap penalties should be non-positive.")
+        if not penalize_extend_when_opening and (extend < open):
+            raise ValueError(
+                "Gap opening penalty should be higher than "
+                "gap extension penalty (or equal)"
+            )
+        self.open, self.extend = open, extend
+        self.penalize_extend_when_opening = penalize_extend_when_opening
+
+    def __call__(self, index, length):
+        """Call a gap function instance already created."""
+        return calc_affine_penalty(
+            length, self.open, self.extend, self.penalize_extend_when_opening
+        )
+
+
+def calc_affine_penalty(length, open, extend, penalize_extend_when_opening):
+    """Calculate a penalty score for the gap function."""
+    if length <= 0:
+        return 0.0
+    penalty = open + extend * length
+    if not penalize_extend_when_opening:
+        penalty -= extend
+    return penalty
+
+
+def print_matrix(matrix):
+    """Print out a matrix for debugging purposes."""
+    # Transpose the matrix and get the length of the values in each column.
+    matrixT = [[] for x in range(len(matrix[0]))]
+    for i in range(len(matrix)):
+        for j in range(len(matrix[i])):
+            matrixT[j].append(len(str(matrix[i][j])))
+    ndigits = [max(x) for x in matrixT]
+    for i in range(len(matrix)):
+        # Using string formatting trick to add leading spaces,
+        print(
+            " ".join("%*s " % (ndigits[j], matrix[i][j]) for j in range(len(matrix[i])))
+        )
+
+
+def format_alignment(align1, align2, score, begin, end, full_sequences=False):
+    """Format the alignment prettily into a string.
+
+    IMPORTANT: Gap symbol must be "-" (or ['-'] for lists)!
+
+    Since Biopython 1.71 identical matches are shown with a pipe
+    character, mismatches as a dot, and gaps as a space.
+
+    Prior releases just used the pipe character to indicate the
+    aligned region (matches, mismatches and gaps).
+
+    Also, in local alignments, if the alignment does not include
+    the whole sequences, now only the aligned part is shown,
+    together with the start positions of the aligned subsequences.
+    The start positions are 1-based; so start position n is the
+    n-th base/amino acid in the *un-aligned* sequence.
+
+    NOTE: This is different to the alignment's begin/end values,
+    which give the Python indices (0-based) of the bases/amino acids
+    in the *aligned* sequences.
+
+    If you want to restore the 'historic' behaviour, that means
+    displaying the whole sequences (including the non-aligned parts),
+    use ``full_sequences=True``. In this case, the non-aligned leading
+    and trailing parts are also indicated by spaces in the match-line.
+    """
+    align_begin = begin
+    align_end = end
+    start1 = start2 = ""
+    start_m = begin  # Begin of match line (how many spaces to include)
+    # For local alignments:
+    if not full_sequences and (begin != 0 or end != len(align1)):
+        # Calculate the actual start positions in the un-aligned sequences
+        # This will only work if the gap symbol is '-' or ['-']!
+        start1 = str(len(align1[:begin]) - align1[:begin].count("-") + 1) + " "
+        start2 = str(len(align2[:begin]) - align2[:begin].count("-") + 1) + " "
+        start_m = max(len(start1), len(start2))
+    elif full_sequences:
+        start_m = 0
+        begin = 0
+        end = len(align1)
+
+    if isinstance(align1, list):
+        # List elements will be separated by spaces, since they can be
+        # of different lengths
+        align1 = [a + " " for a in align1]
+        align2 = [a + " " for a in align2]
+
+    s1_line = ["{:>{width}}".format(start1, width=start_m)]  # seq1 line
+    m_line = [" " * start_m]  # match line
+    s2_line = ["{:>{width}}".format(start2, width=start_m)]  # seq2 line
+
+    for n, (a, b) in enumerate(zip(align1[begin:end], align2[begin:end])):
+        # Since list elements can be of different length, we center them,
+        # using the maximum length of the two compared elements as width
+        m_len = max(len(a), len(b))
+        s1_line.append("{:^{width}}".format(a, width=m_len))
+        s2_line.append("{:^{width}}".format(b, width=m_len))
+        if full_sequences and (n < align_begin or n >= align_end):
+            m_line.append("{:^{width}}".format(" ", width=m_len))  # space
+            continue
+        if a == b:
+            m_line.append("{:^{width}}".format("|", width=m_len))  # match
+        elif a.strip() == "-" or b.strip() == "-":
+            m_line.append("{:^{width}}".format(" ", width=m_len))  # gap
+        else:
+            m_line.append("{:^{width}}".format(".", width=m_len))  # mismatch
+
+    s2_line.append(f"\n  Score={score:g}\n")
+    return "\n".join(["".join(s1_line), "".join(m_line), "".join(s2_line)])
+
+
+# Try and load C implementations of functions. If I can't,
+# then throw a warning and use the pure Python implementations.
+# The redefinition is deliberate, thus the no quality assurance
+# flag for when using flake8.
+# Before, we secure access to the pure Python functions (for testing purposes):
+
+_python_make_score_matrix_fast = _make_score_matrix_fast
+_python_rint = rint
+
+try:
+    from .cpairwise2 import rint, _make_score_matrix_fast  # noqa
+except ImportError:
+    warnings.warn(
+        "Import of C module failed. Falling back to pure Python "
+        "implementation. This may be slooow...",
+        BiopythonWarning,
+    )
+
+if __name__ == "__main__":
+    from Bio._utils import run_doctest
+
+    run_doctest()

.venv_haddock/lib/python3.12/site-packages/haddock3-2026.3.0.dist-info/INSTALLER

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

.venv_haddock/lib/python3.12/site-packages/haddock3-2026.3.0.dist-info/METADATA

@@ -0,0 +1,205 @@
+Metadata-Version: 2.4
+Name: haddock3
+Version: 2026.3.0
+Summary: HADDOCK3
+Author-email: BonvinLab <bonvinlab.support@uu.nl>
+License: Apache License 2.0
+Project-URL: Homepage, https://github.com/haddocking/haddock3
+Project-URL: Documentation, https://github.com/haddocking/haddock3#readme
+Project-URL: Issue Tracker, https://github.com/haddocking/haddock3/issues
+Project-URL: Discussion Forum, https://github.com/haddocking/haddock3/issues
+Keywords: Structural Biology,Biochemistry,Docking,Protein docking,Proteins
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Natural Language :: English
+Classifier: Operating System :: POSIX
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Topic :: Scientific/Engineering :: Chemistry
+Classifier: Topic :: Scientific/Engineering :: Physics
+Classifier: Programming Language :: Python :: 3.9
+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
+Requires-Python: <3.15,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pdb-tools>=2.5.0
+Requires-Dist: biopython==1.*
+Requires-Dist: jsonpickle>=2.1.0
+Requires-Dist: numpy==2.*
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: scipy>=1.10.0
+Requires-Dist: toml>=0.10.2
+Requires-Dist: pandas==2.*
+Requires-Dist: prodigy-prot==2.3.0
+Requires-Dist: prodigy-lig==1.1.4
+Requires-Dist: plotly==6.5.2
+Requires-Dist: freesasa>=2.2.1
+Provides-Extra: dev
+Requires-Dist: coverage==7.10.7; extra == "dev"
+Requires-Dist: pytest==8.4.2; extra == "dev"
+Requires-Dist: pytest-cov==7.0.0; extra == "dev"
+Requires-Dist: hypothesis==6.141.1; extra == "dev"
+Requires-Dist: pytest-mock==3.15.1; extra == "dev"
+Requires-Dist: fastapi==0.128.8; extra == "dev"
+Requires-Dist: httpx==0.28.1; extra == "dev"
+Requires-Dist: kaleido==1.2.0; extra == "dev"
+Requires-Dist: pytest-random-order==1.2.0; extra == "dev"
+Provides-Extra: docs
+Requires-Dist: sphinx>=7; extra == "docs"
+Requires-Dist: sphinx-argparse>=0.4.0; extra == "docs"
+Requires-Dist: sphinx_rtd_theme>=3.0.1; extra == "docs"
+Requires-Dist: CommonMark>=0.9.1; extra == "docs"
+Requires-Dist: mock>=5.1.0; extra == "docs"
+Requires-Dist: myst-parser>=3.0.1; extra == "docs"
+Provides-Extra: mpi
+Requires-Dist: mpi4py>=4.0.2; extra == "mpi"
+Provides-Extra: notebooks
+Requires-Dist: py3Dmol>=2.5.2; extra == "notebooks"
+Dynamic: license-file
+
+# `haddock3`
+
+![haddock3-logo](https://raw.githubusercontent.com/haddocking/haddock3/refs/heads/main/docs/figs/HADDOCK3-logo.png)
+
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.16914680.svg)](https://doi.org/10.5281/zenodo.16914680)
+[![Research Software Directory](https://img.shields.io/badge/rsd-haddock3-00a3e3.svg)](https://research-software-directory.org/software/haddock3)
+[![fair-software.eu](https://img.shields.io/badge/fair--software.eu-%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F%20%20%E2%97%8F-green)](https://fair-software.eu)
+[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/8844/badge)](https://www.bestpractices.dev/projects/8844)
+
+[![Downloads](https://static.pepy.tech/badge/haddock3)](https://pepy.tech/project/haddock3)
+![PyPI - Version](https://img.shields.io/pypi/v/haddock3)
+![PyPI - Python Version](https://img.shields.io/pypi/pyversions/haddock3)
+[![SBGrid Badge](https://img.shields.io/badge/haddock3-blue?label=SBGrid&labelColor=%3D)](https://sbgrid.org/software/titles/haddock3)
+
+[![ci](https://github.com/haddocking/haddock3/actions/workflows/ci.yml/badge.svg)](https://github.com/haddocking/haddock3/actions/workflows/ci.yml)
+[![pages](https://github.com/haddocking/haddock3/actions/workflows/pages.yml/badge.svg)](https://github.com/haddocking/haddock3/actions/workflows/pages.yml)
+[![CodeQL](https://github.com/haddocking/haddock3/actions/workflows/github-code-scanning/codeql/badge.svg)](https://github.com/haddocking/haddock3/actions/workflows/github-code-scanning/codeql)
+[![Codacy Badge](https://app.codacy.com/project/badge/Grade/e11e7f45400f4e8589cdf5941f95233a)](https://app.codacy.com/gh/haddocking/haddock3/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
+[![Codacy Badge](https://app.codacy.com/project/badge/Coverage/e11e7f45400f4e8589cdf5941f95233a)](https://app.codacy.com/gh/haddocking/haddock3/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_coverage)
+
+## Introduction
+
+HADDOCK, standing for **H**igh **A**mbiguity **D**riven protein-protein **DOCK**ing, is a widely used computational tool for the integrative modeling of biomolecular interactions. Developed by researchers at [Utrecht University](https://uu.nl) in the [BonvinLab](https://bonvinlab.org) for more than 20 years, it integrates various types of experimental data, biochemical, biophysical, bioinformatic prediction and knowledge to guide the docking process.
+
+## Installation
+
+Simple installation of the [latest release](https://pypi.org/project/haddock3/) of HADDOCK3 (assuming you have a Python version 3.9 to 3.13 installed and the rights to install the software - if not refer to the instructions in [INSTALL.md](docs/INSTALL.md) for using either `venv` or `conda`) .
+
+```bash
+pip install haddock3
+```
+
+To install haddock3 with MPI support (required an OpenMPI installation - refer
+to the instructions in [INSTALL.md](docs/INSTALL.md) use:
+
+```bash
+pip install 'haddock3[mpi]'
+```
+
+In case you rather install the latest unreleased version use instead:
+
+```bash
+git clone https://github.com/haddocking/haddock3.git
+cd haddock3
+pip install .
+```
+
+For detailed instructions and installation of third-party software, please check [INSTALL.md](docs/INSTALL.md)
+
+You might also want to check the following utilities:
+
+- [`haddock-restraints`](https://github.com/haddocking/haddock-restraints): Tool to generate restraints to be used in `haddock3`.
+- [`haddock-runner`](https://github.com/haddocking/haddock-runner): Tool to run large scale `haddock3` simulations using multiple input molecules in different scenarios
+- [`haddock-tools`](https://github.com/haddocking/haddock-tools): Set of useful utility scripts developed over the years by the BonvinLab group members
+
+## Usage
+
+The most basic usage is:
+
+```bash
+haddock3 <configuration-file.toml>
+```
+
+For help on haddock3 usage:
+
+```bash
+$ haddock3 -h
+usage: haddock3 [-h] [--restart RESTART] [--extend-run EXTEND_RUN] [--setup] [--log-level {DEBUG,INFO,WARNING,ERROR,CRITICAL}] [-v] recipe
+
+positional arguments:
+  recipe                The input recipe file path
+
+optional arguments:
+  -h, --help            show this help message and exit
+  --restart RESTART     Restart the run from a given step. Previous folders from the selected step onwards will be deleted.
+  --extend-run EXTEND_RUN
+                        Start a run from a run directory previously prepared with the `haddock3-copy` CLI. Provide the run directory created with `haddock3-copy` CLI.
+  --setup               Only setup the run, do not execute
+  --log-level {DEBUG,INFO,WARNING,ERROR,CRITICAL}
+  -v, --version         show version
+```
+
+Check the [EXAMPLES](https://github.com/haddocking/haddock3/blob/main/examples/README.md) page for more some usage examples and the [User manual](https://www.bonvinlab.org/haddock3-user-manual) for a more detailed explanation of the configuration file.
+
+## Support
+
+If you encounter any code-related issues, [please open an issue](https://github.com/haddocking/haddock3/issues/new/choose).
+
+If you have any other questions or need help, please contact us at [ask.bioexcel.eu](https://ask.bioexcel.eu/).
+
+If you clone this repository and use `haddock3` for your research, please support us by signing up in [this form](https://forms.gle/LCUHiYHh1hE9rd8L6). This will allow us contact you when needed for `haddock3`-related issues, and also provide us a mean to demonstrate impact when reporting for grants - which grealty helps us to keep the project alive!
+
+## Cite us
+
+If you used `haddock3` for your research, please cite us:
+
+- **Research article**: M. Giulini, V. Reys, J.M.C. Teixeira, B. Jiménez-García, R.V. Honorato, A. Kravchenko, X. Xu, R. Versini, A. Engel, S. Verhoeven, A.M.J.J. Bonvin, [*HADDOCK3: A modular and versatile platform for integrative modelling of biomolecular complexes*](https://pubs.acs.org/doi/10.1021/acs.jcim.5c00969) Journal of Chemical Information and Modeling (2025). doi: 10.1021/acs.jcim.5c00969 [[BioRxiv]](https://www.biorxiv.org/content/10.1101/2025.04.30.651432v1)
+ 
+- **Cite this repository**: M.C. Teixeira, J., Vargas Honorato, R., Giulini, M., Bonvin, A., SarahAlidoost, Reys, V., Jimenez, B., Schulte, D., van Noort, C., Verhoeven, S., Vreede, B., SSchott, & Tsai, R. (2024). haddocking/haddock3: v3.0.0-beta.5 (Version 3.0.0-beta.5) [Computer software]. [https://doi.org/10.5281/zenodo.10527751](https://doi.org/10.5281/zenodo.10527751)
+
+## Useful resources
+
+- [User manual](https://www.bonvinlab.org/haddock3-user-manual): The online HADDOCK3 guide describing every aspects of the tool.
+- [Best practice guide](https://www.bonvinlab.org/software/bpg/) (HADDOCK2.X series)
+- [The HADDOCK2.4 web server: A leap forward in integrative modelling of biomolecular complexes. Nature Prot. 2024](https://www.nature.com/articles/s41596-024-01011-0)
+
+## Development
+
+Please check [DEVELOPMENT](https://github.com/haddocking/haddock3/blob/main/DEVELOPMENT.md) for instructions on how to develop `haddock3`
+
+### Code Documentation
+
+The code documentation is automatically built and hosted at [bonvinlab.org/haddock3](https://www.bonvinlab.org/haddock3/).
+
+To build it locally it is necessary to have some extra packages installed. You can install them using the following command:
+
+```bash
+pip install -e '.[docs]'
+```
+
+Then, to build the documentation, run the following commands:
+
+```bash
+sphinx-apidoc -f -e -o docs/ src/haddock -d 1
+sphinx-build -b html docs haddock3-docs
+```
+
+> Warning messages are expected, but the documentation should be built successfully.
+
+The rendered documentation will be available at `haddock3-docs/index.html`. This will open a local webpage with the
+
+### Contributing
+
+Check the [CONTRIBUTING](CONTRIBUTING.md) file for instructions on how to contribute with the project!
+
+<!-- ---
+
+Happy HADDOCking!
+
+<img src="https://www.bonvinlab.org/images/bio-haddock.png" alt="haddock" width="50px"> -->

.venv_haddock/lib/python3.12/site-packages/haddock3-2026.3.0.dist-info/RECORD

@@ -0,0 +1,571 @@
+../../../bin/haddock-restraints,sha256=Yags-YNY67tJLwfMd2_pZq_sz-aP_6FuwvicD8S3DBw,234
+../../../bin/haddock3,sha256=HbfycSqG7JkHVfu1D9670SESUMQzg8OInaflb02qREE,217
+../../../bin/haddock3-analyse,sha256=qCpYoFSoGA9gdvuRbu46H91TjHtxUwIHcbCWafUuoHs,225
+../../../bin/haddock3-cfg,sha256=Nqqqvi-PZyVx2i0JH1g3rde6uYAT3W_g2I4WcZmFCPE,221
+../../../bin/haddock3-clean,sha256=U5jXBhPP7vqMp2rsFrXptxExOkcG63EL1FNDMakHNHQ,223
+../../../bin/haddock3-copy,sha256=rcvMAxwINQe-Qv24fUD3nee2jGdB9ZCXuqt07jL1gKw,220
+../../../bin/haddock3-dmn,sha256=exb1Aop7kqqAhrptONYsqtFPT3dqWc9LdoGotYJuwPY,221
+../../../bin/haddock3-mpitask,sha256=47Cg7mItK8Dj53_JQ1861-wSoCCT0WXfkkSjFX4AgcU,221
+../../../bin/haddock3-pp,sha256=B8Cm4L42TSeRiRzH9iIWmICVFUUPsEXtA-SBy20ar5Q,220
+../../../bin/haddock3-re,sha256=MJ4Vw8DptOivUx3wOQbhbODMA1SBIH14Wwy2OOHwCdc,220
+../../../bin/haddock3-restraints,sha256=CZ94yeu7W_hRwcUffa4LeYvrlSr36O3Z-R46m6P3ZWw,228
+../../../bin/haddock3-score,sha256=EOcjnW0I9aCephqoxTkow13ucouSYkD-fdvSPyy1Sg0,223
+../../../bin/haddock3-traceback,sha256=_9PDyQF__1wI3w1XWCC97TEOjZTCOA33NuEO301pBek,227
+../../../bin/haddock3-unpack,sha256=r1oU7rdrcK6b_aW08m2I_-yPJxmo7fKkIXhzbm5X1pY,224
+haddock/__init__.py,sha256=fIVrlAmZV9hM6SOJ1WyB0Poh2vShgepyMsy3BiJpGiE,1325
+haddock/__pycache__/__init__.cpython-312.pyc,,
+haddock/bin/contact_fcc,sha256=DJQb0bttBNGHK0nRmTEdstqltzFIW129po9kIAEoxDY,73320
+haddock/bin/contact_fcc.cpython-312-darwin.so,sha256=FOj9VPji2dkAtHCMOH7bnmEEHtdErF_QNZ4-E7QKKLo,89904
+haddock/bin/fast-rmsdmatrix,sha256=zxAahCUM1PGyjV5uq5me5xy7JD4JIM3TxDIZHFq8tEs,52512
+haddock/bin/fast_rmsdmatrix.cpython-312-darwin.so,sha256=KgN-7iQLhS0-PBPJxJjcldF2ocXYjzkzzjSCYJaZCdA,69048
+haddock/bin/haddock-restraints,sha256=Das8qLkNpGtjcL1q9Ilo3T3Nud649qCFptDM5PTx6mk,2157456
+haddock/clis/__init__.py,sha256=hQdjlVdnd-_1BJHBTojZc5dpJPM2HtJ8ueluHj1VnUk,211
+haddock/clis/__pycache__/__init__.cpython-312.pyc,,
+haddock/clis/__pycache__/cli.cpython-312.pyc,,
+haddock/clis/__pycache__/cli_analyse.cpython-312.pyc,,
+haddock/clis/__pycache__/cli_cfg.cpython-312.pyc,,
+haddock/clis/__pycache__/cli_clean.cpython-312.pyc,,
+haddock/clis/__pycache__/cli_cp.cpython-312.pyc,,
+haddock/clis/__pycache__/cli_dmn.cpython-312.pyc,,
+haddock/clis/__pycache__/cli_mpi.cpython-312.pyc,,
+haddock/clis/__pycache__/cli_pp.cpython-312.pyc,,
+haddock/clis/__pycache__/cli_re.cpython-312.pyc,,
+haddock/clis/__pycache__/cli_restraints.cpython-312.pyc,,
+haddock/clis/__pycache__/cli_score.cpython-312.pyc,,
+haddock/clis/__pycache__/cli_traceback.cpython-312.pyc,,
+haddock/clis/__pycache__/cli_unpack.cpython-312.pyc,,
+haddock/clis/__pycache__/wrapper_haddock_restraints.cpython-312.pyc,,
+haddock/clis/cli.py,sha256=HNfcDz4F2xQAaPn7ntg5JukG_HfyVayawErv4UhSe9s,6064
+haddock/clis/cli_analyse.py,sha256=06uPRsRW72qDcR1uM2qM4GipA_tEKacJJeyaqUGZPLo,25845
+haddock/clis/cli_cfg.py,sha256=97OY3h0d9APVUBEojBQQrmSMzlPWrzKsuChG4uHyHls,6514
+haddock/clis/cli_clean.py,sha256=lf2s6PGQbzkLjUHhOp9_jtiLHnrj5oPW_tQaST4-Fu4,2976
+haddock/clis/cli_cp.py,sha256=kT3thSQ55T-DE8AsvKWutCXIst_TAHb47dDUGEGH2jg,4687
+haddock/clis/cli_dmn.py,sha256=r28ByoEwQMZUuFcr2mbj-mRvsKdSpOOsvueAUV3s7YM,8863
+haddock/clis/cli_mpi.py,sha256=-xwqD3s0-jOtVKYhWw1eoxLgBpKJjbNp9n85Amdiw8U,3114
+haddock/clis/cli_pp.py,sha256=I5vIswQgYr7hsdTxL_8z_krKEcV2YuvOnmmwEKQZpqo,4357
+haddock/clis/cli_re.py,sha256=oi8J-fag-NcSDq6eLc8OUi1zXlYmDWJ4i2k_VlolyGQ,1663
+haddock/clis/cli_restraints.py,sha256=g6cKYGz16mAwimhNfC4LW-SJmBVh7G3xVPHiuXQAgpU,4304
+haddock/clis/cli_score.py,sha256=8hd7c4YK74tKr8K9EJWe6zb62yZpSSyufyc6kDMlfMM,8874
+haddock/clis/cli_traceback.py,sha256=WLU9rvhTofaepCSE1V0n7hqkGIgf_GAg9Jl3GUeCgDk,12694
+haddock/clis/cli_unpack.py,sha256=qVGHgJtIpZ9XQdJ_srWn0OxN5rnkJueVjayu40g_gG4,3540
+haddock/clis/re/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+haddock/clis/re/__pycache__/__init__.cpython-312.pyc,,
+haddock/clis/re/__pycache__/clustfcc.cpython-312.pyc,,
+haddock/clis/re/__pycache__/clustrmsd.cpython-312.pyc,,
+haddock/clis/re/__pycache__/score.cpython-312.pyc,,
+haddock/clis/re/clustfcc.py,sha256=8R_57DdEgxvmjv1xokV3_nYCpk8zeuaLiqekX2h9f3o,6623
+haddock/clis/re/clustrmsd.py,sha256=7Ktju36_SEvgL2aPi-aAEKJkTIWV-D2pf-tjZy7bagk,8825
+haddock/clis/re/score.py,sha256=aIfH1a47wtgobNBf2xaW5JM6SdN1y1SDcim1NmI3DYc,4540
+haddock/clis/restraints/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haddock/clis/restraints/__pycache__/__init__.cpython-312.pyc,,
+haddock/clis/restraints/__pycache__/active_passive_to_ambig.cpython-312.pyc,,
+haddock/clis/restraints/__pycache__/calc_accessibility.cpython-312.pyc,,
+haddock/clis/restraints/__pycache__/passive_from_active.cpython-312.pyc,,
+haddock/clis/restraints/__pycache__/random_removal.cpython-312.pyc,,
+haddock/clis/restraints/__pycache__/restrain_bodies.cpython-312.pyc,,
+haddock/clis/restraints/__pycache__/restrain_ligand.cpython-312.pyc,,
+haddock/clis/restraints/__pycache__/validate_tbl.cpython-312.pyc,,
+haddock/clis/restraints/__pycache__/webservice.cpython-312.pyc,,
+haddock/clis/restraints/__pycache__/z_surface_restraints.cpython-312.pyc,,
+haddock/clis/restraints/active_passive_to_ambig.py,sha256=EjG0fM1W5UuWEYZQamisc0x3FikLSLz8vonbug1XueA,2283
+haddock/clis/restraints/calc_accessibility.py,sha256=M9Z4zhNXM7PXEkZaW816KMwMNgE51_GlOaY4deL1Ef8,11269
+haddock/clis/restraints/naccess.config,sha256=bk8sLKHwBo2StPKMAZD5MrB7CXHi0Ms19rHSgW4-DEo,4493
+haddock/clis/restraints/passive_from_active.py,sha256=7xVfgod0kTh6OSYBmsMV3mG7IqPlsGNxE4WCankx-bI,2192
+haddock/clis/restraints/random_removal.py,sha256=ZC5xbZ7HkeQeEzzDhiRW8lY44JP_f2tSAOTW0g4749Q,5274
+haddock/clis/restraints/restrain_bodies.py,sha256=osq-RLusT08rkECU5xduq526nI45P_yb3c-KKQk5uNE,1705
+haddock/clis/restraints/restrain_ligand.py,sha256=2wgTBiWKdQjUfcoS-kpKqDKtrETAGjUDUa2BRTSSd_E,7477
+haddock/clis/restraints/validate_tbl.py,sha256=4Sag8zN6KHdCVvwcPud4Lzp-SqkKHx7_TgNV1m7fT9U,1694
+haddock/clis/restraints/webservice.py,sha256=Gtakyjba8rsPwehm8PiQhdpzYMLgydVWSRLBmZjx8nE,9774
+haddock/clis/restraints/z_surface_restraints.py,sha256=qKBYYx2NKn7j93pOyxujOf3cYtJAP03CWDQTM3-Vrvg,23114
+haddock/clis/wrapper_haddock_restraints.py,sha256=qkK7jgaAUtD0oe1U5EArqSJb6XyIlDE189Xv5shyTBs,432
+haddock/cns/bin/aarch64-linux.bin,sha256=cgiN1cg69k5XbNlpP7t6AbrZU0GS7-KSiQyK17u7uXQ,3947816
+haddock/cns/bin/arm64-darwin.bin,sha256=5v6_dOzLdA-LxdSZVcyPwgICXV1kLhKedzjnKArZWog,4171768
+haddock/cns/bin/x86_64-darwin.bin,sha256=UR0WNJL4h4vojnQDP7-PnzHJdRW78Wo4di8_zQwP8x0,4089832
+haddock/cns/bin/x86_64-linux.bin,sha256=zmsMa5044JmR-xVDFALpLLOMcjVEstzKeo3Ci2ZkOSc,6363048
+haddock/cns/toppar/boxtyp20.pdb,sha256=sROuDiaM-qLE2ktszjP9ZSWckF2Nb0S2_kKVh81SRwA,51077
+haddock/cns/toppar/carbohydrate.param,sha256=vPGsd7ljzfe5vY6Ps0pLNQm_wisQIll5W7y6Im6C0QY,12136
+haddock/cns/toppar/carbohydrate.top,sha256=Q4zyL0GJ--GaakL_TW-LLWIKF0nggMbFIZ0J2QUgj6w,87186
+haddock/cns/toppar/cofactors.param,sha256=zsmdvfZS_M5SQpT2xOPaCt03mXqM4Y0UMg7xktnx18U,144746
+haddock/cns/toppar/cofactors.pep,sha256=daEdpEyAJIa8b2VkCqSKcw8PaExcB6Qro80XNes_sHA,2
+haddock/cns/toppar/cofactors.top,sha256=WxfXuY29EZVGfRlZqG6Zbzd5LvMzFfkr2UQSD-2AXek,85089
+haddock/cns/toppar/dmso.pdb,sha256=in1vU16IwxIYK00FzxQjxeEHtQbTA9Kbq0LZ0KzhvEM,57626
+haddock/cns/toppar/dna-rna-1.3.link,sha256=FugBWXkMYrc6m0wmptr01bKLCPC8KmS5jmt1BIj3ylU,2259
+haddock/cns/toppar/dna-rna-CG-MARTINI-2-1p-break.top,sha256=SZ2x6DLH5wcyz3SoHBNtUATt2qiqLanYnfokzfNoRAM,499
+haddock/cns/toppar/dna-rna-CG-MARTINI-2-1p.link,sha256=SF_9DDUQgVImO_whCjop8kImw4oxAmaipztiZ2NeB98,1267
+haddock/cns/toppar/dna-rna-CG-MARTINI-2-1p.param,sha256=gPlvW0DGdmzfK7ORBvkLNnIzW2XCWlFL361MZmGjUBY,76501
+haddock/cns/toppar/dna-rna-CG-MARTINI-2-1p.top,sha256=1sLHl25iT5QhtxwWLd-koiPEUcBaZbZAscMTYj-6hrU,8756
+haddock/cns/toppar/dna-rna-allatom-hj-opls-1.3.param,sha256=5W5PHA9vJFvrzbDWrnCl8L2a8Ihp9PT3hNEZTykETN0,62721
+haddock/cns/toppar/dna-rna-allatom-hj-opls-1.3.top,sha256=BKACbR5dmo3yB_or_zLM_7A6erILgdiwySdHJRpM2xA,38255
+haddock/cns/toppar/dna-rna-pho-1.3.link,sha256=TAdg38H-8aR1WbtHDlGyyvXueRGjFYdS5La7TAkmyW8,2230
+haddock/cns/toppar/dna_break.top,sha256=jNWk98MIiiuVAv-D7nbsCz4VRJbyxXA7mOefOYl0J78,553
+haddock/cns/toppar/fragment_probes.param,sha256=WkjBh_7xOdtQnnC5iMT3FAdMC-hPAjzhx5sibl3Cw9Q,27601
+haddock/cns/toppar/fragment_probes.top,sha256=dqwqOyLA3dKrnHjdMYCJLy2jML8VZhWJTv8eD1_vtOM,60109
+haddock/cns/toppar/heme.pdb,sha256=dIRbmE_a1TxTvpx8nFxWuYVjr-Fa9ED7uiFobxsV7GA,6372
+haddock/cns/toppar/heme.psf,sha256=AO7A04zsDO6c_77JNmAo2neBmbLznohXejdIVPh1gGU,7674
+haddock/cns/toppar/hemeB.pdb,sha256=CUBqwwh0afEIPoqWh1HXzYQIFIZs7wc2YGg_97bbMr0,5746
+haddock/cns/toppar/hemeB.psf,sha256=6GAfkNHU1qEmWtb0DPVD1f7OxrwkENe9Jf0m52eFzQI,14147
+haddock/cns/toppar/hemes-allhdg.param,sha256=tWeMEsN27BGNm7SxIfNJRGLkU3Asc51LUJhScFPKKqU,11258
+haddock/cns/toppar/hemes-allhdg.top,sha256=3NRn1rwAOnS9MeVrQ2_28C6yl3lraR7-gL2PpKPBqtU,19060
+haddock/cns/toppar/hemes.pep,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haddock/cns/toppar/initial_positions/trans_vector_0,sha256=SwBBT7HxN1lS4_7Lv-C6Nuln3RLzCP1y9Wow4DVnmXY,114
+haddock/cns/toppar/initial_positions/trans_vector_1,sha256=rtjduBEEzPBSHQ0gB0_XhHLGeMIp1XVQRaGrddmKRaA,117
+haddock/cns/toppar/initial_positions/trans_vector_10,sha256=32pz0VLs4s31FrvxB0K46WlN9u7U72tqx9K-3QvE7bo,1189
+haddock/cns/toppar/initial_positions/trans_vector_11,sha256=KVJgv3lu5ma0DdKSlhM7b6pMtMxWgZ2V3xQ-4o_nTEI,1310
+haddock/cns/toppar/initial_positions/trans_vector_12,sha256=iXXjxf7-hC2hr-f1-nuLKQAROiwpU1TlBfmkW0plu3E,1431
+haddock/cns/toppar/initial_positions/trans_vector_13,sha256=Z6Z31uhsvOrIYuWf70D4qMClfW_A16avVM8FjNw5GPQ,1552
+haddock/cns/toppar/initial_positions/trans_vector_14,sha256=MIw7czOW-HiA0o_z4kh5rWxc0dhszpqNccs5gA_M_O8,1674
+haddock/cns/toppar/initial_positions/trans_vector_15,sha256=6Y6T1AQ1jLu7dspPUDSo7hGDpZ_xu3hyYnBUONh5TcQ,1795
+haddock/cns/toppar/initial_positions/trans_vector_16,sha256=IFWYxzto9yFNw_ji4vHF5dtyVD8Wwz_zqtck7sxkHyU,1918
+haddock/cns/toppar/initial_positions/trans_vector_17,sha256=EaxylLQsSGoQd5DAZl-T1qMJ7O6k_WcGFuNwc8bN-Jw,2038
+haddock/cns/toppar/initial_positions/trans_vector_18,sha256=YhCaxXSpINoWUvjKJHtBysbj0SyqMyQc72dPS0I97KI,2160
+haddock/cns/toppar/initial_positions/trans_vector_19,sha256=Mfz8J0K-qaQTQv_d6J_KdHGoQMQjABY4-qTWjD-f8DU,2281
+haddock/cns/toppar/initial_positions/trans_vector_2,sha256=GPonFreK6rDPuXricSRuEpIzgBXSNRUNQmM-zxUXTcw,237
+haddock/cns/toppar/initial_positions/trans_vector_20,sha256=ODBLpHkiI7B-BeYmeRyBL7182HaX3ymH0EUfPk2yv7U,2403
+haddock/cns/toppar/initial_positions/trans_vector_21,sha256=LsnG3uIodEESa5dU0ce3NLSc-XdivibppxraS5cGfTY,2524
+haddock/cns/toppar/initial_positions/trans_vector_22,sha256=6X2ZJrO2v74Z82f1z-DYO9ig-TCbOnE_ZL9drC0Yj38,2645
+haddock/cns/toppar/initial_positions/trans_vector_23,sha256=JvaB2-s36qbj0jjjQYFUnx8Qq7U9AkGipCXE8hcc94Y,2766
+haddock/cns/toppar/initial_positions/trans_vector_24,sha256=TZseOIIOUBV13vTHUawpqOsA-ZBpWRkEohVFg5NybQE,2887
+haddock/cns/toppar/initial_positions/trans_vector_25,sha256=jbv61_C9SBrRieeezOJL6o4VdYyEPRVMInuH7i8r17c,3010
+haddock/cns/toppar/initial_positions/trans_vector_26,sha256=SNR8glIMs4FxrlnluzQrunRriSWYBfJM80r5poFRd70,3133
+haddock/cns/toppar/initial_positions/trans_vector_27,sha256=HOgRJTe02k1nUAFUTIRuRBmSlO9v6k-LyjTytazjfc8,3253
+haddock/cns/toppar/initial_positions/trans_vector_28,sha256=cCXRYBF57mrBvk6nys0YEVwiZr5r8RI6xY0HtLWRyDE,3376
+haddock/cns/toppar/initial_positions/trans_vector_29,sha256=8pk1hA6-6sltWoHAAQnT6BbRKmIKdY-L-ep0tiN0-Vc,3497
+haddock/cns/toppar/initial_positions/trans_vector_3,sha256=pbeRX5_vbSFuAGRPkKF2z4ocjPUvt9GiXcEoJrxpgAw,354
+haddock/cns/toppar/initial_positions/trans_vector_30,sha256=9z4s49cys49ZVZ2Clx2iGHCPqmTYdxzjLkUpinnPQvA,3618
+haddock/cns/toppar/initial_positions/trans_vector_31,sha256=CNqWOwLO94DpfpfHBJCMQF2_PBt6rdMes4GTVuRgp4A,3740
+haddock/cns/toppar/initial_positions/trans_vector_32,sha256=f3RkyjF9cbfpOGC_BLNOqRrGtLkzuLQ5uM9WVh_XmNs,3861
+haddock/cns/toppar/initial_positions/trans_vector_33,sha256=vp_i7RtNAoCrp_3qZ3dGp6qylVgWJ6JHewSOe5ZRrdk,3981
+haddock/cns/toppar/initial_positions/trans_vector_34,sha256=VuePwiByUCWn782UBW9-_R-B0iLEGd1ly93Qy0NCF9M,4103
+haddock/cns/toppar/initial_positions/trans_vector_35,sha256=HY5NNYbKDTv5pReRTMha-dEhxVjPRHfArmorkXARzVI,4226
+haddock/cns/toppar/initial_positions/trans_vector_36,sha256=qSUHqc4NXWNFOjunMYhBdne0nKDuUBKbt2ri2vkuGDE,4347
+haddock/cns/toppar/initial_positions/trans_vector_37,sha256=cabhHC2gbUAV-ua4BdhhHQRT_VAflOlOJMJ7nfidmIQ,4469
+haddock/cns/toppar/initial_positions/trans_vector_38,sha256=G-_8b9YYa5o6dXbgNrborVMKBdWwMDM9zqOiMQLHCJo,4590
+haddock/cns/toppar/initial_positions/trans_vector_39,sha256=QfQuaGCg746MM7sWrOiUFhvkGCWK7CqdPGMSxENoCKI,4713
+haddock/cns/toppar/initial_positions/trans_vector_4,sha256=KQX0wW1AeAvuf53HsNBzGXQkQ7bZDL1cFr-SUbAxhEc,473
+haddock/cns/toppar/initial_positions/trans_vector_40,sha256=M0drggL_YM04LxUgN0-oPXFfKsGVhOvsLL-osiXhlQM,4834
+haddock/cns/toppar/initial_positions/trans_vector_41,sha256=6MNh7CpvoxHY1-4bFlXa6x4b2GOygGbsovxBeU23x40,4958
+haddock/cns/toppar/initial_positions/trans_vector_42,sha256=yPXV9K00LiWw6dh5oWsI1KFq2eFGpqdgc5TtNOYyFEA,5076
+haddock/cns/toppar/initial_positions/trans_vector_43,sha256=44heeC_5LKC2QE4t5-jCHxwMnBAkog3p8mzr5PdNiLc,5197
+haddock/cns/toppar/initial_positions/trans_vector_44,sha256=t8ruh9HCr-PPs_n3otR83TfK1aQDO3wS3dX0kZWGqtc,5319
+haddock/cns/toppar/initial_positions/trans_vector_45,sha256=DQiDSGzGyUwjoDmZ5sQ9GgKJIwp6ORNc5a1iXqO9PSk,5441
+haddock/cns/toppar/initial_positions/trans_vector_46,sha256=c4pDHAHFeDmCsJK6uQa98Z3L6zHGM4JjFUvdjMflk6w,5561
+haddock/cns/toppar/initial_positions/trans_vector_47,sha256=c33i0zyY4PWNSR0VIUktvvQBbLW-dzOwD9hVKaRV2wA,5684
+haddock/cns/toppar/initial_positions/trans_vector_48,sha256=rXq0tH2X6ti4XggzLXjuM1bgK1SHMGDE_hWSaRwpS8s,5805
+haddock/cns/toppar/initial_positions/trans_vector_49,sha256=QYw2KQMINmghAok-OhixWHdC2shDiKeq9CDCYAu98eg,5927
+haddock/cns/toppar/initial_positions/trans_vector_5,sha256=LYAdBIeAZphgR9FVnwA1rHaITSdLw66WHKolliA4zlI,592
+haddock/cns/toppar/initial_positions/trans_vector_50,sha256=f9VzoGOVTr02Q6JJ_LeNZYb5oklx5ZddFpFmDNP_zA8,6049
+haddock/cns/toppar/initial_positions/trans_vector_6,sha256=M2MYuXSCQ-Di1CFgcHDtv7LJ7HEW2_DeXHIu9RRsSgY,711
+haddock/cns/toppar/initial_positions/trans_vector_7,sha256=rqZC9pS6I4jywcIB7-kHcvpPN2BEq-eLJVvFitNccZI,831
+haddock/cns/toppar/initial_positions/trans_vector_8,sha256=-5Zxpbwwm2FF1dJXn57e8Wii0aRxCs8WzeWDzNXAI7E,950
+haddock/cns/toppar/initial_positions/trans_vector_9,sha256=MkreysXN4ZqX-HIX0ghG-ju3n6wzy6Nfsl9dSS-D-10,1067
+haddock/cns/toppar/ion.param,sha256=hv0AZDT9-1oNa8mQN1nRJ6Cqkt5gPw1X3u_QwnFVk-4,5179
+haddock/cns/toppar/ion.top,sha256=tUWJkmafNh4q9tiDnrfGdAgMT-87RJ8GVQnzfVl7_fw,10961
+haddock/cns/toppar/metalcenter.tbl,sha256=nE6urZxJZXq1kJcEHRGNwJg8V8kAXxXnN8AWx93uJQo,160
+haddock/cns/toppar/par_axis.pro,sha256=QcvLoIrq12XuQNJlypyGNg0_CNp_Zh0Hhh7RORtsCz0,700
+haddock/cns/toppar/par_axis_dani.pro,sha256=qewpcxTdFm74WZ1GbB98NKt5WRX0ZqcEAeAeFCKoyN8,652
+haddock/cns/toppar/protein-CG-Martini-2-2.link,sha256=R-JGxuijAbjpq5L2ikjl2gnQ_vrx_RL5KZvb8za78FQ,56248
+haddock/cns/toppar/protein-CG-Martini-2-2.param,sha256=QgHFxgd805NxI84pDhaatYkAbUmOGMTMVCVh4KcQXaM,1404087
+haddock/cns/toppar/protein-CG-Martini-2-2.top,sha256=DnmVsFid_xacYmmh7uPnIbt9ImvaiSkyq3XtsHSMRGk,7823
+haddock/cns/toppar/protein-CG-Martini.link,sha256=R-JGxuijAbjpq5L2ikjl2gnQ_vrx_RL5KZvb8za78FQ,56248
+haddock/cns/toppar/protein-CG-Martini.param,sha256=1SZ1ajgJltklg5b0qqGmGcotiBYDZTNzQmSz8TiHKTc,1833141
+haddock/cns/toppar/protein-CG-Martini.top,sha256=F87Xg0vU5_sCV26G7wf1U7dSzenBXzv8uVrRmgWJE74,7303
+haddock/cns/toppar/protein-allhdg5-4-noCter.link,sha256=MSGO8LLiT1O6L4ODQQrD--9zvSwSRyU04aZLlamDokM,94690
+haddock/cns/toppar/protein-allhdg5-4-noNter.link,sha256=nAQpiIU5pxmkkkx0GF32VYymGgvgO5lDj_KoFzV370I,94589
+haddock/cns/toppar/protein-allhdg5-4-noter.link,sha256=1tiK4XQ1Lt2O5ipdM6w2hBQQzeDp7-J-lePhkdPNrLA,93387
+haddock/cns/toppar/protein-allhdg5-4.link,sha256=YIVnKQ4LUEE88qi0PwgXyYPAa7Z54AlH1a07H4DEPPI,95891
+haddock/cns/toppar/protein-allhdg5-4.param,sha256=8h30h3ieGkRro1_or2bDz1U2TaqMUjAaK6_T3tf9W2k,119314
+haddock/cns/toppar/protein-allhdg5-4.top,sha256=1c37BXS6tGAJCIMJy2Ry2Hce-j7aBfRsDTPnzdxXFlE,106529
+haddock/cns/toppar/scatter.lib,sha256=QbuDzDND0nXUHnPGE1j5xjMU4eG9gghXoafMgWjkn3M,27508
+haddock/cns/toppar/shape.param,sha256=3Ns17S4SR6WqXLq6hU1-yb1SDVl4L1i4o5ejsAHLgYU,229
+haddock/cns/toppar/shape.top,sha256=e4V32_I13vtNPGdJLihWgh-lWNzFSKKWN0JnscgdZNQ,352
+haddock/cns/toppar/solvent-allhdg5-4.param,sha256=BaapuWG0qUlTQjUvYgB5QZjbErnRVHI-3HuJi4eDQ0w,1376
+haddock/cns/toppar/solvent-allhdg5-4.top,sha256=SzVG8KirJ460WHS0YSaAuWqxRg7kivtHrr1ErEcju44,3983
+haddock/cns/toppar/tensor.pdb,sha256=FxQeD9NNeaNAlDwldq0dgHm5_RFWcxu0SUBuHJWFs0A,3253
+haddock/cns/toppar/tensor.psf,sha256=WcmWCaVK33MnfCneVRWkj3AKFzd3UFRVJJLlm-YycaM,3303
+haddock/cns/toppar/tensor_dani.pdb,sha256=WWshNHksvNUOvAlgfMpQs-oETqph2kFmqaM6AIxeFLc,1750
+haddock/cns/toppar/tensor_dani.psf,sha256=qq0Uef1h1q2dbJO0i1JdAX_cR-dBi3AlR2RLDbvfqtk,2135
+haddock/cns/toppar/tensor_para.pdb,sha256=QUUM3dPUW3x0L5zJYAIsg_TwKsadzQPtRsFoKMVmH2o,3260
+haddock/cns/toppar/tensor_para.psf,sha256=deVGT8ZwFqE4YjNhOLE5hHzlbRbWMdnVPfwe0XU2IT8,3430
+haddock/cns/toppar/top_axis.pro,sha256=Z-Sikf-PDxIQG67l-SphHbUo-B7dJkR0HhmyjSDRL9Y,976
+haddock/cns/toppar/top_axis_dani.pro,sha256=XgxnQVlXDm45_VHPM7wNEsjKjhIAuOKeUq1tbh5j2yc,533
+haddock/core/__init__.py,sha256=LvOBCQzcgwxQPixN3ae2TjxXlDdjw0Ax2Rds4h1UFEE,39
+haddock/core/__pycache__/__init__.cpython-312.pyc,,
+haddock/core/__pycache__/cns_paths.cpython-312.pyc,,
+haddock/core/__pycache__/defaults.cpython-312.pyc,,
+haddock/core/__pycache__/exceptions.cpython-312.pyc,,
+haddock/core/__pycache__/supported_molecules.cpython-312.pyc,,
+haddock/core/__pycache__/typing.cpython-312.pyc,,
+haddock/core/cns_paths.py,sha256=qJyE6Z-Uty5by6OiYXm60_tVv84j53t3vwHYCe7Cb7Y,2828
+haddock/core/defaults.py,sha256=yKknPzxichto_jG3ZJ48wsSAcyrpZPmROdmzJMwKI7I,1413
+haddock/core/exceptions.py,sha256=T86eYzR0biAFyIt2XKEtjoEjH5DiXZm8PT6e_fGlVIQ,1535
+haddock/core/mandatory.yaml,sha256=wX-qX6eZN_r8hWOq7viqzrcXv4A9XpZDpIQelApHtqU,496
+haddock/core/optional.yaml,sha256=cNkWKEPh6I6PspNb4x4IUUt-5YKCKVMYGq9ObO9pGQU,1590
+haddock/core/supported_molecules.py,sha256=ilmim2ZnlWpoYPWvjgpXBAbo43wfM_quRkVe5Foh3hA,16077
+haddock/core/typing.py,sha256=zVKozQwtcohx-Lfa8HM8y4fx_xi5ti1z2Zv99_e_BcE,4555
+haddock/deps/contact_fcc.cpp,sha256=ITn5R6VQmurHZ2XEuNpC0aeu54YbDgXZekpOshvTOKs,2948
+haddock/deps/fast-rmsdmatrix.c,sha256=IXXeREAcNmrWKcCHvLRG1_4IzA5noeY-1je4HbHCJbE,29676
+haddock/fcc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haddock/fcc/__pycache__/__init__.cpython-312.pyc,,
+haddock/fcc/__pycache__/calc_fcc_matrix.cpython-312.pyc,,
+haddock/fcc/__pycache__/cluster_fcc.cpython-312.pyc,,
+haddock/fcc/calc_fcc_matrix.py,sha256=L1I-q5PZLGRwtw365y3rXchX6bqtm-XfS9cOujVIT5k,2453
+haddock/fcc/cluster_fcc.py,sha256=uRL_hM6ObhHSL_IMLhzIk8SyunZC5u5aWO-bIid1hpA,4628
+haddock/gear/__init__.py,sha256=DISpBt2ms1ySWT0xuSistlspfN9pzeXEcX53-U222Ec,274
+haddock/gear/__pycache__/__init__.cpython-312.pyc,,
+haddock/gear/__pycache__/clean_steps.cpython-312.pyc,,
+haddock/gear/__pycache__/config.cpython-312.pyc,,
+haddock/gear/__pycache__/expandable_parameters.cpython-312.pyc,,
+haddock/gear/__pycache__/extend_run.cpython-312.pyc,,
+haddock/gear/__pycache__/greetings.cpython-312.pyc,,
+haddock/gear/__pycache__/haddockmodel.cpython-312.pyc,,
+haddock/gear/__pycache__/known_cns_errors.cpython-312.pyc,,
+haddock/gear/__pycache__/parameters.cpython-312.pyc,,
+haddock/gear/__pycache__/postprocessing.cpython-312.pyc,,
+haddock/gear/__pycache__/prepare_run.cpython-312.pyc,,
+haddock/gear/__pycache__/preprocessing.cpython-312.pyc,,
+haddock/gear/__pycache__/restart_run.cpython-312.pyc,,
+haddock/gear/__pycache__/validations.cpython-312.pyc,,
+haddock/gear/__pycache__/yaml2cfg.cpython-312.pyc,,
+haddock/gear/__pycache__/zerofill.cpython-312.pyc,,
+haddock/gear/clean_steps.py,sha256=rOlXliZ93XrRwU-WfpUuu6-FT37AYoRxMOBej-Dd5jM,7379
+haddock/gear/config.py,sha256=oH2Wnzf4HF7f5sU1noE3aDzBWn1vOZatevaScAHaUGY,9820
+haddock/gear/expandable_parameters.py,sha256=AtHl24Fw7Qeqd22lJjwxIU96GV7zNZrQjm1PxMiM5aY,27121
+haddock/gear/extend_run.py,sha256=RlrnlGdyYeo2Y4fWRUKB6AciIUE7K-Nv2WNucvlaDow,8139
+haddock/gear/greetings.py,sha256=OWfnxg-_RN3gjBNMg_1Ec3ukX2eIZRlXrjyc_TsCIAk,3516
+haddock/gear/haddockmodel.py,sha256=2xBtLlMkYsOd7CQ0Qq2RyKV7XowRcJlhURE_n14_XRA,5437
+haddock/gear/known_cns_errors.py,sha256=CDtBJ1RSWBmRAJzuiCT5BrfCC5Ch2Hw_hOR3J130zr8,6910
+haddock/gear/parameters.py,sha256=e7ZAOzOZzijlKWHTqeDgHP-QGu0HKCdlinc6Klk3M68,749
+haddock/gear/postprocessing.py,sha256=xnNurZ8P5VYRb1TeZOYOwM2ZC8LQYJdqQP0qIeMJN1k,1439
+haddock/gear/prepare_run.py,sha256=b9JXlHSrDBwucLbTezMYVOfA_TRx0YKDBTEajTjLpKc,47960
+haddock/gear/preprocessing.py,sha256=IoJivA3VDBhfK_3nj2LrKHmZQUyDjKYdMtAW7_iO3ls,31188
+haddock/gear/restart_run.py,sha256=QO6ROHqg24m36r1_NkEyPJ1eX57QZSo1M8d8xMaIWis,1803
+haddock/gear/validations.py,sha256=79Hii60bB58g4NJziYPQWh3rm4u70gvj0u1Ff9KNBzI,4376
+haddock/gear/yaml2cfg.py,sha256=DATeKFsLJv2Ly506O_J20wqmbLncbzDL6l21Yl4vw94,9133
+haddock/gear/zerofill.py,sha256=TesdOODdbIKdekwXRaO4l2jdggo5P7lMYGwBGVgXhn8,3373
+haddock/libs/__init__.py,sha256=v4-UCEx7R8hJRTKSBQzPvkyXnQb6q7hvkQCmPVA6AnU,47
+haddock/libs/__pycache__/__init__.cpython-312.pyc,,
+haddock/libs/__pycache__/libalign.cpython-312.pyc,,
+haddock/libs/__pycache__/libcli.cpython-312.pyc,,
+haddock/libs/__pycache__/libclust.cpython-312.pyc,,
+haddock/libs/__pycache__/libcns.cpython-312.pyc,,
+haddock/libs/__pycache__/libfcc.cpython-312.pyc,,
+haddock/libs/__pycache__/libfunc.cpython-312.pyc,,
+haddock/libs/__pycache__/libgrid.cpython-312.pyc,,
+haddock/libs/__pycache__/libhpc.cpython-312.pyc,,
+haddock/libs/__pycache__/libinteractive.cpython-312.pyc,,
+haddock/libs/__pycache__/libio.cpython-312.pyc,,
+haddock/libs/__pycache__/libligand.cpython-312.pyc,,
+haddock/libs/__pycache__/liblog.cpython-312.pyc,,
+haddock/libs/__pycache__/libmath.cpython-312.pyc,,
+haddock/libs/__pycache__/libmpi.cpython-312.pyc,,
+haddock/libs/__pycache__/libnotebooks.cpython-312.pyc,,
+haddock/libs/__pycache__/libontology.cpython-312.pyc,,
+haddock/libs/__pycache__/libparallel.cpython-312.pyc,,
+haddock/libs/__pycache__/libpdb.cpython-312.pyc,,
+haddock/libs/__pycache__/libplots.cpython-312.pyc,,
+haddock/libs/__pycache__/libprodigy.cpython-312.pyc,,
+haddock/libs/__pycache__/librestraints.cpython-312.pyc,,
+haddock/libs/__pycache__/libstructure.cpython-312.pyc,,
+haddock/libs/__pycache__/libsubprocess.cpython-312.pyc,,
+haddock/libs/__pycache__/libtimer.cpython-312.pyc,,
+haddock/libs/__pycache__/libutil.cpython-312.pyc,,
+haddock/libs/__pycache__/libworkflow.cpython-312.pyc,,
+haddock/libs/assets/__init__.py,sha256=OHnRgMfl3EKH39_jt29TsQgdlCh77a-S2ckhajnR5RE,361
+haddock/libs/assets/__pycache__/__init__.cpython-312.pyc,,
+haddock/libs/assets/index.css,sha256=zQhm56MPdkCiONjcDcbJGOJzxcsE62IwpoHpWMZ5LR0,10785
+haddock/libs/assets/report.bundle.js,sha256=wJLAYIGv-zCto98hmwFLB3dtsl7xpNdkjB6Fqx-rxpo,1481453
+haddock/libs/libalign.py,sha256=THxG3qZqWAQnJRkjTrHY77egeu1hQJ6iO66Fhc0nlY0,38721
+haddock/libs/libcli.py,sha256=jYvqc8-m9BUevDitjw4ps97mO_2-OQ_okECJ1wwloYM,2716
+haddock/libs/libclust.py,sha256=n7LG4n5bI0TCKJNP-6j2DwRBJOR2G-2JC7BnDeWOC4w,9655
+haddock/libs/libcns.py,sha256=4voTSRCv7VjAyy1JC4mfnamB-pDWNBBOenoqWefRbDo,14193
+haddock/libs/libfcc.py,sha256=zk8-uss90KFfBEsphXOVuz_jHn8pY9fcsholiL1od-s,6562
+haddock/libs/libfunc.py,sha256=Y6afr2DT7Rx42FBHoRm4TIL3qRueKldKKyW-s7Z8JZA,2274
+haddock/libs/libgrid.py,sha256=R0nC-f9A5hKK7kKgKw5c_mJ1IxFvvfr1JR-6SbvDyN4,29623
+haddock/libs/libhpc.py,sha256=EQpn5for3hRLkp6OrIx00t18ZvkjplOh04g88Ay7yf0,12354
+haddock/libs/libinteractive.py,sha256=WtO3vNf3pKpZ3rlzhflE9wb8zuztNTI3qTKoCGwfkmE,7329
+haddock/libs/libio.py,sha256=R3wDEO7YGYZZEFBvG7OKm6THq4JsELoRDMT0tK2-47E,16530
+haddock/libs/libligand.py,sha256=2CKBNWSXE0X49kRaigMu-GzdnZ2SAvsvco0wLhLrzkU,5462
+haddock/libs/liblog.py,sha256=xp1Qinu8Ct8LVHPEAVb4ik_mj48kK096GnBoMq6G37I,2333
+haddock/libs/libmath.py,sha256=PdPROXkAuA4Ujq7cfG-u8VsQjFTnO8nhM7gANqvVr5o,865
+haddock/libs/libmpi.py,sha256=yl_peJ6JNQpU-gNzCcY03Q9RGfFbxBzM6MQH-DZtwD8,1803
+haddock/libs/libnotebooks.py,sha256=wAO--cC-PGENU8-N-rqMnhdyV6RKuMj6jC42pllOF9w,9460
+haddock/libs/libontology.py,sha256=iTUJlmFc2u8Qy8w1Uem4zE1TeZ9pB93yB0me1GnY97k,8332
+haddock/libs/libparallel.py,sha256=2-EolmGZb5Av_MR5AROX5MaxfuMxL9TejWoqtym3zJo,6379
+haddock/libs/libpdb.py,sha256=IjNy6HCQlMvNc57QMf9tqrXOJj30SxpDuuwtGcNkmRU,16280
+haddock/libs/libplots.py,sha256=rMx85zZKQ5yWcMxG2ONwqxHbehG_ZCyb4Pl_rnWa3UI,49143
+haddock/libs/libprodigy.py,sha256=ofVMTELREPyxwJzVuLGPzehk7eNTWkgY2CDD_pALx4k,5026
+haddock/libs/librestraints.py,sha256=OBemuZSLFlfuubMox1lBQz0Ju8WkqWAmM-E29b-LuqU,28610
+haddock/libs/libstructure.py,sha256=uRPaaJsZPbiB7jyWFJwBeLwbA6OfEZbHavhxlrjK7f8,1367
+haddock/libs/libsubprocess.py,sha256=o8zQeOJ3BlhujxnL46irHd7uNYMQd0mGIQty-bGBnps,8033
+haddock/libs/libtimer.py,sha256=8vFHFbBSRM5AkJ4b-I4Ph4NYBMYEeYIZ5ttTu3tD2n4,1607
+haddock/libs/libutil.py,sha256=nso_xPfqlY0JUqUE2bF9DSCcpd-dq0ReWTk7y7xnNSI,14005
+haddock/libs/libworkflow.py,sha256=HhNYok2Wx0yRzsnelwKrndvrcp4zaWomLZI0nY_gGzM,7364
+haddock/modules/__init__.py,sha256=adGlrDRDtzl9ot3sz3jW3pfyTxGmIRYicn6S04uGaKM,17125
+haddock/modules/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/__pycache__/base_cns_module.cpython-312.pyc,,
+haddock/modules/_template_cat/README.md,sha256=q1EPD15gNjWwQa6QCTnlRhTBaBHZjMOMiWslkBM6LHM,1694
+haddock/modules/_template_cat/_template_mod/__init__.py,sha256=gbz7p-C7DbePqq3w0R9nuiD8ymnEs2N6nnxz_bEIPyQ,5548
+haddock/modules/_template_cat/_template_mod/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/_template_cat/_template_mod/defaults.yaml,sha256=EKZzFFd9tfO6_MNG9OGyM_6mLuVfeiuyffZcys2iTM4,1941
+haddock/modules/analysis/__init__.py,sha256=OUxBnttEXAAjGXnJWHJ8k-Jir8HyLzeqyEhtS9e9YDo,1926
+haddock/modules/analysis/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/analysis/alascan/__init__.py,sha256=EDeh6qzv1lpijgH5c6DELOG3JhIe5xzf-q5v9ibJQmw,7862
+haddock/modules/analysis/alascan/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/analysis/alascan/__pycache__/scan.cpython-312.pyc,,
+haddock/modules/analysis/alascan/defaults.yaml,sha256=C1EK-pA7YwPtWyfx4MChQ788P7WGSCFqO0zl1aHnK9Q,3753
+haddock/modules/analysis/alascan/scan.py,sha256=sp2KdjR3Sumk3_9mg3Ov57GbFoptethENSwJWC-z38A,33797
+haddock/modules/analysis/caprieval/__init__.py,sha256=trmXV9nFx-WdvcV8Rml6BnI1WbUk7ao0qR8LW5qWTpI,9880
+haddock/modules/analysis/caprieval/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/analysis/caprieval/__pycache__/capri.cpython-312.pyc,,
+haddock/modules/analysis/caprieval/capri.py,sha256=t2aLsqYCrWZiNKKf9kN_wCMN3zBCACYg_xDW10oJgPc,39733
+haddock/modules/analysis/caprieval/defaults.yaml,sha256=jRrJdXHmdQ78xgLJ46P_L2f63w9-TfYD9NN0a9Lck6k,6944
+haddock/modules/analysis/clustfcc/__init__.py,sha256=ZEKa0_hWYrzrCmsw_L5hnlonAJbvG4gZTlTDv0qE5EU,7456
+haddock/modules/analysis/clustfcc/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/analysis/clustfcc/__pycache__/clustfcc.cpython-312.pyc,,
+haddock/modules/analysis/clustfcc/clustfcc.py,sha256=U-CV-LcXxMbDGcAP0hCDP0GcFg8nDxjioL3KXM3siI8,6114
+haddock/modules/analysis/clustfcc/defaults.yaml,sha256=zoQGTLJtvDZwJdzZfI-vZpz9hN0Qvhn3PZ8eHPjl8QA,2519
+haddock/modules/analysis/clustrmsd/__init__.py,sha256=wB_zfn5Ray5SA6jlSruqeFc6NKwiEJA1isDy4QLsIgg,6350
+haddock/modules/analysis/clustrmsd/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/analysis/clustrmsd/__pycache__/clustrmsd.cpython-312.pyc,,
+haddock/modules/analysis/clustrmsd/clustrmsd.py,sha256=1AbNzmz0LnYczZnKB30iXZILBvBY19J2NfFDp6MCS_E,12387
+haddock/modules/analysis/clustrmsd/defaults.yaml,sha256=ko2SVYIfdXsZTeRXMtbr3W5HKNVrayR0fyWe7kW-B6k,2044
+haddock/modules/analysis/contactmap/__init__.py,sha256=XV1qnG_ZC1ou8envXBvhpDKRP1DA2fY-1F0SuqURyAA,4424
+haddock/modules/analysis/contactmap/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/analysis/contactmap/__pycache__/contmap.cpython-312.pyc,,
+haddock/modules/analysis/contactmap/contmap.py,sha256=Qv0-penTUsWCWvugHS7KwR8F81nu0egyfKyk4AHnpBs,74236
+haddock/modules/analysis/contactmap/defaults.yaml,sha256=3gMMRx7TXBaae9A1jIF9Z-yiPbgnvmcKmYNJ8DcRC8o,3263
+haddock/modules/analysis/filter/__init__.py,sha256=8dnxVQpOEJ6JlGL7TYKCRTg-_gxSsgkpkGvdypdRvek,3736
+haddock/modules/analysis/filter/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/analysis/filter/defaults.yaml,sha256=LaRHAWiGarOWQEvDjjB749G5TRk9LFGHORmC9S-WH0s,371
+haddock/modules/analysis/ilrmsdmatrix/__init__.py,sha256=Tg9DEGYxh1VaYUeIvPg_RNF9QyGd3TYD1Wskgfv7awI,14168
+haddock/modules/analysis/ilrmsdmatrix/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/analysis/ilrmsdmatrix/__pycache__/ilrmsd.cpython-312.pyc,,
+haddock/modules/analysis/ilrmsdmatrix/defaults.yaml,sha256=DmdQo293VbE1VUHIYdSbvuEFo8z222lt9Byk0g-i1SU,2474
+haddock/modules/analysis/ilrmsdmatrix/ilrmsd.py,sha256=asoMkpLtMoi_ScFIo3J7aDQAZqzzFSY6w-SJCotd6dk,3809
+haddock/modules/analysis/rmsdmatrix/__init__.py,sha256=C0vjkTQho3iW7FlLfmFz3kvAn3O_YKCm-mhJVsgRiWU,8373
+haddock/modules/analysis/rmsdmatrix/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/analysis/rmsdmatrix/__pycache__/rmsd.cpython-312.pyc,,
+haddock/modules/analysis/rmsdmatrix/defaults.yaml,sha256=cS_Y7XKiolEaNDFOltU00xjBzYMx5CoGrVciDmr4V68,1639
+haddock/modules/analysis/rmsdmatrix/rmsd.py,sha256=NEDc23-ITL7cbsRwObyETZgO25Iy_9nwMiT30sHfx1Y,3872
+haddock/modules/analysis/seletop/__init__.py,sha256=crGU45EQGDbKE8lBgRc5Bz396eVSMD9vzEv_fGYgAWs,2162
+haddock/modules/analysis/seletop/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/analysis/seletop/defaults.yaml,sha256=HpnqYme7nFFeyjKB6wg7or4dlzZN-61biyj0HTyJbNI,412
+haddock/modules/analysis/seletopclusts/__init__.py,sha256=vj8kudb81Y8wX832NWH43018l_DQxYCuXVKybHJRFEA,2908
+haddock/modules/analysis/seletopclusts/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/analysis/seletopclusts/__pycache__/seletopclusts.cpython-312.pyc,,
+haddock/modules/analysis/seletopclusts/defaults.yaml,sha256=dWxN_rdic4WRUTLzdiG2FAxqOMnKKrczMAEtfWhMlbY,1414
+haddock/modules/analysis/seletopclusts/seletopclusts.py,sha256=MOwuIyuJuRYc5ml58zOvi7H-Ko7T7ARe6whaqXs0EHc,7051
+haddock/modules/base_cns_module.py,sha256=OyrDmj4ed2lJkgy1ArBwjpzTYpKfv8xp8WL89EMvkd4,6366
+haddock/modules/defaults.yaml,sha256=xmAr6EZ03_u0Qy8P86R8eMJhaS86I4g1RY6u7kukKbw,6014
+haddock/modules/extras/__init__.py,sha256=cDHmAvelnn80uqO6ouvds1ahgFBIgI0DqFv9Z0Jo8rY,175
+haddock/modules/extras/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/extras/exit/__init__.py,sha256=37VlCgPBIiLU8vtFDgioJMRamTtK4SzTdCpTkf2w1RQ,1703
+haddock/modules/extras/exit/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/extras/exit/defaults.yaml,sha256=9OTiEcCv4zBEYfle2uTwAdmMEKazk5a6TuShUv1SEE8,238
+haddock/modules/refinement/__init__.py,sha256=cMG5Zt4JDKvNK207ct6FMJ0EgbmU0e_1L-V_ZXCsOZc,48
+haddock/modules/refinement/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/refinement/emref/__init__.py,sha256=bhWdqXv9M5MqTfihaGzz_q6WbCDby7T1RTE0XeofBWk,5143
+haddock/modules/refinement/emref/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/refinement/emref/cns/calc_free-ene.cns,sha256=oiXJjYSnG23nizBMv1D6YbeI-c4kDdQahRsuq0rn2w0,1116
+haddock/modules/refinement/emref/cns/check_coordinates.cns,sha256=diLUZz3XxMMb1towOaeWlGRiSNh72dgB5oX6tV57tFg,3015
+haddock/modules/refinement/emref/cns/contactairs.cns,sha256=LtMZm33ScEAnNE1J5HE-iQ95R8CtpTTCne4F23w7moc,1426
+haddock/modules/refinement/emref/cns/def_solv_param.cns,sha256=hRyLXwbnm7zoCidi_Eeztq-NvBjSiWIJfxo9WXcRzPo,4071
+haddock/modules/refinement/emref/cns/dna-rna_restraints.cns,sha256=gkljYrv7AqP3x9ujcjQYVSmhH6vknqW0GKmqyCBH-SY,19764
+haddock/modules/refinement/emref/cns/emref.cns,sha256=HKePIsUY7IUdYEU3T0f5K-yelyDXakuZuhsmBcWktdo,13409
+haddock/modules/refinement/emref/cns/flex_segment_back.cns,sha256=ZcURFVmlEIXHw96PSZ-GPmM_IyrCivG5A_8AKotuSQw,2320
+haddock/modules/refinement/emref/cns/flexauto-neighbors.cns,sha256=TysMjn197bNZ1gPSty-f0341t5fHc-K-I4aEvfE2-DA,1934
+haddock/modules/refinement/emref/cns/print_coorheader.cns,sha256=AdRuACCZ5TIWwBPuSVXVvQhD6728rIUxhwtN4yiLWmw,12246
+haddock/modules/refinement/emref/cns/protein-ss-restraints-all.cns,sha256=Ng7k_RoSrORIj77EFUIPuQ5xLwqMkcTw8byDF6ets70,4239
+haddock/modules/refinement/emref/cns/protein-ss-restraints-alpha-beta.cns,sha256=v02vtd4tzMDvoLr9tQgAkiKah2yJGBUJ0ufO8-8r2IE,6002
+haddock/modules/refinement/emref/cns/protein-ss-restraints-alpha.cns,sha256=zp_fje9KlUkwrqN9C6RVoXtAo674GEj69AmAALuLz48,5163
+haddock/modules/refinement/emref/cns/read_data.cns,sha256=5timDjMPd5_cTA8djQjuLxoIBBhOAwefdlFOj-BE6ms,2026
+haddock/modules/refinement/emref/cns/read_noes.cns,sha256=nLADAFcVjbJ-WN8Zza5mgYZFkvZNldL9feUidQRVN1I,1817
+haddock/modules/refinement/emref/cns/read_param.cns,sha256=Dm_oGn9aIJILPsFIa1RvAp21w5AeekXLxJLdh7u9BXY,2021
+haddock/modules/refinement/emref/cns/restrain-ions.cns,sha256=gb6AqflQscIatvKUSXno6wO6G2-kbncNNwaId2b5J7U,5237
+haddock/modules/refinement/emref/cns/scale_inter.cns,sha256=mKIJ7R65tB9DuqAMCOfADPW2vZY5aFnFvo-Xkxjxy_w,2349
+haddock/modules/refinement/emref/cns/scale_inter_final.cns,sha256=WPncZ_1Rp757GyOZL9YFp0ONAfpIzV7WW6Lvrhy4LNQ,1836
+haddock/modules/refinement/emref/cns/scale_intra_only.cns,sha256=BIA9k5ETYoSswYiZXTnVaE5g6N7k0TTIhhG-Amot3Q8,1489
+haddock/modules/refinement/emref/cns/setflags.cns,sha256=BWCTCEU-7i6rDsArjZ_EWJd6pe-sj275phmD9EJs0Es,771
+haddock/modules/refinement/emref/cns/symmultimer.cns,sha256=v-RvMEcmhxmwJgetDufqr2OHO9JTOaHIU1cm_vshTf8,32233
+haddock/modules/refinement/emref/defaults.yaml,sha256=SjCKBbTRPrqWGc7v-dd19_jFzI7G2x0-zXH0dBL2sU8,162391
+haddock/modules/refinement/flexref/__init__.py,sha256=dSHD9Rbwl9CZnWX2oen9HXX5FYhtC3pIAs2zBiOGflM,5835
+haddock/modules/refinement/flexref/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/refinement/flexref/cns/calc_free-ene.cns,sha256=oiXJjYSnG23nizBMv1D6YbeI-c4kDdQahRsuq0rn2w0,1116
+haddock/modules/refinement/flexref/cns/check-homomers.cns,sha256=t0rPTSXU44EPwZ-Q6Av73QyEXjaYvjzAHXm7FGIQZms,1736
+haddock/modules/refinement/flexref/cns/check_coordinates.cns,sha256=diLUZz3XxMMb1towOaeWlGRiSNh72dgB5oX6tV57tFg,3015
+haddock/modules/refinement/flexref/cns/cm-restraints.cns,sha256=31ZR8M-kl5i4VoJcihgMCZTxjwvla3yfi7gWXYgUSJ4,5043
+haddock/modules/refinement/flexref/cns/contactairs.cns,sha256=LtMZm33ScEAnNE1J5HE-iQ95R8CtpTTCne4F23w7moc,1426
+haddock/modules/refinement/flexref/cns/covalions.cns,sha256=V5UzRQ7iWJPzu3eDxGAbHYX_9ao9eSIBycUo78Zsg5o,3912
+haddock/modules/refinement/flexref/cns/def_solv_param.cns,sha256=hRyLXwbnm7zoCidi_Eeztq-NvBjSiWIJfxo9WXcRzPo,4071
+haddock/modules/refinement/flexref/cns/dna-rna_restraints.cns,sha256=gkljYrv7AqP3x9ujcjQYVSmhH6vknqW0GKmqyCBH-SY,19764
+haddock/modules/refinement/flexref/cns/flex_segment.cns,sha256=kMA5ImQM1njQQ3xTlT4VxqL2FZyIwUlFZ7zKJR0cycg,1243
+haddock/modules/refinement/flexref/cns/flex_segment_back.cns,sha256=ZcURFVmlEIXHw96PSZ-GPmM_IyrCivG5A_8AKotuSQw,2320
+haddock/modules/refinement/flexref/cns/flex_segment_side.cns,sha256=tOdJBjWTb-17NM0LCxKXLC9iNIareaEXHNAkrGfHq4c,2552
+haddock/modules/refinement/flexref/cns/flexauto-neighbors.cns,sha256=TysMjn197bNZ1gPSty-f0341t5fHc-K-I4aEvfE2-DA,1934
+haddock/modules/refinement/flexref/cns/flexref.cns,sha256=xscNwfyX-7gj5BA-4_qkx7rL-8pl8x1Xd7m4rMFNjN8,18672
+haddock/modules/refinement/flexref/cns/numtrees.cns,sha256=vJ3TVqvRuGzRAnBK5r6FCFogOxIsbvbezyk1xzfO8mE,3281
+haddock/modules/refinement/flexref/cns/print_coorheader.cns,sha256=AdRuACCZ5TIWwBPuSVXVvQhD6728rIUxhwtN4yiLWmw,12246
+haddock/modules/refinement/flexref/cns/protein-ss-restraints-all.cns,sha256=Ng7k_RoSrORIj77EFUIPuQ5xLwqMkcTw8byDF6ets70,4239
+haddock/modules/refinement/flexref/cns/protein-ss-restraints-alpha-beta.cns,sha256=v02vtd4tzMDvoLr9tQgAkiKah2yJGBUJ0ufO8-8r2IE,6002
+haddock/modules/refinement/flexref/cns/protein-ss-restraints-alpha.cns,sha256=zp_fje9KlUkwrqN9C6RVoXtAo674GEj69AmAALuLz48,5163
+haddock/modules/refinement/flexref/cns/random_rotations.cns,sha256=6XnCXDtAMmtkbvIolx8BctAKxz8lTMw79zRom_tJtVk,7800
+haddock/modules/refinement/flexref/cns/read_data.cns,sha256=5timDjMPd5_cTA8djQjuLxoIBBhOAwefdlFOj-BE6ms,2026
+haddock/modules/refinement/flexref/cns/read_noes.cns,sha256=nLADAFcVjbJ-WN8Zza5mgYZFkvZNldL9feUidQRVN1I,1817
+haddock/modules/refinement/flexref/cns/read_param.cns,sha256=Dm_oGn9aIJILPsFIa1RvAp21w5AeekXLxJLdh7u9BXY,2021
+haddock/modules/refinement/flexref/cns/restrain-ions.cns,sha256=gb6AqflQscIatvKUSXno6wO6G2-kbncNNwaId2b5J7U,5237
+haddock/modules/refinement/flexref/cns/sa_ltad_cool1.cns,sha256=_WhHrttAUlWUHG4KSESfRIPkcvAxm7CpZm9COAhzW0A,3809
+haddock/modules/refinement/flexref/cns/sa_ltad_cool2.cns,sha256=HPNvgZ7n0zHjPz84fzJIIeyzL_VelU8_9SoAVoPjIE0,3868
+haddock/modules/refinement/flexref/cns/sa_ltad_cool3.cns,sha256=n35MVRjpa0lKSHtFc-KK9PbCXOr6tdS5GWrFCqr9hJ0,3867
+haddock/modules/refinement/flexref/cns/sa_ltad_hightemp.cns,sha256=9kR5ji8ehi4eIafTgh8U8FnnNsuauU02dodZOlxEXGM,1818
+haddock/modules/refinement/flexref/cns/scale_inter.cns,sha256=mKIJ7R65tB9DuqAMCOfADPW2vZY5aFnFvo-Xkxjxy_w,2349
+haddock/modules/refinement/flexref/cns/scale_inter_final.cns,sha256=WPncZ_1Rp757GyOZL9YFp0ONAfpIzV7WW6Lvrhy4LNQ,1836
+haddock/modules/refinement/flexref/cns/scale_inter_only.cns,sha256=MfJwiYsd8Vn8R-Qbaiq02maAI6E89yC-Fg07E3rS2D8,2071
+haddock/modules/refinement/flexref/cns/scale_intra_only.cns,sha256=BIA9k5ETYoSswYiZXTnVaE5g6N7k0TTIhhG-Amot3Q8,1489
+haddock/modules/refinement/flexref/cns/separate.cns,sha256=s_mqxZNmhRNe94BTIsf9XiI_hI_JAbgI17KKn3aqcp8,9324
+haddock/modules/refinement/flexref/cns/setflags.cns,sha256=gllgQGuPPqtCHymIfuGIzvS8MglQzAcPzZRNFR6O9zI,850
+haddock/modules/refinement/flexref/cns/symmultimer.cns,sha256=v-RvMEcmhxmwJgetDufqr2OHO9JTOaHIU1cm_vshTf8,32233
+haddock/modules/refinement/flexref/cns/torsiontop.cns,sha256=5GivVQJOpUV6eFqYY_CMK_yEqDMQp4bLT7tHQQwFOs4,4595
+haddock/modules/refinement/flexref/defaults.yaml,sha256=llNeXA7UC1Qj3seiQaRxoQViba9m8jLxIE6VUh6_NFc,183524
+haddock/modules/refinement/mdref/__init__.py,sha256=y3mrMhmeT0ctA0ThZksvsOp1-9F2ix1u5Wh5YBtmg1g,5661
+haddock/modules/refinement/mdref/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/refinement/mdref/cns/calc_free-ene.cns,sha256=oiXJjYSnG23nizBMv1D6YbeI-c4kDdQahRsuq0rn2w0,1116
+haddock/modules/refinement/mdref/cns/check_coordinates.cns,sha256=diLUZz3XxMMb1towOaeWlGRiSNh72dgB5oX6tV57tFg,3015
+haddock/modules/refinement/mdref/cns/cm-restraints.cns,sha256=XqI2yLh8WagcEeY3VAObuUPrdgAeVvyGv4r-udFDfH0,5511
+haddock/modules/refinement/mdref/cns/contactairs.cns,sha256=LtMZm33ScEAnNE1J5HE-iQ95R8CtpTTCne4F23w7moc,1426
+haddock/modules/refinement/mdref/cns/def_solv_param.cns,sha256=hRyLXwbnm7zoCidi_Eeztq-NvBjSiWIJfxo9WXcRzPo,4071
+haddock/modules/refinement/mdref/cns/dna-rna_restraints.cns,sha256=gkljYrv7AqP3x9ujcjQYVSmhH6vknqW0GKmqyCBH-SY,19764
+haddock/modules/refinement/mdref/cns/flex_segment_back.cns,sha256=iysr0Gz16kj1IxvPDCA7VkW1rAmZv_qHoJIn1INCFGk,2263
+haddock/modules/refinement/mdref/cns/flex_segment_side.cns,sha256=LLv1xUQO-n5z7fSHb9fs5ro-Bj8JsVLHzlbSTBxwr3c,1906
+haddock/modules/refinement/mdref/cns/flexauto-neighbors.cns,sha256=TysMjn197bNZ1gPSty-f0341t5fHc-K-I4aEvfE2-DA,1934
+haddock/modules/refinement/mdref/cns/generate_dmso.cns,sha256=-wuKZONhjDS-EjnsLQmcuLzf6mjWTqs_HUBzPw6r49Y,5433
+haddock/modules/refinement/mdref/cns/generate_water.cns,sha256=GO6nyT7pXZtHKBE8mh9MT8q8dbntQxHEXMxeB_Eo3I0,5792
+haddock/modules/refinement/mdref/cns/mdref.cns,sha256=ryxfLCB2SLWSdnt2DZgS2Fxil0sU4J2v9bT8leJubTY,16910
+haddock/modules/refinement/mdref/cns/print_coorheader.cns,sha256=AdRuACCZ5TIWwBPuSVXVvQhD6728rIUxhwtN4yiLWmw,12246
+haddock/modules/refinement/mdref/cns/protein-ss-restraints-all.cns,sha256=Ng7k_RoSrORIj77EFUIPuQ5xLwqMkcTw8byDF6ets70,4239
+haddock/modules/refinement/mdref/cns/protein-ss-restraints-alpha-beta.cns,sha256=v02vtd4tzMDvoLr9tQgAkiKah2yJGBUJ0ufO8-8r2IE,6002
+haddock/modules/refinement/mdref/cns/protein-ss-restraints-alpha.cns,sha256=zp_fje9KlUkwrqN9C6RVoXtAo674GEj69AmAALuLz48,5163
+haddock/modules/refinement/mdref/cns/read_data.cns,sha256=5timDjMPd5_cTA8djQjuLxoIBBhOAwefdlFOj-BE6ms,2026
+haddock/modules/refinement/mdref/cns/read_noes.cns,sha256=nLADAFcVjbJ-WN8Zza5mgYZFkvZNldL9feUidQRVN1I,1817
+haddock/modules/refinement/mdref/cns/read_param.cns,sha256=Dm_oGn9aIJILPsFIa1RvAp21w5AeekXLxJLdh7u9BXY,2021
+haddock/modules/refinement/mdref/cns/restrain-ions.cns,sha256=QktROUdVSPaRC4ckEWjAsy0lY9sUZ6Rp1-2iDGfl3y4,5213
+haddock/modules/refinement/mdref/cns/scale_inter.cns,sha256=mKIJ7R65tB9DuqAMCOfADPW2vZY5aFnFvo-Xkxjxy_w,2349
+haddock/modules/refinement/mdref/cns/scale_inter_final.cns,sha256=WPncZ_1Rp757GyOZL9YFp0ONAfpIzV7WW6Lvrhy4LNQ,1836
+haddock/modules/refinement/mdref/cns/scale_intra_only.cns,sha256=BIA9k5ETYoSswYiZXTnVaE5g6N7k0TTIhhG-Amot3Q8,1489
+haddock/modules/refinement/mdref/cns/setflags.cns,sha256=BWCTCEU-7i6rDsArjZ_EWJd6pe-sj275phmD9EJs0Es,771
+haddock/modules/refinement/mdref/cns/symmultimer.cns,sha256=v-RvMEcmhxmwJgetDufqr2OHO9JTOaHIU1cm_vshTf8,32233
+haddock/modules/refinement/mdref/defaults.yaml,sha256=rfrSOsbTcZszZesA-Y_KEzPIBCanm89SBcosDhZB68Y,166304
+haddock/modules/refinement/openmm/__init__.py,sha256=XGNlzJZmG5aG2YMasSen-5FwxNu-P7dHq5beV5yUmTs,6152
+haddock/modules/refinement/openmm/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/refinement/openmm/__pycache__/openmm.cpython-312.pyc,,
+haddock/modules/refinement/openmm/defaults.yaml,sha256=_MVC_1YAGiy3O8UzBb4lEyRrDiAOu-Iwv1aa14KEyO4,9080
+haddock/modules/refinement/openmm/openmm.py,sha256=ojd8N6fQ0Uqjfr4jy2svBSRmXqR-aLfirDDTRZgRD1A,37361
+haddock/modules/sampling/__init__.py,sha256=IzSJ1tIiCpDEi6ItmP_kq_kpYG3--qR27oTGO--3njI,37
+haddock/modules/sampling/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/sampling/lightdock/__init__.py,sha256=YsnXGhgkqwuaQ0r0pt0QMN4uZtDVfvuFLEmiXxMgpfA,5819
+haddock/modules/sampling/lightdock/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/sampling/lightdock/defaults.yaml,sha256=cbXG0qE_WUaKvwOU3rxtDhcIbjmCBXbm9BFMHLVV3B0,2671
+haddock/modules/sampling/rigidbody/__init__.py,sha256=bjKEyHC_vmH9DpEnwnF7GlFxDipEGLO0tohR4irqW74,10714
+haddock/modules/sampling/rigidbody/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/sampling/rigidbody/cns/bestener.cns,sha256=EW2EJ1eMhKx6BgLc2K1DURHIkajYcQYuXy4Td09XnXw,3055
+haddock/modules/sampling/rigidbody/cns/bsa.cns,sha256=BGhJFQpEHo_tpsWu1qqk4H4-TGyr27m2r49F5ajWUsc,2493
+haddock/modules/sampling/rigidbody/cns/charge-beads-interactions.cns,sha256=YZO2HosC75DLThsSaCBcejZHyit5pjiioT6XkcE8d9k,1755
+haddock/modules/sampling/rigidbody/cns/check-homomers.cns,sha256=t0rPTSXU44EPwZ-Q6Av73QyEXjaYvjzAHXm7FGIQZms,1736
+haddock/modules/sampling/rigidbody/cns/check_coordinates.cns,sha256=diLUZz3XxMMb1towOaeWlGRiSNh72dgB5oX6tV57tFg,3015
+haddock/modules/sampling/rigidbody/cns/cm-restraints.cns,sha256=31ZR8M-kl5i4VoJcihgMCZTxjwvla3yfi7gWXYgUSJ4,5043
+haddock/modules/sampling/rigidbody/cns/def_solv_param.cns,sha256=hRyLXwbnm7zoCidi_Eeztq-NvBjSiWIJfxo9WXcRzPo,4071
+haddock/modules/sampling/rigidbody/cns/get_random_rotation.cns,sha256=5zHg-lEkWBE_8Zrrv9RqBzo60avmXPmO_yC6TScaOq8,3875
+haddock/modules/sampling/rigidbody/cns/print_coorheader.cns,sha256=AdRuACCZ5TIWwBPuSVXVvQhD6728rIUxhwtN4yiLWmw,12246
+haddock/modules/sampling/rigidbody/cns/random_rotations.cns,sha256=6XnCXDtAMmtkbvIolx8BctAKxz8lTMw79zRom_tJtVk,7800
+haddock/modules/sampling/rigidbody/cns/randomairs.cns,sha256=Bv5TjtwCQMwwDLRHoNc8bQNH-KxCwkPyzQGQRPnTIaw,8970
+haddock/modules/sampling/rigidbody/cns/read_noes.cns,sha256=nLADAFcVjbJ-WN8Zza5mgYZFkvZNldL9feUidQRVN1I,1817
+haddock/modules/sampling/rigidbody/cns/read_param.cns,sha256=Dm_oGn9aIJILPsFIa1RvAp21w5AeekXLxJLdh7u9BXY,2021
+haddock/modules/sampling/rigidbody/cns/rigidbody.cns,sha256=VuZv32U8XiI3KPz5SZCVW2t8ncmn2tHR-UrTFkxjUSo,18700
+haddock/modules/sampling/rigidbody/cns/rotation180.cns,sha256=J0UXXhjj67-hKInI54n8y3Qlt8GeOT1k5VaTPLp6M-s,2749
+haddock/modules/sampling/rigidbody/cns/scale_inter_final.cns,sha256=WPncZ_1Rp757GyOZL9YFp0ONAfpIzV7WW6Lvrhy4LNQ,1836
+haddock/modules/sampling/rigidbody/cns/scale_inter_mini.cns,sha256=QwfEU3fBxBqTOeB5BDUbRfa9FrGvifnraUVFLRIvfCw,1711
+haddock/modules/sampling/rigidbody/cns/scale_inter_only.cns,sha256=MfJwiYsd8Vn8R-Qbaiq02maAI6E89yC-Fg07E3rS2D8,2071
+haddock/modules/sampling/rigidbody/cns/scale_intra_only.cns,sha256=BIA9k5ETYoSswYiZXTnVaE5g6N7k0TTIhhG-Amot3Q8,1489
+haddock/modules/sampling/rigidbody/cns/separate.cns,sha256=s_mqxZNmhRNe94BTIsf9XiI_hI_JAbgI17KKn3aqcp8,9324
+haddock/modules/sampling/rigidbody/cns/surf-restraints.cns,sha256=Xsh9rKXeB4bEELsGQ_06xYCLGAGYD1kjh1h8MmXRPNU,2722
+haddock/modules/sampling/rigidbody/cns/symmultimer.cns,sha256=v-RvMEcmhxmwJgetDufqr2OHO9JTOaHIU1cm_vshTf8,32233
+haddock/modules/sampling/rigidbody/defaults.yaml,sha256=PClF41pu2WYClCm0mNXMEGwC2XdP6i_c31Msk-1BQ9o,156404
+haddock/modules/scoring/__init__.py,sha256=uZKaVaMaDApf0Yng0biAeXWhV4AYYngjl5abZRbPdfA,12816
+haddock/modules/scoring/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/scoring/emscoring/__init__.py,sha256=C6A1vSY-udbKWiws11aVKPxA0elBb54yt7jDOC61vTs,3627
+haddock/modules/scoring/emscoring/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/scoring/emscoring/cns/calc_free-ene.cns,sha256=ImZyyS30ThEOJ9y_B1QLOs7AJALMJ5yH699RmGN4XZE,962
+haddock/modules/scoring/emscoring/cns/check_coordinates.cns,sha256=diLUZz3XxMMb1towOaeWlGRiSNh72dgB5oX6tV57tFg,3015
+haddock/modules/scoring/emscoring/cns/def_solv_param.cns,sha256=hRyLXwbnm7zoCidi_Eeztq-NvBjSiWIJfxo9WXcRzPo,4071
+haddock/modules/scoring/emscoring/cns/emscoring.cns,sha256=8pHOygMxS8NAoRVlruXegYIupQ9FmAtSMKASOHXgWfQ,6388
+haddock/modules/scoring/emscoring/cns/print_coorheader.cns,sha256=unXp0Ufe6_RvB10xqlZjPADQI2TYafGux8ujPAHdD6c,17115
+haddock/modules/scoring/emscoring/cns/read_param.cns,sha256=Dm_oGn9aIJILPsFIa1RvAp21w5AeekXLxJLdh7u9BXY,2021
+haddock/modules/scoring/emscoring/cns/restrain-ions.cns,sha256=gb6AqflQscIatvKUSXno6wO6G2-kbncNNwaId2b5J7U,5237
+haddock/modules/scoring/emscoring/cns/scale_inter_final.cns,sha256=tV57zFF1vHt0texcYIsNqw5xyVRR8ft6ahIPuaGnx2k,1801
+haddock/modules/scoring/emscoring/cns/scale_intra_only.cns,sha256=BIA9k5ETYoSswYiZXTnVaE5g6N7k0TTIhhG-Amot3Q8,1489
+haddock/modules/scoring/emscoring/defaults.yaml,sha256=9YAkIq5rLwdloKpcFP3aMv4e9qS3VMCRViL7WUXiJXw,10496
+haddock/modules/scoring/mdscoring/__init__.py,sha256=C3HQP2U0BXJHvO_UbQiuV0oGAgCLkzwLsJdOUOPzZ80,3612
+haddock/modules/scoring/mdscoring/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/scoring/mdscoring/cns/calc_free-ene.cns,sha256=oiXJjYSnG23nizBMv1D6YbeI-c4kDdQahRsuq0rn2w0,1116
+haddock/modules/scoring/mdscoring/cns/check_coordinates.cns,sha256=diLUZz3XxMMb1towOaeWlGRiSNh72dgB5oX6tV57tFg,3015
+haddock/modules/scoring/mdscoring/cns/contactairs.cns,sha256=LtMZm33ScEAnNE1J5HE-iQ95R8CtpTTCne4F23w7moc,1426
+haddock/modules/scoring/mdscoring/cns/def_solv_param.cns,sha256=hRyLXwbnm7zoCidi_Eeztq-NvBjSiWIJfxo9WXcRzPo,4071
+haddock/modules/scoring/mdscoring/cns/dna-rna_restraints.cns,sha256=gkljYrv7AqP3x9ujcjQYVSmhH6vknqW0GKmqyCBH-SY,19764
+haddock/modules/scoring/mdscoring/cns/flex_segment_back.cns,sha256=xOirchd_aVDHcOrViWbUwJyA3otme_U5tvdWUQXj-PI,1031
+haddock/modules/scoring/mdscoring/cns/flex_segment_side.cns,sha256=40dJPmGgkOUzw8cNZ-iGdgKA40Thj-TjAffGD28Fhxs,1101
+haddock/modules/scoring/mdscoring/cns/flexauto-neighbors.cns,sha256=lk3g471rwmcySIEIhQVrYWzN0jd1rWQxBiybwBuoxp8,2141
+haddock/modules/scoring/mdscoring/cns/generate_dmso.cns,sha256=-wuKZONhjDS-EjnsLQmcuLzf6mjWTqs_HUBzPw6r49Y,5433
+haddock/modules/scoring/mdscoring/cns/generate_water.cns,sha256=GO6nyT7pXZtHKBE8mh9MT8q8dbntQxHEXMxeB_Eo3I0,5792
+haddock/modules/scoring/mdscoring/cns/mdscoring.cns,sha256=llZxBUqZHBULj75RdxiGlxDJabfuAPEI3kn-cXeEwdw,12973
+haddock/modules/scoring/mdscoring/cns/print_coorheader.cns,sha256=unXp0Ufe6_RvB10xqlZjPADQI2TYafGux8ujPAHdD6c,17115
+haddock/modules/scoring/mdscoring/cns/protein-ss-restraints-all.cns,sha256=Ng7k_RoSrORIj77EFUIPuQ5xLwqMkcTw8byDF6ets70,4239
+haddock/modules/scoring/mdscoring/cns/protein-ss-restraints-alpha-beta.cns,sha256=v02vtd4tzMDvoLr9tQgAkiKah2yJGBUJ0ufO8-8r2IE,6002
+haddock/modules/scoring/mdscoring/cns/protein-ss-restraints-alpha.cns,sha256=zp_fje9KlUkwrqN9C6RVoXtAo674GEj69AmAALuLz48,5163
+haddock/modules/scoring/mdscoring/cns/read_param.cns,sha256=Dm_oGn9aIJILPsFIa1RvAp21w5AeekXLxJLdh7u9BXY,2021
+haddock/modules/scoring/mdscoring/cns/restrain-ions.cns,sha256=gb6AqflQscIatvKUSXno6wO6G2-kbncNNwaId2b5J7U,5237
+haddock/modules/scoring/mdscoring/cns/scale_inter_final.cns,sha256=tV57zFF1vHt0texcYIsNqw5xyVRR8ft6ahIPuaGnx2k,1801
+haddock/modules/scoring/mdscoring/cns/scale_intra_only.cns,sha256=BIA9k5ETYoSswYiZXTnVaE5g6N7k0TTIhhG-Amot3Q8,1489
+haddock/modules/scoring/mdscoring/cns/setflags.cns,sha256=BWCTCEU-7i6rDsArjZ_EWJd6pe-sj275phmD9EJs0Es,771
+haddock/modules/scoring/mdscoring/defaults.yaml,sha256=roDENFSMB2X38YHsAZQIgSCO22GNNzFcy9TWCXIL-mg,15687
+haddock/modules/scoring/prodigyligand/__init__.py,sha256=C_hWOypd2yMxT5Iawfbu0DxtADDmPI50laVJV_QgSAQ,3030
+haddock/modules/scoring/prodigyligand/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/scoring/prodigyligand/__pycache__/prodigylig.cpython-312.pyc,,
+haddock/modules/scoring/prodigyligand/defaults.yaml,sha256=9OcxMUB6J3a3dq03A3u59oTDGE1ZlE8AodRzYeq0KEg,2285
+haddock/modules/scoring/prodigyligand/prodigylig.py,sha256=XVFFJ9G4M8iXOc76aOIiwdYsQscVD6ViG1fBFJFJfrc,2805
+haddock/modules/scoring/prodigyprotein/__init__.py,sha256=XvGR90BHRp55RkswI_QJmZgRYwEcDzHHay89Tg1lv_4,3103
+haddock/modules/scoring/prodigyprotein/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/scoring/prodigyprotein/__pycache__/prodigy.cpython-312.pyc,,
+haddock/modules/scoring/prodigyprotein/defaults.yaml,sha256=VKzgmWkYJYTYfBTfvyVVVv0cCDUUQzk2RPlsYWuVbbc,2287
+haddock/modules/scoring/prodigyprotein/prodigy.py,sha256=xnnOwKNpa0GeeykptAmm2l5D_WMuu_O-bO6mnEEcdPc,2506
+haddock/modules/scoring/sasascore/__init__.py,sha256=E35Jf30jzFjB2B0Q25U_aTkRBCCSYnbP_i4bMq9_FNk,4283
+haddock/modules/scoring/sasascore/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/scoring/sasascore/__pycache__/sasascore.cpython-312.pyc,,
+haddock/modules/scoring/sasascore/defaults.yaml,sha256=QPYj269Cz4wzl3QavYeAEacII8xE5Dfxst2O9X2zpOo,1457
+haddock/modules/scoring/sasascore/sasascore.py,sha256=nULoqFPCs7EGMGITTqmAtfgA7UnvoWOHz07QsXZ2nic,5478
+haddock/modules/topology/__init__.py,sha256=T1QD23IIPMdLplN1AE8fH6ayk5x1ClewgCI9jtgkycs,45
+haddock/modules/topology/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/topology/topoaa/__init__.py,sha256=AK5LuSH-iYkpEqYvnYf9aDgQ9ikXrX4Iq3uLIuykVmM,15344
+haddock/modules/topology/topoaa/__pycache__/__init__.cpython-312.pyc,,
+haddock/modules/topology/topoaa/cns/auto-his.cns,sha256=sdzqMBcvQHMB1tMtbkQ_ZKOmWopZtVvm0pNqOKKIJdY,4999
+haddock/modules/topology/topoaa/cns/bondglycans.cns,sha256=HeUkl-Nn188E6FBkSgtlBXDrvKro99IXTUp5TNJZvCU,22854
+haddock/modules/topology/topoaa/cns/build-missing.cns,sha256=Z1il-I46XEAqkpfue8buc_R7rgRCyUUlKqqLILxeLK4,8912
+haddock/modules/topology/topoaa/cns/check_coordinates.cns,sha256=diLUZz3XxMMb1towOaeWlGRiSNh72dgB5oX6tV57tFg,3015
+haddock/modules/topology/topoaa/cns/coval-ace-cys.cns,sha256=ZOZmDA0wDRulagAhy2EQzEGV0OlPPULJAy-omC9-z6M,2015
+haddock/modules/topology/topoaa/cns/covalheme.cns,sha256=PtPpIoTBFFUYeg5-mQ4s08V57SevYFE8jg4FFiTYB_M,3768
+haddock/modules/topology/topoaa/cns/dna_break.cns,sha256=YBfMhmQVIFg_bZR7IFp6KyCF0ubhBoQ3JSXW-87shFE,2738
+haddock/modules/topology/topoaa/cns/generate-topology.cns,sha256=MXOt00CBq_I2z8P_50waJCcjcWaVQUYXxEWs8I9MeAU,23545
+haddock/modules/topology/topoaa/cns/patch-bb-cg.cns,sha256=OVxefdcaYAcogj7dLcnWDmS6LHT38ri2wAIeMi7M5z8,8026
+haddock/modules/topology/topoaa/cns/patch-types-cg.cns,sha256=T2hHsV-mTrX0BVQMLDmHubg-XVw-PHuuW2Kq4MNUNWY,2963
+haddock/modules/topology/topoaa/cns/prot_break.cns,sha256=DZyq8yDD3yfnL0gfWGCYv6hEMNcJ9tcrZV34V-2Mbdc,4843
+haddock/modules/topology/topoaa/defaults.yaml,sha256=GrnJC1BWbynRHEkWKojY_v4wrGS1VELd6PObqSUVZNU,8404
+haddock/prodrg/prodrg.param,sha256=5SPxuZsoiKP8DM6R7yaQXg4c8XcdJmS-JjIZ7nuU74I,81989
+haddock/prodrg/prodrg_aarch64-linux,sha256=RgYnIbN2U8t7TOK-6jJ3OeLKNU3KeIaGy_mly12hzoU,1919656
+haddock/prodrg/prodrg_arm64-darwin,sha256=UxDP5bmf2skSx2E49sq3Es0ScKP0_j8_ZJJ42Wa5h_0,737144
+haddock/prodrg/prodrg_x86_64-linux,sha256=d3oqH1qyjD1aS8sKRCzZpKu1_hgBGWacSOlvoLIK6V0,1904548
+haddock3-2026.3.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+haddock3-2026.3.0.dist-info/METADATA,sha256=QkWpLD2srYCZRXSuvqOXwwx9XWegsFyoXW6bN-cuRb0,10659
+haddock3-2026.3.0.dist-info/RECORD,,
+haddock3-2026.3.0.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+haddock3-2026.3.0.dist-info/WHEEL,sha256=VjsRi47qtukBUrbjxzUfbq_AtWwISMuQJEz01zs7bcg,109
+haddock3-2026.3.0.dist-info/entry_points.txt,sha256=aT3o4F0PoYHex4eotd2i65SKvHu9co9u6kkrVTG8ViY,696
+haddock3-2026.3.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+haddock3-2026.3.0.dist-info/top_level.txt,sha256=26Fn1sNxrDBEuot8BU3pVoHZ-U-diSijnSp_gcVwNUs,8

.venv_haddock/lib/python3.12/site-packages/haddock3-2026.3.0.dist-info/WHEEL

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

.venv_haddock/lib/python3.12/site-packages/haddock3-2026.3.0.dist-info/entry_points.txt

@@ -0,0 +1,15 @@
+[console_scripts]
+haddock-restraints = haddock.clis.wrapper_haddock_restraints:main
+haddock3 = haddock.clis.cli:maincli
+haddock3-analyse = haddock.clis.cli_analyse:maincli
+haddock3-cfg = haddock.clis.cli_cfg:maincli
+haddock3-clean = haddock.clis.cli_clean:maincli
+haddock3-copy = haddock.clis.cli_cp:maincli
+haddock3-dmn = haddock.clis.cli_dmn:maincli
+haddock3-mpitask = haddock.clis.cli_mpi:maincli
+haddock3-pp = haddock.clis.cli_pp:maincli
+haddock3-re = haddock.clis.cli_re:maincli
+haddock3-restraints = haddock.clis.cli_restraints:maincli
+haddock3-score = haddock.clis.cli_score:maincli
+haddock3-traceback = haddock.clis.cli_traceback:maincli
+haddock3-unpack = haddock.clis.cli_unpack:maincli

.venv_haddock/lib/python3.12/site-packages/haddock3-2026.3.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+haddock

.venv_haddock/lib/python3.12/site-packages/jsonpickle-4.1.1.dist-info/INSTALLER

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

.venv_haddock/lib/python3.12/site-packages/jsonpickle-4.1.1.dist-info/METADATA

@@ -0,0 +1,232 @@
+Metadata-Version: 2.4
+Name: jsonpickle
+Version: 4.1.1
+Summary: jsonpickle encodes/decodes any Python object to/from JSON
+Author: Theelx
+Author-email: David Aguilar <davvid+jsonpickle@gmail.com>
+License: BSD-3-Clause
+Project-URL: Documentation, https://jsonpickle.readthedocs.io/
+Project-URL: Homepage, https://jsonpickle.readthedocs.io/
+Project-URL: Source, https://github.com/jsonpickle/jsonpickle
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+License-File: LICENSE
+Provides-Extra: cov
+Requires-Dist: pytest-cov; extra == "cov"
+Provides-Extra: dev
+Requires-Dist: black; extra == "dev"
+Requires-Dist: pyupgrade; extra == "dev"
+Provides-Extra: testing
+Requires-Dist: pytest!=8.1.*,>=6.0; extra == "testing"
+Requires-Dist: pytest-benchmark; extra == "testing"
+Requires-Dist: pytest-benchmark[histogram]; extra == "testing"
+Requires-Dist: pytest-checkdocs>=1.2.3; extra == "testing"
+Requires-Dist: pytest-enabler>=1.0.1; extra == "testing"
+Requires-Dist: pytest-ruff>=0.2.1; extra == "testing"
+Requires-Dist: bson; extra == "testing"
+Requires-Dist: ecdsa; extra == "testing"
+Requires-Dist: feedparser; extra == "testing"
+Requires-Dist: gmpy2; extra == "testing"
+Requires-Dist: numpy; extra == "testing"
+Requires-Dist: pandas; extra == "testing"
+Requires-Dist: pymongo; extra == "testing"
+Requires-Dist: PyYAML; extra == "testing"
+Requires-Dist: scikit-learn; extra == "testing"
+Requires-Dist: scipy>=1.9.3; python_version > "3.10" and extra == "testing"
+Requires-Dist: scipy; python_version <= "3.10" and extra == "testing"
+Requires-Dist: simplejson; extra == "testing"
+Requires-Dist: sqlalchemy; extra == "testing"
+Requires-Dist: ujson; extra == "testing"
+Requires-Dist: atheris~=2.3.0; python_version < "3.12" and extra == "testing"
+Provides-Extra: docs
+Requires-Dist: furo; extra == "docs"
+Requires-Dist: rst.linker>=1.9; extra == "docs"
+Requires-Dist: sphinx>=3.5; extra == "docs"
+Provides-Extra: packaging
+Requires-Dist: build; extra == "packaging"
+Requires-Dist: setuptools>=61.2; extra == "packaging"
+Requires-Dist: setuptools_scm[toml]>=6.0; extra == "packaging"
+Requires-Dist: twine; extra == "packaging"
+Dynamic: license-file
+
+.. image:: https://img.shields.io/pypi/v/jsonpickle.svg
+   :target: `PyPI link`_
+
+.. image:: https://img.shields.io/pypi/pyversions/jsonpickle.svg
+   :target: `PyPI link`_
+
+.. _PyPI link: https://pypi.org/project/jsonpickle
+
+.. image:: https://readthedocs.org/projects/jsonpickle/badge/?version=latest
+   :target: https://jsonpickle.readthedocs.io/en/latest/?badge=latest
+
+.. image:: https://github.com/jsonpickle/jsonpickle/actions/workflows/test.yml/badge.svg
+   :target: https://github.com/jsonpickle/jsonpickle/actions
+   :alt: Github Actions
+
+.. image:: https://img.shields.io/badge/License-BSD%203--Clause-blue.svg
+   :target: https://github.com/jsonpickle/jsonpickle/blob/main/LICENSE
+   :alt: BSD
+
+
+jsonpickle
+==========
+
+jsonpickle is a library for the two-way conversion of complex Python objects
+and `JSON <http://json.org/>`_.  jsonpickle builds upon existing JSON
+encoders, such as simplejson, json, and ujson.
+
+.. warning::
+
+   jsonpickle can execute arbitrary Python code.
+
+   Please see the Security section for more details.
+
+
+For complete documentation, please visit the
+`jsonpickle documentation <http://jsonpickle.readthedocs.io/>`_.
+
+Bug reports and merge requests are encouraged at the
+`jsonpickle repository on github <https://github.com/jsonpickle/jsonpickle>`_.
+
+Usage
+=====
+The following is a very simple example of how one can use jsonpickle in their scripts/projects. Note the usage of jsonpickle.encode and decode, and how the data is written/encoded to a file and then read/decoded from the file.
+
+.. code-block:: python
+
+    import jsonpickle
+    from dataclasses import dataclass
+   
+    @dataclass
+    class Example:
+        data: str
+   
+   
+    ex = Example("value1")
+    encoded_instance = jsonpickle.encode(ex)
+    assert encoded_instance == '{"py/object": "__main__.Example", "data": "value1"}'
+   
+    with open("example.json", "w+") as f:
+        f.write(encoded_instance)
+   
+    with open("example.json", "r+") as f:
+        written_instance = f.read()
+        decoded_instance = jsonpickle.decode(written_instance)
+    assert decoded_instance == ex
+
+For more examples, see the `examples directory on GitHub <https://github.com/jsonpickle/jsonpickle/tree/main/examples>`_ for example scripts. These can be run on your local machine to see how jsonpickle works and behaves, and how to use it. Contributions from users regarding how they use jsonpickle are welcome!
+
+
+Why jsonpickle?
+===============
+
+Data serialized with python's pickle (or cPickle or dill) is not easily readable outside of python. Using the json format, jsonpickle allows simple data types to be stored in a human-readable format, and more complex data types such as numpy arrays and pandas dataframes, to be machine-readable on any platform that supports json. E.g., unlike pickled data, jsonpickled data stored in an Amazon S3 bucket is indexible by Amazon's Athena.
+
+Security
+========
+
+jsonpickle should be treated the same as the
+`Python stdlib pickle module <https://docs.python.org/3/library/pickle.html>`_
+from a security perspective.
+
+.. warning::
+
+   The jsonpickle module **is not secure**.  Only unpickle data you trust.
+
+   It is possible to construct malicious pickle data which will **execute
+   arbitrary code during unpickling**.  Never unpickle data that could have come
+   from an untrusted source, or that could have been tampered with.
+
+   Consider signing data with an HMAC if you need to ensure that it has not
+   been tampered with.
+
+   Safer deserialization approaches, such as reading JSON directly,
+   may be more appropriate if you are processing untrusted data.
+
+
+Install
+=======
+
+Install from pip for the latest stable release:
+
+::
+
+    pip install jsonpickle
+
+Install from github for the latest changes:
+
+::
+
+    pip install git+https://github.com/jsonpickle/jsonpickle.git
+
+
+Numpy/Pandas Support
+====================
+
+jsonpickle includes built-in numpy and pandas extensions.  If you would
+like to encode sklearn models, numpy arrays, pandas DataFrames, and other
+numpy/pandas-based data, then you must enable the numpy and/or pandas
+extensions by registering their handlers::
+
+    >>> import jsonpickle.ext.numpy as jsonpickle_numpy
+    >>> import jsonpickle.ext.pandas as jsonpickle_pandas
+    >>> jsonpickle_numpy.register_handlers()
+    >>> jsonpickle_pandas.register_handlers()
+
+
+Development
+===========
+
+Use `make` to run the unit tests::
+
+        make test
+
+`pytest` is used to run unit tests internally.
+
+A `tox` target is provided to run tests using all installed and supported Python versions::
+
+        make tox
+
+`jsonpickle` itself has no dependencies beyond the Python stdlib.
+`tox` is required for testing when using the `tox` test runner only.
+
+The testing requirements are specified in `setup.cfg`.
+It is recommended to create a virtualenv and run tests from within the
+virtualenv.::
+
+        python3 -mvenv env3
+        source env3/bin/activate
+        pip install --editable '.[dev]'
+        make test
+
+You can also use a tool such as `vx <https://github.com/davvid/vx/>`_
+to activate the virtualenv without polluting your shell environment::
+
+        python3 -mvenv env3
+        vx env3 pip install --editable '.[dev]'
+        vx env3 make test
+
+If you can't use a venv, you can install the testing packages as follows::
+
+        pip install .[testing]
+
+`jsonpickle` supports multiple Python versions, so using a combination of
+multiple virtualenvs and `tox` is useful in order to catch compatibility
+issues when developing.
+
+GPG Signing
+===========
+
+Unfortunately, while versions of jsonpickle before 3.0.1 should still be signed,
+GPG signing support was removed from PyPi
+(https://blog.pypi.org/posts/2023-05-23-removing-pgp/) back in May 2023.
+
+License
+=======
+
+Licensed under the BSD License. See the LICENSE file for more details.

.venv_haddock/lib/python3.12/site-packages/jsonpickle-4.1.1.dist-info/RECORD

@@ -0,0 +1,38 @@
+jsonpickle-4.1.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+jsonpickle-4.1.1.dist-info/METADATA,sha256=uj-M-_gfWF9DXSpxrv070t1RNM4HgGjGc-Hw3wZUmc8,8148
+jsonpickle-4.1.1.dist-info/RECORD,,
+jsonpickle-4.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+jsonpickle-4.1.1.dist-info/licenses/LICENSE,sha256=2k10Dnv-Hpd3uu2jz2U09Wjssquye4Dn4sL58oZNg50,1547
+jsonpickle-4.1.1.dist-info/top_level.txt,sha256=cdRDYlLc4XOT2KzzPurieMn-XW_3YxFzopwdeDqPFVs,11
+jsonpickle/__init__.py,sha256=Lfn7ceNeACvvkRQS48F_740_g5Xy7aTffuDvOyJ7z-M,3043
+jsonpickle/__pycache__/__init__.cpython-312.pyc,,
+jsonpickle/__pycache__/backend.cpython-312.pyc,,
+jsonpickle/__pycache__/compat.cpython-312.pyc,,
+jsonpickle/__pycache__/errors.cpython-312.pyc,,
+jsonpickle/__pycache__/handlers.cpython-312.pyc,,
+jsonpickle/__pycache__/pickler.cpython-312.pyc,,
+jsonpickle/__pycache__/tags.cpython-312.pyc,,
+jsonpickle/__pycache__/tags_pd.cpython-312.pyc,,
+jsonpickle/__pycache__/unpickler.cpython-312.pyc,,
+jsonpickle/__pycache__/util.cpython-312.pyc,,
+jsonpickle/__pycache__/version.cpython-312.pyc,,
+jsonpickle/backend.py,sha256=0BImUq61LMYih-8510hNPQvtCgfNjIHGOTKuApzkyWg,9993
+jsonpickle/compat.py,sha256=jCIhbLad7wMstxeEOykPh-lRvM3fIkwITmHi0Rbi5PM,378
+jsonpickle/errors.py,sha256=lzadGFLtErTPH0CzAwxS2gbd61lqoOJE4f2_TSDa3WU,132
+jsonpickle/ext/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+jsonpickle/ext/__pycache__/__init__.cpython-312.pyc,,
+jsonpickle/ext/__pycache__/gmpy.cpython-312.pyc,,
+jsonpickle/ext/__pycache__/numpy.cpython-312.pyc,,
+jsonpickle/ext/__pycache__/pandas.cpython-312.pyc,,
+jsonpickle/ext/__pycache__/yaml.cpython-312.pyc,,
+jsonpickle/ext/gmpy.py,sha256=BSpYNyawYVeGdNQoMNQcS67H-UhxoSVAOYXkwPH2YFc,558
+jsonpickle/ext/numpy.py,sha256=QTF9XhtuEzXJHVgswjA5TygGX34-hzj1WeZDrQtTxdc,14324
+jsonpickle/ext/pandas.py,sha256=uScdvatBroJYZia6Xerm8t2i5eGZpCphOpZtILNnpvs,15138
+jsonpickle/ext/yaml.py,sha256=jM5FPGefQ9UfLBcEYbm72ecUgRlkpp6a5GuQLRUQjks,429
+jsonpickle/handlers.py,sha256=zbWgmCXnO9M7FUYz6hzjqivcj0XxibEnyzK96i2u218,8275
+jsonpickle/pickler.py,sha256=Jpp1y9suO7qm1HdRkScTwGdHTtA_DLkRtXf_Id8vnkY,32227
+jsonpickle/tags.py,sha256=-c43S7GOsPVG6ABR_vitWFjAEHVCD9g-oNFy090FlRY,987
+jsonpickle/tags_pd.py,sha256=F6wFOUfSjp34e91wE8p25-37Pn4hH7z7dOC9DEYAQhI,8312
+jsonpickle/unpickler.py,sha256=jKB6xhlm4dLMuj0qzyZA_9gGXRdKPmzxDTcaED6LY5o,33361
+jsonpickle/util.py,sha256=3OFTrYRTEAqxXVjr2o15dtc9hcgnnZrMQtBXvZhFr7A,15933
+jsonpickle/version.py,sha256=hPwJiFI0c_zey19VKn513p9gJ65s5mMdYi1p0EowrFM,342

.venv_haddock/lib/python3.12/site-packages/jsonpickle-4.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

.venv_haddock/lib/python3.12/site-packages/jsonpickle-4.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+jsonpickle

.venv_haddock/lib/python3.12/site-packages/narwhals-2.19.0.dist-info/INSTALLER

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

.venv_haddock/lib/python3.12/site-packages/narwhals-2.19.0.dist-info/METADATA

@@ -0,0 +1,349 @@
+Metadata-Version: 2.4
+Name: narwhals
+Version: 2.19.0
+Summary: Extremely lightweight compatibility layer between dataframe libraries
+Project-URL: Homepage, https://github.com/narwhals-dev/narwhals
+Project-URL: Documentation, https://narwhals-dev.github.io/narwhals/
+Project-URL: Repository, https://github.com/narwhals-dev/narwhals
+Project-URL: Bug Tracker, https://github.com/narwhals-dev/narwhals/issues
+Author-email: Marco Gorelli <hello_narwhals@proton.me>
+License: MIT License
+        
+        Copyright (c) 2024 to present, Marco Gorelli
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE.md
+Keywords: cudf,dask,dataframes,interoperability,modin,pandas,polars,pyarrow
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+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: Programming Language :: Python :: Free Threading :: 2 - Beta
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Provides-Extra: cudf
+Requires-Dist: cudf-cu12>=24.10.0; extra == 'cudf'
+Provides-Extra: dask
+Requires-Dist: dask[dataframe]>=2024.8; extra == 'dask'
+Provides-Extra: duckdb
+Requires-Dist: duckdb>=1.1; extra == 'duckdb'
+Provides-Extra: ibis
+Requires-Dist: ibis-framework>=6.0.0; extra == 'ibis'
+Requires-Dist: packaging; extra == 'ibis'
+Requires-Dist: pyarrow-hotfix; extra == 'ibis'
+Requires-Dist: rich; extra == 'ibis'
+Provides-Extra: modin
+Requires-Dist: modin; extra == 'modin'
+Provides-Extra: pandas
+Requires-Dist: pandas>=1.1.3; extra == 'pandas'
+Provides-Extra: polars
+Requires-Dist: polars>=0.20.4; extra == 'polars'
+Provides-Extra: pyarrow
+Requires-Dist: pyarrow>=13.0.0; extra == 'pyarrow'
+Provides-Extra: pyspark
+Requires-Dist: pyspark>=3.5.0; extra == 'pyspark'
+Provides-Extra: pyspark-connect
+Requires-Dist: pyspark[connect]>=3.5.0; extra == 'pyspark-connect'
+Provides-Extra: sql
+Requires-Dist: duckdb>=1.1; extra == 'sql'
+Requires-Dist: sqlparse; extra == 'sql'
+Provides-Extra: sqlframe
+Requires-Dist: sqlframe!=3.39.3,>=3.22.0; extra == 'sqlframe'
+Description-Content-Type: text/markdown
+
+# Narwhals
+
+<h1 align="center">
+	<img
+		width="400"
+		alt="narwhals_small"
+		src="https://github.com/user-attachments/assets/968545af-ea0f-48bb-8377-144e93f7abf8">
+</h1>
+
+[![PyPI version](https://badge.fury.io/py/narwhals.svg)](https://badge.fury.io/py/narwhals)
+[![Downloads](https://static.pepy.tech/badge/narwhals/month)](https://pepy.tech/project/narwhals)
+[![Trusted publishing](https://img.shields.io/badge/Trusted_publishing-Provides_attestations-bright_green)](https://peps.python.org/pep-0740/)
+[![PYPI - Types](https://img.shields.io/pypi/types/narwhals)](https://pypi.org/project/narwhals)
+
+Extremely lightweight and extensible compatibility layer between dataframe libraries!
+
+- **Full API support**: cuDF, Modin, pandas, Polars, PyArrow.
+- **Lazy-only support**: Daft, Dask, DuckDB, Ibis, PySpark, SQLFrame.
+
+Seamlessly support all, without depending on any!
+
+- ✅ **Just use** [a subset of **the Polars API**](https://narwhals-dev.github.io/narwhals/api-reference/), no need to learn anything new
+- ✅ **Zero dependencies**, Narwhals only uses what
+  the user passes in so your library can stay lightweight
+- ✅ Separate **lazy** and eager APIs, use **expressions**
+- ✅ Support pandas' complicated type system and index, without
+  either getting in the way
+- ✅ **100% branch coverage**, tested against pandas and Polars nightly builds
+- ✅ **Negligible overhead**, see [overhead](https://narwhals-dev.github.io/narwhals/overhead/)
+- ✅ Let your IDE help you thanks to **full static typing**, see [typing](https://narwhals-dev.github.io/narwhals/api-reference/typing/)
+- ✅ **Perfect backwards compatibility policy**,
+  see [stable api](https://narwhals-dev.github.io/narwhals/backcompat/) for how to opt-in
+
+Get started!
+
+- [Read the documentation](https://narwhals-dev.github.io/narwhals/)
+- [Chat with us on Discord!](https://discord.gg/V3PqtB4VA4)
+- [Join our community call](https://calendar.google.com/calendar/embed?src=27ff6dc5f598c1d94c1f6e627a1aaae680e2fac88f848bda1f2c7946ae74d5ab%40group.calendar.google.com)
+- [Read the contributing guide](https://github.com/narwhals-dev/narwhals/blob/main/CONTRIBUTING.md)
+
+<details>
+<summary>Table of contents</summary>
+
+- [Narwhals](#narwhals)
+  - [Installation](#installation)
+  - [Usage](#usage)
+  - [Example](#example)
+  - [Scope](#scope)
+  - [Roadmap](#roadmap)
+  - [Used by](#used-by)
+  - [Sponsors and institutional partners](#sponsors-and-institutional-partners)
+  - [Support](#support)
+  - [Appears on](#appears-on)
+  - [Why "Narwhals"?](#why-narwhals)
+
+</details>
+
+## Installation
+
+- pip (recommended, as it's the most up-to-date)
+  ```
+  pip install narwhals
+  ```
+- conda-forge (also fine, but the latest version may take longer to appear)
+  ```
+  conda install -c conda-forge narwhals
+  ```
+
+## Usage
+
+There are three steps to writing dataframe-agnostic code using Narwhals:
+
+1. use `narwhals.from_native` to wrap a pandas/Polars/Modin/cuDF/PyArrow
+   DataFrame/LazyFrame in a Narwhals class
+2. use the [subset of the Polars API supported by Narwhals](https://narwhals-dev.github.io/narwhals/api-reference/)
+3. use `narwhals.to_native` to return an object to the user in its original
+   dataframe flavour. For example:
+
+   - if you started with pandas, you'll get pandas back
+   - if you started with Polars, you'll get Polars back
+   - if you started with Modin, you'll get Modin back (and compute will be distributed)
+   - if you started with cuDF, you'll get cuDF back (and compute will happen on GPU)
+   - if you started with PyArrow, you'll get PyArrow back
+
+<h1 align="left">
+	<img
+		width="600"
+		alt="narwhals_gif"
+		src="https://github.com/user-attachments/assets/88292d3c-6359-4155-973d-d0f8e3fbf5ac">
+
+</h1>
+
+## Example
+
+Narwhals allows you to define dataframe-agnostic functions. For example:
+
+```python
+import narwhals as nw
+from narwhals.typing import IntoFrameT
+
+
+def agnostic_function(
+    df_native: IntoFrameT,
+    date_column: str,
+    price_column: str,
+) -> IntoFrameT:
+    return (
+        nw.from_native(df_native)
+        .group_by(nw.col(date_column).dt.truncate("1mo"))
+        .agg(nw.col(price_column).mean())
+        .sort(date_column)
+        .to_native()
+    )
+```
+
+You can then pass `pandas.DataFrame`, `polars.DataFrame`, `polars.LazyFrame`, `duckdb.DuckDBPyRelation`,
+`pyspark.sql.DataFrame`, `pyarrow.Table`, and more, to `agnostic_function`. In each case, no additional
+dependencies will be required, and computation will stay native to the input library:
+
+```python
+import pandas as pd
+import polars as pl
+from datetime import datetime
+
+data = {
+    "date": [datetime(2020, 1, 1), datetime(2020, 1, 8), datetime(2020, 2, 3)],
+    "price": [1, 4, 3],
+}
+print("pandas result:")
+print(agnostic_function(pd.DataFrame(data), "date", "price"))
+print()
+print("Polars result:")
+print(agnostic_function(pl.DataFrame(data), "date", "price"))
+```
+
+```terminal
+pandas result:
+        date  price
+0 2020-01-01    2.5
+1 2020-02-01    3.0
+
+Polars result:
+shape: (2, 2)
+┌─────────────────────┬───────┐
+│ date                ┆ price │
+│ ---                 ┆ ---   │
+│ datetime[μs]        ┆ f64   │
+╞═════════════════════╪═══════╡
+│ 2020-01-01 00:00:00 ┆ 2.5   │
+│ 2020-02-01 00:00:00 ┆ 3.0   │
+└─────────────────────┴───────┘
+```
+
+See the [tutorial](https://narwhals-dev.github.io/narwhals/basics/dataframe/) for several examples!
+
+## Scope
+
+- Do you maintain a dataframe-consuming library?
+- Do you have a specific Polars function in mind that you would like Narwhals to have in order to make your work easier?
+
+If you said yes to both, we'd love to hear from you!
+
+## Roadmap
+
+See [roadmap discussion on GitHub](https://github.com/narwhals-dev/narwhals/discussions/1370)
+for an up-to-date plan of future work.
+
+## Used by
+
+Join the party!
+
+- [altair](https://github.com/vega/altair/)
+- [bokeh](https://github.com/bokeh/bokeh)
+- [darts](https://github.com/unit8co/darts)
+- [fairlearn](https://github.com/fairlearn/fairlearn)
+- [formulaic](https://github.com/matthewwardrop/formulaic)
+- [gt-extras](https://github.com/posit-dev/gt-extras)
+- [hierarchicalforecast](https://github.com/Nixtla/hierarchicalforecast)
+- [marimo](https://github.com/marimo-team/marimo)
+- [metalearners](https://github.com/Quantco/metalearners)
+- [mosaic](https://github.com/uwdata/mosaic)
+- [panel-graphic-walker](https://github.com/panel-extensions/panel-graphic-walker)
+- [plotly](https://plotly.com)
+- [pointblank](https://github.com/posit-dev/pointblank)
+- [pymarginaleffects](https://github.com/vincentarelbundock/pymarginaleffects)
+- [pyreadstat](https://github.com/Roche/pyreadstat)
+- [py-shiny](https://github.com/posit-dev/py-shiny)
+- [rio](https://github.com/rio-labs/rio)
+- [scikit-lego](https://github.com/koaning/scikit-lego)
+- [scikit-playtime](https://github.com/koaning/scikit-playtime)
+- [tabmat](https://github.com/Quantco/tabmat)
+- [tea-tasting](https://github.com/e10v/tea-tasting)
+- [timebasedcv](https://github.com/FBruzzesi/timebasedcv)
+- [tubular](https://github.com/lvgig/tubular)
+- [Validoopsie](https://github.com/akmalsoliev/Validoopsie)
+- [vegafusion](https://github.com/vega/vegafusion)
+- [wimsey](https://github.com/benrutter/wimsey)
+
+Feel free to add your project to the list if it's missing, and/or
+[chat with us on Discord](https://discord.gg/V3PqtB4VA4) if you'd like any support.
+
+## Sponsors and institutional partners
+
+Narwhals is 100% independent, community-driven, and community-owned.
+We are extremely grateful to the following organisations for having
+provided some funding / development time:
+
+- [Quansight Labs](https://labs.quansight.org)
+- [Quansight Futures](https://www.qi.ventures)
+- [OpenTeams](https://www.openteams.com)
+- [POSSEE initiative](https://possee.org)
+- [BYU-Idaho](https://www.byui.edu)
+
+If you contribute to Narwhals on your organization's time, please let us know. We'd be happy to add your employer
+to this list!
+
+## Support
+
+If you'd like to say "thank you", please give us a ⭐ star ⭐.
+
+Please contact [hello_narwhals@proton.me](hello_narwhals@proton.me) if you would like to:
+
+- Receive professional support (e.g., if you're using or would like to use Narwhals at your company).
+- Have any Narwhals fixes / features prioritised.
+- Commission any Narwhals plugins for new backends.
+
+## Appears on
+
+Narwhals has been featured in several talks, podcasts, and blog posts:
+
+- [Inspiring Computing Podcast](https://www.inspiringcomputing.com/2107763/episodes/16702460-the-rise-of-narwhals-in-open-source)
+  The Rise of Narwhals in Open-Source
+
+- [PyCon DE & PyData 2025](https://youtu.be/DJk782DWcss)
+  How Narwhals is silently bringing pandas, Polars, DuckDB, PyArrow, and more together
+
+- [The Python Exchange March 2025](https://youtu.be/TvFWFlK-2po)
+  What Can Narwhals Do for You?
+
+- [PyData London 2025](https://youtu.be/r2PxJlO7_QA)
+  How Narwhals brings Polars, DuckDB, PyArrow, & pandas together
+
+- [Talk Python to me Podcast](https://youtu.be/FSH7BZ0tuE0)
+  Ahoy, Narwhals are bridging the data science APIs
+
+- [Python Bytes Podcast](https://www.youtube.com/live/N7w_ESVW40I?si=y-wN1uCsAuJOKlOT&t=382)
+  Episode 402, topic #2
+
+- [Super Data Science: ML & AI Podcast](https://www.youtube.com/watch?v=TeG4U8R0U8U)  
+  Narwhals: For Pandas-to-Polars DataFrame Compatibility
+
+- [Sample Space Podcast | probabl](https://youtu.be/8hYdq4sWbbQ?si=WG0QP1CZ6gkFf18b)  
+  How Narwhals has many end users ... that never use it directly. - Marco Gorelli
+
+- [The Real Python Podcast](https://www.youtube.com/watch?v=w5DFZbFYzCM)
+  Narwhals: Expanding DataFrame Compatibility Between Libraries
+
+- [Pycon Lithuania 2024](https://www.youtube.com/watch?v=-mdx7Cn6_6E)  
+  Marco Gorelli - DataFrame interoperatiblity - what's been achieved, and what comes next?
+
+- [Pycon Italy 2024](https://www.youtube.com/watch?v=3IqUli9XsmQ)  
+  How you can write a dataframe-agnostic library - Marco Gorelli
+
+- [Polars Blog Post](https://pola.rs/posts/lightweight_plotting/)  
+  Polars has a new lightweight plotting backend
+
+- [Quansight Labs blog post (w/ Scikit-Lego)](https://labs.quansight.org/blog/scikit-lego-narwhals)  
+  How Narwhals and scikit-lego came together to achieve dataframe-agnosticism
+
+## Why "Narwhals"?
+
+[Coz they are so awesome](https://youtu.be/ykwqXuMPsoc?si=A-i8LdR38teYsos4).
+
+Thanks to [Olha Urdeichuk](https://www.fiverr.com/olhaurdeichuk) for the illustration!

.venv_haddock/lib/python3.12/site-packages/narwhals-2.19.0.dist-info/RECORD

@@ -0,0 +1,330 @@
+narwhals-2.19.0.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+narwhals-2.19.0.dist-info/METADATA,sha256=LFbVqYTtwz5TWaaKr9cLNbc7v5F42KlooRzWyo3T48Q,14081
+narwhals-2.19.0.dist-info/RECORD,,
+narwhals-2.19.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+narwhals-2.19.0.dist-info/licenses/LICENSE.md,sha256=gRRF8wFHuPDJ1ETJAl_VKPlTLFS3uD9uI2hHPckc_fA,1082
+narwhals/__init__.py,sha256=2K-Vi5Dtx6Sc6-EwIlMGKYg50WiP8AXB2GWB-v_AUa4,3339
+narwhals/__pycache__/__init__.cpython-312.pyc,,
+narwhals/__pycache__/_constants.cpython-312.pyc,,
+narwhals/__pycache__/_duration.cpython-312.pyc,,
+narwhals/__pycache__/_enum.cpython-312.pyc,,
+narwhals/__pycache__/_exceptions.cpython-312.pyc,,
+narwhals/__pycache__/_expression_parsing.cpython-312.pyc,,
+narwhals/__pycache__/_namespace.cpython-312.pyc,,
+narwhals/__pycache__/_native.cpython-312.pyc,,
+narwhals/__pycache__/_translate.cpython-312.pyc,,
+narwhals/__pycache__/_typing.cpython-312.pyc,,
+narwhals/__pycache__/_typing_compat.cpython-312.pyc,,
+narwhals/__pycache__/_utils.cpython-312.pyc,,
+narwhals/__pycache__/compliant.cpython-312.pyc,,
+narwhals/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/__pycache__/dependencies.cpython-312.pyc,,
+narwhals/__pycache__/dtypes.cpython-312.pyc,,
+narwhals/__pycache__/exceptions.cpython-312.pyc,,
+narwhals/__pycache__/expr.cpython-312.pyc,,
+narwhals/__pycache__/expr_cat.cpython-312.pyc,,
+narwhals/__pycache__/expr_dt.cpython-312.pyc,,
+narwhals/__pycache__/expr_list.cpython-312.pyc,,
+narwhals/__pycache__/expr_name.cpython-312.pyc,,
+narwhals/__pycache__/expr_str.cpython-312.pyc,,
+narwhals/__pycache__/expr_struct.cpython-312.pyc,,
+narwhals/__pycache__/functions.cpython-312.pyc,,
+narwhals/__pycache__/group_by.cpython-312.pyc,,
+narwhals/__pycache__/plugins.cpython-312.pyc,,
+narwhals/__pycache__/schema.cpython-312.pyc,,
+narwhals/__pycache__/selectors.cpython-312.pyc,,
+narwhals/__pycache__/series.cpython-312.pyc,,
+narwhals/__pycache__/series_cat.cpython-312.pyc,,
+narwhals/__pycache__/series_dt.cpython-312.pyc,,
+narwhals/__pycache__/series_list.cpython-312.pyc,,
+narwhals/__pycache__/series_str.cpython-312.pyc,,
+narwhals/__pycache__/series_struct.cpython-312.pyc,,
+narwhals/__pycache__/sql.cpython-312.pyc,,
+narwhals/__pycache__/this.cpython-312.pyc,,
+narwhals/__pycache__/translate.cpython-312.pyc,,
+narwhals/__pycache__/typing.cpython-312.pyc,,
+narwhals/__pycache__/utils.cpython-312.pyc,,
+narwhals/_arrow/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/_arrow/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/expr.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/selectors.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/series.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/series_cat.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/series_dt.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/series_list.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/series_str.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/series_struct.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/typing.cpython-312.pyc,,
+narwhals/_arrow/__pycache__/utils.cpython-312.pyc,,
+narwhals/_arrow/dataframe.py,sha256=SIlHQrE80jg19Vq33Y2pCwNzhWDJj-0k-VD3zkzBYCw,31067
+narwhals/_arrow/expr.py,sha256=T0F5hG0k4jeITT__B6UIHVGvkgGK1uXpZTyu8ZuzPyg,9433
+narwhals/_arrow/group_by.py,sha256=3kNOSdauoXDWtMMAhOQfrQtbmhC1bzSN7Sl56QfwQE4,9174
+narwhals/_arrow/namespace.py,sha256=gpxdqsMjeKUTw93dabbCPRlmZJ_w8LvwEG5VQYK7xYo,11272
+narwhals/_arrow/selectors.py,sha256=kShb4WWC9UKQO_MTrYoLNKyo2KLdofjFRh1KBRtXCKQ,882
+narwhals/_arrow/series.py,sha256=ZdmyaElQif1QOUKvMdeyGpswgzndXMDkz-Toq_8yL2c,45518
+narwhals/_arrow/series_cat.py,sha256=j2DFbFEoaW2vSnLnCycspYNtbNYeWvVSeLELYb_3zF0,686
+narwhals/_arrow/series_dt.py,sha256=xTQt39PKTVPkeVwh87soCld_ll6-v_OQJTdUKJBBjS4,9026
+narwhals/_arrow/series_list.py,sha256=EDwxUa5bm5jrYci8SIK9sXa8gMv8k7GnCUndixg55gs,1461
+narwhals/_arrow/series_str.py,sha256=n87Jqa7q-O-GonBiwWy3V7itGrDYB168Jk9Z-yj7_ns,5179
+narwhals/_arrow/series_struct.py,sha256=MorW6vTLKxqpR96NhB5RxkkBWOxrCTyvJ76Ilnwb7LY,504
+narwhals/_arrow/typing.py,sha256=W3Vz_kc5zw94VeYzrC9xNPYpJBZ3DOSyfpuWPUVEW1M,2359
+narwhals/_arrow/utils.py,sha256=9ntQC59VAxpuZDsd2C6NNc510dNWle1VxEMKoLSEOjs,21010
+narwhals/_compliant/__init__.py,sha256=Xzk2TdU1KItMCg-r_cs599PPF8x9BMjgSMiOalW9Vjs,2319
+narwhals/_compliant/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/any_namespace.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/column.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/expr.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/selectors.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/series.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/typing.cpython-312.pyc,,
+narwhals/_compliant/__pycache__/window.cpython-312.pyc,,
+narwhals/_compliant/any_namespace.py,sha256=1Zbv6m0x21qbHJqG5YbhlmPDBKWS0XcGdqbm6s5Rwgk,4411
+narwhals/_compliant/column.py,sha256=d5watE0NL3f9tsIMqpELlI5OYIeKSMYKqZg1JAEZBEQ,5273
+narwhals/_compliant/dataframe.py,sha256=FlbZXtq3xuN1YlAXH7mUUZnEljeAv00gs6xyVoO3Pss,16819
+narwhals/_compliant/expr.py,sha256=YayC8nTW1BKfTEpK6k5P_K1IuGbcsRh3r9kTYO1yaxM,42125
+narwhals/_compliant/group_by.py,sha256=0eKCV-jxXe506ZVGRDQnoL0LsBeMMUHgqkalHkO8VQo,7050
+narwhals/_compliant/namespace.py,sha256=ai7Tj7tGeWPBYNd7Bbkxvz-Y7zVKcqQW-y1j-RX3PPk,11348
+narwhals/_compliant/selectors.py,sha256=und99_KqUg9zrdhBlfxQVl_6R-VPv6NsL3vv6Bcwhuk,11902
+narwhals/_compliant/series.py,sha256=g4kTQv140Hykaon14-VZazPgdjMmVPCezqmQiHbt-RY,13790
+narwhals/_compliant/typing.py,sha256=xQ6omwtoRfLCiGXlgh-o7FuR_zHwmxL_QEvp6S0EZ1U,7498
+narwhals/_compliant/window.py,sha256=_ji4goVKkT4YPTyZa_I0N2yGmwBfB1_LDG0WSXGbmlo,505
+narwhals/_constants.py,sha256=kE1KWsIky4ryabH-Z117ZtGW24ccTcreWOZJjpacO6I,1094
+narwhals/_dask/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/_dask/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_dask/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_dask/__pycache__/expr.cpython-312.pyc,,
+narwhals/_dask/__pycache__/expr_dt.cpython-312.pyc,,
+narwhals/_dask/__pycache__/expr_str.cpython-312.pyc,,
+narwhals/_dask/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_dask/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_dask/__pycache__/selectors.cpython-312.pyc,,
+narwhals/_dask/__pycache__/utils.cpython-312.pyc,,
+narwhals/_dask/dataframe.py,sha256=tCT7sjZQ-5s3ykXJI-U-dIvQjIWukvf2MoroHEx_g6A,19856
+narwhals/_dask/expr.py,sha256=VSd6j1ucRuFXkkiEg6hsVs7LLxo-wN3b9bFSrhFNa78,26735
+narwhals/_dask/expr_dt.py,sha256=gtLt-UgD0Kw_Vev32rOZUdmP_XQfvU9XrKjtgmkQYps,6276
+narwhals/_dask/expr_str.py,sha256=XE6bKZd-PTfMsZOJ49mWzl1miiQQoKQlTG2U_i97gic,3885
+narwhals/_dask/group_by.py,sha256=nwgSODQljSjJ10snNGvOvKN3ctBXNertD6pciA5H0cs,5083
+narwhals/_dask/namespace.py,sha256=lfE8aXPwpb7ejdIhkxE5kFZy4GasGGrYEqraRaxpTBE,13416
+narwhals/_dask/selectors.py,sha256=W8tLFVUbafUb5EKi5rg09-cP9JA4T3MwiIjKCYk1YH0,927
+narwhals/_dask/utils.py,sha256=pAUYw9k1krePgRzGWxWVBj4OyMaT6AALaRILOR6ehxo,5445
+narwhals/_duckdb/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/_duckdb/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/expr.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/expr_dt.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/expr_list.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/expr_str.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/expr_struct.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/selectors.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/series.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/typing.cpython-312.pyc,,
+narwhals/_duckdb/__pycache__/utils.cpython-312.pyc,,
+narwhals/_duckdb/dataframe.py,sha256=SjQP-dj-XAd_lRCLqDmH-hHWT74yypUwvy9bNFEI4Bw,20462
+narwhals/_duckdb/expr.py,sha256=k35p2V98KcjhMchjvdvkowap7Sw8WBrbVAFXPcej4wc,12486
+narwhals/_duckdb/expr_dt.py,sha256=RDqYnsM0pDPEh59hq0BHrl6YNLFBR7w8gLIdxVWdzvY,5157
+narwhals/_duckdb/expr_list.py,sha256=OgnTsvii5lJDZ2vBJQIXBGT0hMqK2HfGOX_Dvrli2es,2734
+narwhals/_duckdb/expr_str.py,sha256=ksmAAAnRr9fE5dzLI8ZkcIkxCdv-o1lbE3k9zlVsv7k,1870
+narwhals/_duckdb/expr_struct.py,sha256=eN06QA1JS6wjAt7_AZzW3xoztHM_hoadlFUl_hwsEiE,576
+narwhals/_duckdb/group_by.py,sha256=e07h9TN45G6HUveqhalRDKp9PngacCRLa-o3WlkoW5o,1276
+narwhals/_duckdb/namespace.py,sha256=g-4cU0j3CVwe4ljTc4brdYRoNSJM18b6g3vnvCY4EKQ,6400
+narwhals/_duckdb/selectors.py,sha256=yA16Z-MlJUJBjOu0XI9qVO4Zx7L_T5FN2DQqNAYhu-o,1033
+narwhals/_duckdb/series.py,sha256=xBpuPUnSSIQ1vYEKjHQFZN7ix1ZyMwSchliDPpkf3Wk,1397
+narwhals/_duckdb/typing.py,sha256=gO_Odyinkn4QZY_TU4uuzda6mbeo38glOOUUripcWgg,454
+narwhals/_duckdb/utils.py,sha256=yqg4XsFY_URuzEMBxew2a8aDdgHD2FMXfBBXqA-Bbz4,15810
+narwhals/_duration.py,sha256=WGzj3FVcC2KogqRhNeim3YDIwUn8HkXQHAljtvHrjwQ,3139
+narwhals/_enum.py,sha256=6mWLGvqHP8JhLRhBjGof4Ungx-SDasqu-G0M2pX0Oew,1142
+narwhals/_exceptions.py,sha256=uVgFKgx_6ub9MHJ_qJ7xC5zie-uRVtbJo0j3FDoXAqk,1894
+narwhals/_expression_parsing.py,sha256=M-GhKye9mecJLjI9lF3jiDVSQWijZ0j2nH6-DkPSYKc,33387
+narwhals/_ibis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/_ibis/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/expr.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/expr_dt.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/expr_list.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/expr_str.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/expr_struct.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/selectors.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/series.cpython-312.pyc,,
+narwhals/_ibis/__pycache__/utils.cpython-312.pyc,,
+narwhals/_ibis/dataframe.py,sha256=ihqiWfvAeCRs3Vlcyj75yAel-Z4lGR8IL4g80MjX2cU,16388
+narwhals/_ibis/expr.py,sha256=2Unv20zbWJ52goEPNIlq7zCKXtfDC9Z_B044G54BY_g,14018
+narwhals/_ibis/expr_dt.py,sha256=0RS1B1geFYxyS5RplyG9VES8mFg4tylcG75dIKczvNs,3308
+narwhals/_ibis/expr_list.py,sha256=1REKJRa7930JTMofZbSb4rghjBg1mOAZf8sRcKx1EUs,2343
+narwhals/_ibis/expr_str.py,sha256=fvYzDibIaGH8bE3ZhTUF9yfs--0ONM6l7f5zeW7neLk,3443
+narwhals/_ibis/expr_struct.py,sha256=FDsa5MqcHhqPmpZIEfGBASdqxPkyImrlGTH7XUSw3cs,565
+narwhals/_ibis/group_by.py,sha256=enNzAPUsA_LIwPNJ7jG_MJKyqG2HyCiesBEX3pJgJBg,1031
+narwhals/_ibis/namespace.py,sha256=H3d9nO20RAEF0UVQzBaN4jHkSmk3JHR2iV2tP26uzKE,5635
+narwhals/_ibis/selectors.py,sha256=SkFxoukpKc_OjwKoKHRm8VwMaphCMUeWBJ2g_oWz3D0,961
+narwhals/_ibis/series.py,sha256=CZDwDPsdELKtdr7OWmcFyGqexr33Ucfnv_RU95VJxIQ,1218
+narwhals/_ibis/utils.py,sha256=j2nf-cb3wXP0OOlMuyg3qMsFOYZHD_c5pnW_qwu4uy0,10591
+narwhals/_interchange/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/_interchange/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_interchange/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_interchange/__pycache__/series.cpython-312.pyc,,
+narwhals/_interchange/dataframe.py,sha256=FC_2WuxxI4RPUBMqcau68rkdfsxhClou4zCErx1flcw,6034
+narwhals/_interchange/series.py,sha256=nSxdlOZrw3wtavS42TMR_b_EGgPBv224ioZBMo5eoC8,1651
+narwhals/_namespace.py,sha256=ARbIk31MgCvYDAxlAz7J9TGKktG0_p-Eu9myDi3nurs,8551
+narwhals/_native.py,sha256=ByNgFo_kGIsgr_dSte8mT6snLjiBbsvAFGrECnXjl-g,15402
+narwhals/_pandas_like/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/_pandas_like/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/expr.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/selectors.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/series.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/series_cat.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/series_dt.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/series_list.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/series_str.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/series_struct.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/typing.cpython-312.pyc,,
+narwhals/_pandas_like/__pycache__/utils.cpython-312.pyc,,
+narwhals/_pandas_like/dataframe.py,sha256=S7yOLQzPJkDD0_WG3FRFNXHGi1slBusZ_sFtZlavNbo,46397
+narwhals/_pandas_like/expr.py,sha256=8S2dcPNbB-PpsxWloB_PTVAIg5-wiKXMGHrSws9Eznw,16990
+narwhals/_pandas_like/group_by.py,sha256=09zHMYyVXnQBM7efTHbWYMO4a-QdUYcVBfO3kY9oWjg,15484
+narwhals/_pandas_like/namespace.py,sha256=hEs23p2AqNEp_NqPp_ZCYY9s_geiIuMCJgJ8_hH80mk,17025
+narwhals/_pandas_like/selectors.py,sha256=ksx2a0Pf1g2OJu2dsWGnuUH3095v40OnhzT7zkolfhA,1015
+narwhals/_pandas_like/series.py,sha256=hNPg9jRyDUon9UDJ1xgklako2Dn--cUBfldnBFw_llE,48087
+narwhals/_pandas_like/series_cat.py,sha256=MJwCnJ49hfnODh6JgMHOCQ2KBlTbmySU6_X4XWaqiz4,527
+narwhals/_pandas_like/series_dt.py,sha256=Mq6Dhrki-HoV2yqnbsKWT60W2li1UjtOTnKB5V3FTzA,11814
+narwhals/_pandas_like/series_list.py,sha256=Ew6nc4z3cddOWDAwj-8s-ouHew7Eq9mTQbb55iw7JGI,2960
+narwhals/_pandas_like/series_str.py,sha256=XCX1xE2-GjV5E6VVQWQXVmuyS7UNuG3e5jhgwaDu4ek,4875
+narwhals/_pandas_like/series_struct.py,sha256=vX9HoO42vHackvVozUfp8odM9uJ4owct49ydKDnohdk,518
+narwhals/_pandas_like/typing.py,sha256=4-y2QKdz3GChKp8HStqFLW8Fwe5KUMFFJDtjGR76ERQ,1059
+narwhals/_pandas_like/utils.py,sha256=DBFU2dBqxbaXBP2mClNEGMuL_0hByOsn4yLnUHZLmPE,26543
+narwhals/_polars/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/_polars/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_polars/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_polars/__pycache__/expr.cpython-312.pyc,,
+narwhals/_polars/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_polars/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_polars/__pycache__/series.cpython-312.pyc,,
+narwhals/_polars/__pycache__/typing.cpython-312.pyc,,
+narwhals/_polars/__pycache__/utils.cpython-312.pyc,,
+narwhals/_polars/dataframe.py,sha256=vTeRBVrS103xVvdGhHJ8Hs31WCpuBGle421Csbi7dYI,26141
+narwhals/_polars/expr.py,sha256=QdRHd7aKjEO1J595zzp4jwLq5lOqoO5c7yPDjB1dcB0,17882
+narwhals/_polars/group_by.py,sha256=PsxQPWX7QWy2iXUWJEelC5O6mR1TKr9MB_i6O5RVxms,2373
+narwhals/_polars/namespace.py,sha256=AFRy05M9TLzYlJVwwKlk1YN7Mb8EWdAc7i132CjGblE,10469
+narwhals/_polars/series.py,sha256=Pdp4B1k6AR4moNWugq4xTUvkHJQizz04wzE1ZAEfaf4,28502
+narwhals/_polars/typing.py,sha256=d11nVYqv1dqC_H2A-PXz1oHYYCAOnkK_s87ytm4twMA,302
+narwhals/_polars/utils.py,sha256=NcNC8kPirVuo3FRVtOcoXMPIfElikdwQ05nfR49flLM,13035
+narwhals/_spark_like/__init__.py,sha256=T7_UCePrrYs1ZeMatvCUYUvQcXvrDjQ4b08_ugWIHAo,87
+narwhals/_spark_like/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/expr.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/expr_dt.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/expr_list.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/expr_str.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/expr_struct.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/selectors.cpython-312.pyc,,
+narwhals/_spark_like/__pycache__/utils.cpython-312.pyc,,
+narwhals/_spark_like/dataframe.py,sha256=tcQSJl1RO6i1DuV4bsji1mHWSqHLOy5CAC3UoVsP3tY,23329
+narwhals/_spark_like/expr.py,sha256=oBtmPMTlS356IoDQ47HXzCujDqmh4QXgQQn2le71qC4,15337
+narwhals/_spark_like/expr_dt.py,sha256=EuvgesSi-N4DN3F3zRy9kS2So6gx-w7bxlGbyrJieBU,7874
+narwhals/_spark_like/expr_list.py,sha256=1B9OsYCXYEWJqIUm5Id2ikMMKNTwoCyeia5LXRYp-OA,3853
+narwhals/_spark_like/expr_str.py,sha256=iM2nmJpIeNQP8v5W9kyug1wlVir3cM8VDXHVGyHQMPU,2452
+narwhals/_spark_like/expr_struct.py,sha256=haBDpuRhn_nGAFjMF3arhhRr6NfefNei9vEmAOa0fQI,613
+narwhals/_spark_like/group_by.py,sha256=DH7fgToOMLaQXEVPSkMjqzTpdz2ZjDIAM0WoK8XjQFU,1247
+narwhals/_spark_like/namespace.py,sha256=k1UTQez8qMdgQRj6H8yi4jEcAqhZe7a8w83PwVaFLlk,8522
+narwhals/_spark_like/selectors.py,sha256=SzJPoFjyIEviSSvPRvL81o1jjQJcM-Veqb52vFU66JQ,1086
+narwhals/_spark_like/utils.py,sha256=hRQT2SDrKJfZrfFFqDhW-s8UVkfc0LcKuTjbgoeTcj0,11892
+narwhals/_sql/__init__.py,sha256=T7_UCePrrYs1ZeMatvCUYUvQcXvrDjQ4b08_ugWIHAo,87
+narwhals/_sql/__pycache__/__init__.cpython-312.pyc,,
+narwhals/_sql/__pycache__/dataframe.cpython-312.pyc,,
+narwhals/_sql/__pycache__/expr.cpython-312.pyc,,
+narwhals/_sql/__pycache__/expr_dt.cpython-312.pyc,,
+narwhals/_sql/__pycache__/expr_str.cpython-312.pyc,,
+narwhals/_sql/__pycache__/group_by.cpython-312.pyc,,
+narwhals/_sql/__pycache__/namespace.cpython-312.pyc,,
+narwhals/_sql/__pycache__/typing.cpython-312.pyc,,
+narwhals/_sql/dataframe.py,sha256=itTHoiLQ74S0Z8SeRgFT_Ss4jbWBs9La5DrME4Mm3xU,2451
+narwhals/_sql/expr.py,sha256=-7VO3_RWNAmr-2YANZD0_K6EKD3_dBMUTMi1sHtqI20,34572
+narwhals/_sql/expr_dt.py,sha256=QcBGKkp9_gUgPOMGXcfuGsqeC7iT1AAGrq5ZDX-nEKo,1700
+narwhals/_sql/expr_str.py,sha256=RPsPIqySlNmAOOMGVai0nUnpUqhldc1X6jx-Bsnq6TM,7433
+narwhals/_sql/group_by.py,sha256=-yR5J2-Kk0awFRoFnLici00rfTK_5CxFKJSxc-Bt8Zs,1669
+narwhals/_sql/namespace.py,sha256=hvSGHpWebsx05PYipMQp8GRlM1Zx-_qCopPzhv7nbXo,3352
+narwhals/_sql/typing.py,sha256=e3LkLPI4oa2IzykR7BgO9IIfCKRw0vrX4uHxPTB-uJM,487
+narwhals/_translate.py,sha256=z9BXuXTI6YSjep4I1o9hRE35JT-7sLGt8Z9GF01GhRc,9389
+narwhals/_typing.py,sha256=eneOfgi2z_4rGbYnvT_IWmEyMgSUhWrTZ1kaGFWVLNQ,6497
+narwhals/_typing_compat.py,sha256=h-BtLEl7CrZ-hYLlwYTOcCdsUS3dvgvkxQTcDQ7RYmA,2516
+narwhals/_utils.py,sha256=0P_V4Avv5NdS5HSJg_8ECjzQiadLoSlyEdYU6ekiynU,73287
+narwhals/compliant.py,sha256=MYzN7r6qgieJjw68g4I-HKXum0r_fhlf1vAlfRL47yk,920
+narwhals/dataframe.py,sha256=ChwNNRfP78bDtQMlC6FP_Y0f869avDcRCHvAuWwBxq4,137172
+narwhals/dependencies.py,sha256=ABk7GskzfO4JnEBoH4WotfEEYR3KylOqY8anDjt8140,19926
+narwhals/dtypes.py,sha256=iFv3WabAXslxxDd3ZHshkbLXuTvKNFV4kY7EvoeFAcE,33117
+narwhals/exceptions.py,sha256=97IIfR_YmJYZEb53uwoARpegXleq-Im3QMDjZs7thGo,3758
+narwhals/expr.py,sha256=YB1pRIzmMsfZh3D9qW913EAo-LbQMeMoCn_jdx07Xns,110482
+narwhals/expr_cat.py,sha256=Rfyy4Q_oyFmfz2enTebUY2MCQtwA8ZtBFmhUpQ295UU,1250
+narwhals/expr_dt.py,sha256=FFPj3KcdgZrvv4M7-_IKPvivv5GZFTbjsnULxOB3_6Q,31816
+narwhals/expr_list.py,sha256=K99FGLW9IYeK7NRiVKrICJ6NseQJl86YJcf47sfdHPw,14228
+narwhals/expr_name.py,sha256=yhMal_7caymLduWhTs1NRYb5y35bincnoZK5gCQWX5U,4814
+narwhals/expr_str.py,sha256=b45kQ86rDc5oBETxqw_QXKFEKRJ0E6X9DC40o8wgmic,25270
+narwhals/expr_struct.py,sha256=9sHY743_UDsduwgUfip4X_xs-_A-aCHSVdlMsDk8WNA,1790
+narwhals/functions.py,sha256=q4slLkkjBV-17bPPiTDStZi8TETJ7WrMHixtHM6KMgw,71617
+narwhals/group_by.py,sha256=JLE0hEdi_-0dVAL_ayby7DqUUbxQjSMwBsIh0Cb0OtY,6632
+narwhals/plugins.py,sha256=8ZIhps5rCUgf9ilwvmtgqO4sMOaSaRSekvixlLyzRxg,3878
+narwhals/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/schema.py,sha256=4yiRz6Qv373ATpN6kCFNSblUb4vMDX9USpKeJTDRrYI,12369
+narwhals/selectors.py,sha256=Wig5bbVEE8IYYlErkH_xIeTykC6x7tDb1eXqUDlLfBc,10200
+narwhals/series.py,sha256=ET5N0CkDXu4FdcMi7XKQbYPhRWPdAEMGgsNRVH6_grA,103178
+narwhals/series_cat.py,sha256=mikr2q3S8kWo8uTJ4s2z6ZKv9cgn-jC1xNy_tYQaQyw,831
+narwhals/series_dt.py,sha256=O3ZRXCPbwtQbcyqahyNBw3PMMhJAGMd732pSYjGaF4c,23051
+narwhals/series_list.py,sha256=8QsdcP_HGrvcu-w-l_WT28o_tJ2_C7xKWaN5sCf9-_g,7954
+narwhals/series_str.py,sha256=dPKgIEyb1BP6l1hW4Hl8RsngKPWayXcaWdamkbjuxU0,19378
+narwhals/series_struct.py,sha256=bixxdASlxYyP1prDjMmfltVU5212a596VQZE11yszUg,930
+narwhals/sql.py,sha256=MhWT4E3S4gV4fiQCmVlFd6k01irkF4aJhbpzOEdQIas,3767
+narwhals/stable/__init__.py,sha256=WX57ijebHmAZMq_ngLYyOZFTxiBc99dnxldiXkBDccQ,95
+narwhals/stable/__pycache__/__init__.cpython-312.pyc,,
+narwhals/stable/v1/__init__.py,sha256=twpERqdSTJfqf0EC8gZ0kJrxVXRLuC3Z2BlkzgJXpUY,36571
+narwhals/stable/v1/__pycache__/__init__.cpython-312.pyc,,
+narwhals/stable/v1/__pycache__/_dtypes.cpython-312.pyc,,
+narwhals/stable/v1/__pycache__/_namespace.cpython-312.pyc,,
+narwhals/stable/v1/__pycache__/dependencies.cpython-312.pyc,,
+narwhals/stable/v1/__pycache__/dtypes.cpython-312.pyc,,
+narwhals/stable/v1/__pycache__/selectors.cpython-312.pyc,,
+narwhals/stable/v1/__pycache__/typing.cpython-312.pyc,,
+narwhals/stable/v1/_dtypes.py,sha256=ngGP8hQRdYv19GJgtynHPMEg-RUIDOs_jdbGrt5YO9E,2722
+narwhals/stable/v1/_namespace.py,sha256=gfsbT4R4aLmmdArY35LRpEHPiUeZKEEnXGiY9ypFtwE,296
+narwhals/stable/v1/dependencies.py,sha256=aM0IShF4hbaaMEDRJQXvsu4RABZOdBG4QhrpJPxb7fg,5001
+narwhals/stable/v1/dtypes.py,sha256=u2NFDJyCkjsK6p3K9ULJS7CoG16z0Z1MQiACTVkhkH4,1082
+narwhals/stable/v1/selectors.py,sha256=xEA9bBzkpTwUanGGoFwBCcHIAXb8alwrPX1mjzE9mDM,312
+narwhals/stable/v1/typing.py,sha256=9YhcvKJ8jtN8mQBD0q12HShEM6Q-D10DYB-m4lQYzDM,4998
+narwhals/stable/v2/__init__.py,sha256=7eG-5HA3p70dRpmNIG0SRk6A7bq9qahE9yOibwO2KmA,40312
+narwhals/stable/v2/__pycache__/__init__.cpython-312.pyc,,
+narwhals/stable/v2/__pycache__/_namespace.cpython-312.pyc,,
+narwhals/stable/v2/__pycache__/dependencies.cpython-312.pyc,,
+narwhals/stable/v2/__pycache__/dtypes.cpython-312.pyc,,
+narwhals/stable/v2/__pycache__/selectors.cpython-312.pyc,,
+narwhals/stable/v2/__pycache__/typing.cpython-312.pyc,,
+narwhals/stable/v2/_namespace.py,sha256=oYB5nrFGxqqTonkRx9vUanyBxGs2Yb0j7_juMyvnvWA,296
+narwhals/stable/v2/dependencies.py,sha256=vpYWx_dron6wFdbQ60G06EV2UJ_LMd52LDodCrAY5Jg,86
+narwhals/stable/v2/dtypes.py,sha256=iMpk2Kc1mNiQYmboOSgmiAijklSUBHSHF2LTKMKnGe8,80
+narwhals/stable/v2/selectors.py,sha256=sjJL3agHd8Rgf_lWhgCmEKruhWEkwHdX32-n85OqVJU,83
+narwhals/stable/v2/typing.py,sha256=pAR_JL07FgNaLgCenpQVO3E0oFwYAi2wxCS2htgUJUs,2494
+narwhals/testing/__init__.py,sha256=eCy8mtRcHySZiaWPV2r21DLZrznjtRQggj8ygoQms28,219
+narwhals/testing/__pycache__/__init__.cpython-312.pyc,,
+narwhals/testing/asserts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+narwhals/testing/asserts/__pycache__/__init__.cpython-312.pyc,,
+narwhals/testing/asserts/__pycache__/frame.cpython-312.pyc,,
+narwhals/testing/asserts/__pycache__/series.cpython-312.pyc,,
+narwhals/testing/asserts/__pycache__/utils.cpython-312.pyc,,
+narwhals/testing/asserts/frame.py,sha256=SUNo7tFyLcXEyEKK1SHaPmM6O99YSpGYKNf5kY3Obm8,10511
+narwhals/testing/asserts/series.py,sha256=MWhbghtXnT7GX8hsOS31TkoX0TpmkLmsFReaUaPR1F8,11118
+narwhals/testing/asserts/utils.py,sha256=3VLqrRONh5e_-sQfhweOEr7gDjvZISq_o-XxGBn4mrU,2188
+narwhals/this.py,sha256=BbKcj0ReWqE01lznzKjuqq7otXONvjBevWWC5aJhQxs,1584
+narwhals/translate.py,sha256=YlS3UQWdU7JXbZq2ZcY1HVPBQLAKIMFhlY3AOQ_67cM,24169
+narwhals/typing.py,sha256=2imWqcYKdpbSfjjNtwNSQ1Y_hm078_rre1cGX0ox3qg,13970
+narwhals/utils.py,sha256=2GT3XxucWI6l9r9jTwMw7Aha2G73FsSXgXNFZ3O_ZyA,223

.venv_haddock/lib/python3.12/site-packages/narwhals-2.19.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

.venv_haddock/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd

@@ -0,0 +1,1242 @@
+# NumPy static imports for Cython >= 3.0
+#
+# If any of the PyArray_* functions are called, import_array must be
+# called first.  This is done automatically by Cython 3.0+ if a call
+# is not detected inside of the module.
+#
+# Author: Dag Sverre Seljebotn
+#
+
+from cpython.ref cimport Py_INCREF
+from cpython.object cimport PyObject, PyTypeObject, PyObject_TypeCheck
+cimport libc.stdio as stdio
+
+
+cdef extern from *:
+    # Leave a marker that the NumPy declarations came from NumPy itself and not from Cython.
+    # See https://github.com/cython/cython/issues/3573
+    """
+    /* Using NumPy API declarations from "numpy/__init__.cython-30.pxd" */
+    """
+
+
+cdef extern from "numpy/arrayobject.h":
+    # It would be nice to use size_t and ssize_t, but ssize_t has special
+    # implicit conversion rules, so just use "long".
+    # Note: The actual type only matters for Cython promotion, so long
+    #       is closer than int, but could lead to incorrect promotion.
+    #       (Not to worrying, and always the status-quo.)
+    ctypedef signed long npy_intp
+    ctypedef unsigned long npy_uintp
+
+    ctypedef unsigned char      npy_bool
+
+    ctypedef signed char      npy_byte
+    ctypedef signed short     npy_short
+    ctypedef signed int       npy_int
+    ctypedef signed long      npy_long
+    ctypedef signed long long npy_longlong
+
+    ctypedef unsigned char      npy_ubyte
+    ctypedef unsigned short     npy_ushort
+    ctypedef unsigned int       npy_uint
+    ctypedef unsigned long      npy_ulong
+    ctypedef unsigned long long npy_ulonglong
+
+    ctypedef float        npy_float
+    ctypedef double       npy_double
+    ctypedef long double  npy_longdouble
+
+    ctypedef signed char        npy_int8
+    ctypedef signed short       npy_int16
+    ctypedef signed int         npy_int32
+    ctypedef signed long long   npy_int64
+
+    ctypedef unsigned char      npy_uint8
+    ctypedef unsigned short     npy_uint16
+    ctypedef unsigned int       npy_uint32
+    ctypedef unsigned long long npy_uint64
+
+    ctypedef float        npy_float32
+    ctypedef double       npy_float64
+    ctypedef long double  npy_float80
+    ctypedef long double  npy_float96
+    ctypedef long double  npy_float128
+
+    ctypedef struct npy_cfloat:
+        pass
+
+    ctypedef struct npy_cdouble:
+        pass
+
+    ctypedef struct npy_clongdouble:
+        pass
+
+    ctypedef struct npy_complex64:
+        pass
+
+    ctypedef struct npy_complex128:
+        pass
+
+    ctypedef struct npy_complex160:
+        pass
+
+    ctypedef struct npy_complex192:
+        pass
+
+    ctypedef struct npy_complex256:
+        pass
+
+    ctypedef struct PyArray_Dims:
+        npy_intp *ptr
+        int len
+
+
+    cdef enum NPY_TYPES:
+        NPY_BOOL
+        NPY_BYTE
+        NPY_UBYTE
+        NPY_SHORT
+        NPY_USHORT
+        NPY_INT
+        NPY_UINT
+        NPY_LONG
+        NPY_ULONG
+        NPY_LONGLONG
+        NPY_ULONGLONG
+        NPY_FLOAT
+        NPY_DOUBLE
+        NPY_LONGDOUBLE
+        NPY_CFLOAT
+        NPY_CDOUBLE
+        NPY_CLONGDOUBLE
+        NPY_OBJECT
+        NPY_STRING
+        NPY_UNICODE
+        NPY_VSTRING
+        NPY_VOID
+        NPY_DATETIME
+        NPY_TIMEDELTA
+        NPY_NTYPES_LEGACY
+        NPY_NOTYPE
+
+        NPY_INT8
+        NPY_INT16
+        NPY_INT32
+        NPY_INT64
+        NPY_UINT8
+        NPY_UINT16
+        NPY_UINT32
+        NPY_UINT64
+        NPY_FLOAT16
+        NPY_FLOAT32
+        NPY_FLOAT64
+        NPY_FLOAT80
+        NPY_FLOAT96
+        NPY_FLOAT128
+        NPY_COMPLEX64
+        NPY_COMPLEX128
+        NPY_COMPLEX160
+        NPY_COMPLEX192
+        NPY_COMPLEX256
+
+        NPY_INTP
+        NPY_UINTP
+        NPY_DEFAULT_INT  # Not a compile time constant (normally)!
+
+    ctypedef enum NPY_ORDER:
+        NPY_ANYORDER
+        NPY_CORDER
+        NPY_FORTRANORDER
+        NPY_KEEPORDER
+
+    ctypedef enum NPY_CASTING:
+        NPY_NO_CASTING
+        NPY_EQUIV_CASTING
+        NPY_SAFE_CASTING
+        NPY_SAME_KIND_CASTING
+        NPY_UNSAFE_CASTING
+        NPY_SAME_VALUE_CASTING
+
+    ctypedef enum NPY_CLIPMODE:
+        NPY_CLIP
+        NPY_WRAP
+        NPY_RAISE
+
+    ctypedef enum NPY_SCALARKIND:
+        NPY_NOSCALAR,
+        NPY_BOOL_SCALAR,
+        NPY_INTPOS_SCALAR,
+        NPY_INTNEG_SCALAR,
+        NPY_FLOAT_SCALAR,
+        NPY_COMPLEX_SCALAR,
+        NPY_OBJECT_SCALAR
+
+    ctypedef enum NPY_SORTKIND:
+        NPY_QUICKSORT
+        NPY_HEAPSORT
+        NPY_MERGESORT
+
+    ctypedef enum NPY_SEARCHSIDE:
+        NPY_SEARCHLEFT
+        NPY_SEARCHRIGHT
+
+    enum:
+        NPY_ARRAY_C_CONTIGUOUS
+        NPY_ARRAY_F_CONTIGUOUS
+        NPY_ARRAY_OWNDATA
+        NPY_ARRAY_FORCECAST
+        NPY_ARRAY_ENSURECOPY
+        NPY_ARRAY_ENSUREARRAY
+        NPY_ARRAY_ELEMENTSTRIDES
+        NPY_ARRAY_ALIGNED
+        NPY_ARRAY_NOTSWAPPED
+        NPY_ARRAY_WRITEABLE
+        NPY_ARRAY_WRITEBACKIFCOPY
+
+        NPY_ARRAY_BEHAVED
+        NPY_ARRAY_BEHAVED_NS
+        NPY_ARRAY_CARRAY
+        NPY_ARRAY_CARRAY_RO
+        NPY_ARRAY_FARRAY
+        NPY_ARRAY_FARRAY_RO
+        NPY_ARRAY_DEFAULT
+
+        NPY_ARRAY_IN_ARRAY
+        NPY_ARRAY_OUT_ARRAY
+        NPY_ARRAY_INOUT_ARRAY
+        NPY_ARRAY_IN_FARRAY
+        NPY_ARRAY_OUT_FARRAY
+        NPY_ARRAY_INOUT_FARRAY
+
+        NPY_ARRAY_UPDATE_ALL
+
+    cdef enum:
+        NPY_MAXDIMS  # 64 on NumPy 2.x and 32 on NumPy 1.x
+        NPY_RAVEL_AXIS  # Used for functions like PyArray_Mean
+
+    ctypedef void (*PyArray_VectorUnaryFunc)(void *, void *, npy_intp, void *,  void *)
+
+    ctypedef struct PyArray_ArrayDescr:
+        # shape is a tuple, but Cython doesn't support "tuple shape"
+        # inside a non-PyObject declaration, so we have to declare it
+        # as just a PyObject*.
+        PyObject* shape
+
+    ctypedef struct PyArray_Descr:
+        pass
+
+    ctypedef class numpy.dtype [object PyArray_Descr, check_size ignore]:
+        # Use PyDataType_* macros when possible, however there are no macros
+        # for accessing some of the fields, so some are defined.
+        cdef PyTypeObject* typeobj
+        cdef char kind
+        cdef char type
+        # Numpy sometimes mutates this without warning (e.g. it'll
+        # sometimes change "|" to "<" in shared dtype objects on
+        # little-endian machines). If this matters to you, use
+        # PyArray_IsNativeByteOrder(dtype.byteorder) instead of
+        # directly accessing this field.
+        cdef char byteorder
+        cdef int type_num
+
+        @property
+        cdef inline npy_intp itemsize(self) noexcept nogil:
+            return PyDataType_ELSIZE(self)
+
+        @property
+        cdef inline npy_intp alignment(self) noexcept nogil:
+            return PyDataType_ALIGNMENT(self)
+
+        # Use fields/names with care as they may be NULL.  You must check
+        # for this using PyDataType_HASFIELDS.
+        @property
+        cdef inline object fields(self):
+            return <object>PyDataType_FIELDS(self)
+
+        @property
+        cdef inline tuple names(self):
+            return <tuple>PyDataType_NAMES(self)
+
+        # Use PyDataType_HASSUBARRAY to test whether this field is
+        # valid (the pointer can be NULL). Most users should access
+        # this field via the inline helper method PyDataType_SHAPE.
+        @property
+        cdef inline PyArray_ArrayDescr* subarray(self) noexcept nogil:
+            return PyDataType_SUBARRAY(self)
+
+        @property
+        cdef inline npy_uint64 flags(self) noexcept nogil:
+            """The data types flags."""
+            return PyDataType_FLAGS(self)
+
+
+    ctypedef class numpy.flatiter [object PyArrayIterObject, check_size ignore]:
+        # Use through macros
+        pass
+
+    ctypedef class numpy.broadcast [object PyArrayMultiIterObject, check_size ignore]:
+
+        @property
+        cdef inline int numiter(self) noexcept nogil:
+            """The number of arrays that need to be broadcast to the same shape."""
+            return PyArray_MultiIter_NUMITER(self)
+
+        @property
+        cdef inline npy_intp size(self) noexcept nogil:
+            """The total broadcasted size."""
+            return PyArray_MultiIter_SIZE(self)
+
+        @property
+        cdef inline npy_intp index(self) noexcept nogil:
+            """The current (1-d) index into the broadcasted result."""
+            return PyArray_MultiIter_INDEX(self)
+
+        @property
+        cdef inline int nd(self) noexcept nogil:
+            """The number of dimensions in the broadcasted result."""
+            return PyArray_MultiIter_NDIM(self)
+
+        @property
+        cdef inline npy_intp* dimensions(self) noexcept nogil:
+            """The shape of the broadcasted result."""
+            return PyArray_MultiIter_DIMS(self)
+
+        @property
+        cdef inline void** iters(self) noexcept nogil:
+            """An array of iterator objects that holds the iterators for the arrays to be broadcast together.
+            On return, the iterators are adjusted for broadcasting."""
+            return PyArray_MultiIter_ITERS(self)
+
+
+    ctypedef struct PyArrayObject:
+        # For use in situations where ndarray can't replace PyArrayObject*,
+        # like PyArrayObject**.
+        pass
+
+    ctypedef class numpy.ndarray [object PyArrayObject, check_size ignore]:
+        cdef __cythonbufferdefaults__ = {"mode": "strided"}
+
+        # NOTE: no field declarations since direct access is deprecated since NumPy 1.7
+        # Instead, we use properties that map to the corresponding C-API functions.
+
+        @property
+        cdef inline PyObject* base(self) noexcept nogil:
+            """Returns a borrowed reference to the object owning the data/memory.
+            """
+            return PyArray_BASE(self)
+
+        @property
+        cdef inline dtype descr(self):
+            """Returns an owned reference to the dtype of the array.
+            """
+            return <dtype>PyArray_DESCR(self)
+
+        @property
+        cdef inline int ndim(self) noexcept nogil:
+            """Returns the number of dimensions in the array.
+            """
+            return PyArray_NDIM(self)
+
+        @property
+        cdef inline npy_intp *shape(self) noexcept nogil:
+            """Returns a pointer to the dimensions/shape of the array.
+            The number of elements matches the number of dimensions of the array (ndim).
+            Can return NULL for 0-dimensional arrays.
+            """
+            return PyArray_DIMS(self)
+
+        @property
+        cdef inline npy_intp *strides(self) noexcept nogil:
+            """Returns a pointer to the strides of the array.
+            The number of elements matches the number of dimensions of the array (ndim).
+            """
+            return PyArray_STRIDES(self)
+
+        @property
+        cdef inline npy_intp size(self) noexcept nogil:
+            """Returns the total size (in number of elements) of the array.
+            """
+            return PyArray_SIZE(self)
+
+        @property
+        cdef inline char* data(self) noexcept nogil:
+            """The pointer to the data buffer as a char*.
+            This is provided for legacy reasons to avoid direct struct field access.
+            For new code that needs this access, you probably want to cast the result
+            of `PyArray_DATA()` instead, which returns a 'void*'.
+            """
+            return PyArray_BYTES(self)
+
+
+    int _import_array() except -1
+    # A second definition so _import_array isn't marked as used when we use it here.
+    # Do not use - subject to change any time.
+    int __pyx_import_array "_import_array"() except -1
+
+    #
+    # Macros from ndarrayobject.h
+    #
+    bint PyArray_CHKFLAGS(ndarray m, int flags) nogil
+    bint PyArray_IS_C_CONTIGUOUS(ndarray arr) nogil
+    bint PyArray_IS_F_CONTIGUOUS(ndarray arr) nogil
+    bint PyArray_ISCONTIGUOUS(ndarray m) nogil
+    bint PyArray_ISWRITEABLE(ndarray m) nogil
+    bint PyArray_ISALIGNED(ndarray m) nogil
+
+    int PyArray_NDIM(ndarray) nogil
+    bint PyArray_ISONESEGMENT(ndarray) nogil
+    bint PyArray_ISFORTRAN(ndarray) nogil
+    int PyArray_FORTRANIF(ndarray) nogil
+
+    void* PyArray_DATA(ndarray) nogil
+    char* PyArray_BYTES(ndarray) nogil
+
+    npy_intp* PyArray_DIMS(ndarray) nogil
+    npy_intp* PyArray_STRIDES(ndarray) nogil
+    npy_intp PyArray_DIM(ndarray, size_t) nogil
+    npy_intp PyArray_STRIDE(ndarray, size_t) nogil
+
+    PyObject *PyArray_BASE(ndarray) nogil  # returns borrowed reference!
+    PyArray_Descr *PyArray_DESCR(ndarray) nogil  # returns borrowed reference to dtype!
+    PyArray_Descr *PyArray_DTYPE(ndarray) nogil  # returns borrowed reference to dtype! NP 1.7+ alias for descr.
+    int PyArray_FLAGS(ndarray) nogil
+    void PyArray_CLEARFLAGS(ndarray, int flags) nogil  # Added in NumPy 1.7
+    void PyArray_ENABLEFLAGS(ndarray, int flags) nogil  # Added in NumPy 1.7
+    npy_intp PyArray_ITEMSIZE(ndarray) nogil
+    int PyArray_TYPE(ndarray arr) nogil
+
+    object PyArray_GETITEM(ndarray arr, void *itemptr)
+    int PyArray_SETITEM(ndarray arr, void *itemptr, object obj) except -1
+
+    bint PyTypeNum_ISBOOL(int) nogil
+    bint PyTypeNum_ISUNSIGNED(int) nogil
+    bint PyTypeNum_ISSIGNED(int) nogil
+    bint PyTypeNum_ISINTEGER(int) nogil
+    bint PyTypeNum_ISFLOAT(int) nogil
+    bint PyTypeNum_ISNUMBER(int) nogil
+    bint PyTypeNum_ISSTRING(int) nogil
+    bint PyTypeNum_ISCOMPLEX(int) nogil
+    bint PyTypeNum_ISFLEXIBLE(int) nogil
+    bint PyTypeNum_ISUSERDEF(int) nogil
+    bint PyTypeNum_ISEXTENDED(int) nogil
+    bint PyTypeNum_ISOBJECT(int) nogil
+
+    npy_intp PyDataType_ELSIZE(dtype) nogil
+    npy_intp PyDataType_ALIGNMENT(dtype) nogil
+    PyObject* PyDataType_METADATA(dtype) nogil
+    PyArray_ArrayDescr* PyDataType_SUBARRAY(dtype) nogil
+    PyObject* PyDataType_NAMES(dtype) nogil
+    PyObject* PyDataType_FIELDS(dtype) nogil
+
+    bint PyDataType_ISBOOL(dtype) nogil
+    bint PyDataType_ISUNSIGNED(dtype) nogil
+    bint PyDataType_ISSIGNED(dtype) nogil
+    bint PyDataType_ISINTEGER(dtype) nogil
+    bint PyDataType_ISFLOAT(dtype) nogil
+    bint PyDataType_ISNUMBER(dtype) nogil
+    bint PyDataType_ISSTRING(dtype) nogil
+    bint PyDataType_ISCOMPLEX(dtype) nogil
+    bint PyDataType_ISFLEXIBLE(dtype) nogil
+    bint PyDataType_ISUSERDEF(dtype) nogil
+    bint PyDataType_ISEXTENDED(dtype) nogil
+    bint PyDataType_ISOBJECT(dtype) nogil
+    bint PyDataType_HASFIELDS(dtype) nogil
+    bint PyDataType_HASSUBARRAY(dtype) nogil
+    npy_uint64 PyDataType_FLAGS(dtype) nogil
+
+    bint PyArray_ISBOOL(ndarray) nogil
+    bint PyArray_ISUNSIGNED(ndarray) nogil
+    bint PyArray_ISSIGNED(ndarray) nogil
+    bint PyArray_ISINTEGER(ndarray) nogil
+    bint PyArray_ISFLOAT(ndarray) nogil
+    bint PyArray_ISNUMBER(ndarray) nogil
+    bint PyArray_ISSTRING(ndarray) nogil
+    bint PyArray_ISCOMPLEX(ndarray) nogil
+    bint PyArray_ISFLEXIBLE(ndarray) nogil
+    bint PyArray_ISUSERDEF(ndarray) nogil
+    bint PyArray_ISEXTENDED(ndarray) nogil
+    bint PyArray_ISOBJECT(ndarray) nogil
+    bint PyArray_HASFIELDS(ndarray) nogil
+
+    bint PyArray_ISVARIABLE(ndarray) nogil
+
+    bint PyArray_SAFEALIGNEDCOPY(ndarray) nogil
+    bint PyArray_ISNBO(char) nogil              # works on ndarray.byteorder
+    bint PyArray_IsNativeByteOrder(char) nogil # works on ndarray.byteorder
+    bint PyArray_ISNOTSWAPPED(ndarray) nogil
+    bint PyArray_ISBYTESWAPPED(ndarray) nogil
+
+    bint PyArray_FLAGSWAP(ndarray, int) nogil
+
+    bint PyArray_ISCARRAY(ndarray) nogil
+    bint PyArray_ISCARRAY_RO(ndarray) nogil
+    bint PyArray_ISFARRAY(ndarray) nogil
+    bint PyArray_ISFARRAY_RO(ndarray) nogil
+    bint PyArray_ISBEHAVED(ndarray) nogil
+    bint PyArray_ISBEHAVED_RO(ndarray) nogil
+
+
+    bint PyDataType_ISNOTSWAPPED(dtype) nogil
+    bint PyDataType_ISBYTESWAPPED(dtype) nogil
+
+    bint PyArray_DescrCheck(object)
+
+    bint PyArray_Check(object)
+    bint PyArray_CheckExact(object)
+
+    # Cannot be supported due to out arg:
+    # bint PyArray_HasArrayInterfaceType(object, dtype, object, object&)
+    # bint PyArray_HasArrayInterface(op, out)
+
+
+    bint PyArray_IsZeroDim(object)
+    # Cannot be supported due to ## ## in macro:
+    # bint PyArray_IsScalar(object, verbatim work)
+    bint PyArray_CheckScalar(object)
+    bint PyArray_IsPythonNumber(object)
+    bint PyArray_IsPythonScalar(object)
+    bint PyArray_IsAnyScalar(object)
+    bint PyArray_CheckAnyScalar(object)
+
+    ndarray PyArray_GETCONTIGUOUS(ndarray)
+    bint PyArray_SAMESHAPE(ndarray, ndarray) nogil
+    npy_intp PyArray_SIZE(ndarray) nogil
+    npy_intp PyArray_NBYTES(ndarray) nogil
+
+    object PyArray_FROM_O(object)
+    object PyArray_FROM_OF(object m, int flags)
+    object PyArray_FROM_OT(object m, int type)
+    object PyArray_FROM_OTF(object m, int type, int flags)
+    object PyArray_FROMANY(object m, int type, int min, int max, int flags)
+    object PyArray_ZEROS(int nd, npy_intp* dims, int type, int fortran)
+    object PyArray_EMPTY(int nd, npy_intp* dims, int type, int fortran)
+    void PyArray_FILLWBYTE(ndarray, int val)
+    object PyArray_ContiguousFromAny(op, int, int min_depth, int max_depth)
+    unsigned char PyArray_EquivArrTypes(ndarray a1, ndarray a2)
+    bint PyArray_EquivByteorders(int b1, int b2) nogil
+    object PyArray_SimpleNew(int nd, npy_intp* dims, int typenum)
+    object PyArray_SimpleNewFromData(int nd, npy_intp* dims, int typenum, void* data)
+    #object PyArray_SimpleNewFromDescr(int nd, npy_intp* dims, dtype descr)
+    object PyArray_ToScalar(void* data, ndarray arr)
+
+    void* PyArray_GETPTR1(ndarray m, npy_intp i) nogil
+    void* PyArray_GETPTR2(ndarray m, npy_intp i, npy_intp j) nogil
+    void* PyArray_GETPTR3(ndarray m, npy_intp i, npy_intp j, npy_intp k) nogil
+    void* PyArray_GETPTR4(ndarray m, npy_intp i, npy_intp j, npy_intp k, npy_intp l) nogil
+
+    # Cannot be supported due to out arg
+    # void PyArray_DESCR_REPLACE(descr)
+
+
+    object PyArray_Copy(ndarray)
+    object PyArray_FromObject(object op, int type, int min_depth, int max_depth)
+    object PyArray_ContiguousFromObject(object op, int type, int min_depth, int max_depth)
+    object PyArray_CopyFromObject(object op, int type, int min_depth, int max_depth)
+
+    object PyArray_Cast(ndarray mp, int type_num)
+    object PyArray_Take(ndarray ap, object items, int axis)
+    object PyArray_Put(ndarray ap, object items, object values)
+
+    void PyArray_ITER_RESET(flatiter it) nogil
+    void PyArray_ITER_NEXT(flatiter it) nogil
+    void PyArray_ITER_GOTO(flatiter it, npy_intp* destination) nogil
+    void PyArray_ITER_GOTO1D(flatiter it, npy_intp ind) nogil
+    void* PyArray_ITER_DATA(flatiter it) nogil
+    bint PyArray_ITER_NOTDONE(flatiter it) nogil
+
+    void PyArray_MultiIter_RESET(broadcast multi) nogil
+    void PyArray_MultiIter_NEXT(broadcast multi) nogil
+    void PyArray_MultiIter_GOTO(broadcast multi, npy_intp dest) nogil
+    void PyArray_MultiIter_GOTO1D(broadcast multi, npy_intp ind) nogil
+    void* PyArray_MultiIter_DATA(broadcast multi, npy_intp i) nogil
+    void PyArray_MultiIter_NEXTi(broadcast multi, npy_intp i) nogil
+    bint PyArray_MultiIter_NOTDONE(broadcast multi) nogil
+    npy_intp PyArray_MultiIter_SIZE(broadcast multi) nogil
+    int PyArray_MultiIter_NDIM(broadcast multi) nogil
+    npy_intp PyArray_MultiIter_INDEX(broadcast multi) nogil
+    int PyArray_MultiIter_NUMITER(broadcast multi) nogil
+    npy_intp* PyArray_MultiIter_DIMS(broadcast multi) nogil
+    void** PyArray_MultiIter_ITERS(broadcast multi) nogil
+
+    # Functions from __multiarray_api.h
+
+    # Functions taking dtype and returning object/ndarray are disabled
+    # for now as they steal dtype references. I'm conservative and disable
+    # more than is probably needed until it can be checked further.
+    int PyArray_INCREF (ndarray) except *  # uses PyArray_Item_INCREF...
+    int PyArray_XDECREF (ndarray) except *  # uses PyArray_Item_DECREF...
+    dtype PyArray_DescrFromType (int)
+    object PyArray_TypeObjectFromType (int)
+    char * PyArray_Zero (ndarray)
+    char * PyArray_One (ndarray)
+    #object PyArray_CastToType (ndarray, dtype, int)
+    int PyArray_CanCastSafely (int, int)  # writes errors
+    npy_bool PyArray_CanCastTo (dtype, dtype)  # writes errors
+    int PyArray_ObjectType (object, int) except 0
+    dtype PyArray_DescrFromObject (object, dtype)
+    #ndarray* PyArray_ConvertToCommonType (object, int *)
+    dtype PyArray_DescrFromScalar (object)
+    dtype PyArray_DescrFromTypeObject (object)
+    npy_intp PyArray_Size (object)
+    #object PyArray_Scalar (void *, dtype, object)
+    #object PyArray_FromScalar (object, dtype)
+    void PyArray_ScalarAsCtype (object, void *)
+    #int PyArray_CastScalarToCtype (object, void *, dtype)
+    #int PyArray_CastScalarDirect (object, dtype, void *, int)
+    #PyArray_VectorUnaryFunc * PyArray_GetCastFunc (dtype, int)
+    #object PyArray_FromAny (object, dtype, int, int, int, object)
+    object PyArray_EnsureArray (object)
+    object PyArray_EnsureAnyArray (object)
+    #object PyArray_FromFile (stdio.FILE *, dtype, npy_intp, char *)
+    #object PyArray_FromString (char *, npy_intp, dtype, npy_intp, char *)
+    #object PyArray_FromBuffer (object, dtype, npy_intp, npy_intp)
+    #object PyArray_FromIter (object, dtype, npy_intp)
+    object PyArray_Return (ndarray)
+    #object PyArray_GetField (ndarray, dtype, int)
+    #int PyArray_SetField (ndarray, dtype, int, object) except -1
+    object PyArray_Byteswap (ndarray, npy_bool)
+    object PyArray_Resize (ndarray, PyArray_Dims *, int, NPY_ORDER)
+    int PyArray_CopyInto (ndarray, ndarray) except -1
+    int PyArray_CopyAnyInto (ndarray, ndarray) except -1
+    int PyArray_CopyObject (ndarray, object) except -1
+    object PyArray_NewCopy (ndarray, NPY_ORDER)
+    object PyArray_ToList (ndarray)
+    object PyArray_ToString (ndarray, NPY_ORDER)
+    int PyArray_ToFile (ndarray, stdio.FILE *, char *, char *) except -1
+    int PyArray_Dump (object, object, int) except -1
+    object PyArray_Dumps (object, int)
+    int PyArray_ValidType (int)  # Cannot error
+    void PyArray_UpdateFlags (ndarray, int)
+    object PyArray_New (type, int, npy_intp *, int, npy_intp *, void *, int, int, object)
+    #object PyArray_NewFromDescr (type, dtype, int, npy_intp *, npy_intp *, void *, int, object)
+    #dtype PyArray_DescrNew (dtype)
+    dtype PyArray_DescrNewFromType (int)
+    double PyArray_GetPriority (object, double)  # clears errors as of 1.25
+    object PyArray_IterNew (object)
+    object PyArray_MultiIterNew (int, ...)
+
+    int PyArray_PyIntAsInt (object) except? -1
+    npy_intp PyArray_PyIntAsIntp (object)
+    int PyArray_Broadcast (broadcast) except -1
+    int PyArray_FillWithScalar (ndarray, object) except -1
+    npy_bool PyArray_CheckStrides (int, int, npy_intp, npy_intp, npy_intp *, npy_intp *)
+    dtype PyArray_DescrNewByteorder (dtype, char)
+    object PyArray_IterAllButAxis (object, int *)
+    #object PyArray_CheckFromAny (object, dtype, int, int, int, object)
+    #object PyArray_FromArray (ndarray, dtype, int)
+    object PyArray_FromInterface (object)
+    object PyArray_FromStructInterface (object)
+    #object PyArray_FromArrayAttr (object, dtype, object)
+    #NPY_SCALARKIND PyArray_ScalarKind (int, ndarray*)
+    int PyArray_CanCoerceScalar (int, int, NPY_SCALARKIND)
+    npy_bool PyArray_CanCastScalar (type, type)
+    int PyArray_RemoveSmallest (broadcast) except -1
+    int PyArray_ElementStrides (object)
+    void PyArray_Item_INCREF (char *, dtype) except *
+    void PyArray_Item_XDECREF (char *, dtype) except *
+    object PyArray_Transpose (ndarray, PyArray_Dims *)
+    object PyArray_TakeFrom (ndarray, object, int, ndarray, NPY_CLIPMODE)
+    object PyArray_PutTo (ndarray, object, object, NPY_CLIPMODE)
+    object PyArray_PutMask (ndarray, object, object)
+    object PyArray_Repeat (ndarray, object, int)
+    object PyArray_Choose (ndarray, object, ndarray, NPY_CLIPMODE)
+    int PyArray_Sort (ndarray, int, NPY_SORTKIND) except -1
+    object PyArray_ArgSort (ndarray, int, NPY_SORTKIND)
+    object PyArray_SearchSorted (ndarray, object, NPY_SEARCHSIDE, PyObject *)
+    object PyArray_ArgMax (ndarray, int, ndarray)
+    object PyArray_ArgMin (ndarray, int, ndarray)
+    object PyArray_Reshape (ndarray, object)
+    object PyArray_Newshape (ndarray, PyArray_Dims *, NPY_ORDER)
+    object PyArray_Squeeze (ndarray)
+    #object PyArray_View (ndarray, dtype, type)
+    object PyArray_SwapAxes (ndarray, int, int)
+    object PyArray_Max (ndarray, int, ndarray)
+    object PyArray_Min (ndarray, int, ndarray)
+    object PyArray_Ptp (ndarray, int, ndarray)
+    object PyArray_Mean (ndarray, int, int, ndarray)
+    object PyArray_Trace (ndarray, int, int, int, int, ndarray)
+    object PyArray_Diagonal (ndarray, int, int, int)
+    object PyArray_Clip (ndarray, object, object, ndarray)
+    object PyArray_Conjugate (ndarray, ndarray)
+    object PyArray_Nonzero (ndarray)
+    object PyArray_Std (ndarray, int, int, ndarray, int)
+    object PyArray_Sum (ndarray, int, int, ndarray)
+    object PyArray_CumSum (ndarray, int, int, ndarray)
+    object PyArray_Prod (ndarray, int, int, ndarray)
+    object PyArray_CumProd (ndarray, int, int, ndarray)
+    object PyArray_All (ndarray, int, ndarray)
+    object PyArray_Any (ndarray, int, ndarray)
+    object PyArray_Compress (ndarray, object, int, ndarray)
+    object PyArray_Flatten (ndarray, NPY_ORDER)
+    object PyArray_Ravel (ndarray, NPY_ORDER)
+    npy_intp PyArray_MultiplyList (npy_intp *, int)
+    int PyArray_MultiplyIntList (int *, int)
+    void * PyArray_GetPtr (ndarray, npy_intp*)
+    int PyArray_CompareLists (npy_intp *, npy_intp *, int)
+    #int PyArray_AsCArray (object*, void *, npy_intp *, int, dtype)
+    int PyArray_Free (object, void *)
+    #int PyArray_Converter (object, object*)
+    int PyArray_IntpFromSequence (object, npy_intp *, int) except -1
+    object PyArray_Concatenate (object, int)
+    object PyArray_InnerProduct (object, object)
+    object PyArray_MatrixProduct (object, object)
+    object PyArray_Correlate (object, object, int)
+    #int PyArray_DescrConverter (object, dtype*) except 0
+    #int PyArray_DescrConverter2 (object, dtype*) except 0
+    int PyArray_IntpConverter (object, PyArray_Dims *) except 0
+    #int PyArray_BufferConverter (object, chunk) except 0
+    int PyArray_AxisConverter (object, int *) except 0
+    int PyArray_BoolConverter (object, npy_bool *) except 0
+    int PyArray_ByteorderConverter (object, char *) except 0
+    int PyArray_OrderConverter (object, NPY_ORDER *) except 0
+    unsigned char PyArray_EquivTypes (dtype, dtype)  # clears errors
+    #object PyArray_Zeros (int, npy_intp *, dtype, int)
+    #object PyArray_Empty (int, npy_intp *, dtype, int)
+    object PyArray_Where (object, object, object)
+    object PyArray_Arange (double, double, double, int)
+    #object PyArray_ArangeObj (object, object, object, dtype)
+    int PyArray_SortkindConverter (object, NPY_SORTKIND *) except 0
+    object PyArray_LexSort (object, int)
+    object PyArray_Round (ndarray, int, ndarray)
+    unsigned char PyArray_EquivTypenums (int, int)
+    int PyArray_RegisterDataType (dtype) except -1
+    int PyArray_RegisterCastFunc (dtype, int, PyArray_VectorUnaryFunc *) except -1
+    int PyArray_RegisterCanCast (dtype, int, NPY_SCALARKIND) except -1
+    #void PyArray_InitArrFuncs (PyArray_ArrFuncs *)
+    object PyArray_IntTupleFromIntp (int, npy_intp *)
+    int PyArray_ClipmodeConverter (object, NPY_CLIPMODE *) except 0
+    #int PyArray_OutputConverter (object, ndarray*) except 0
+    object PyArray_BroadcastToShape (object, npy_intp *, int)
+    #int PyArray_DescrAlignConverter (object, dtype*) except 0
+    #int PyArray_DescrAlignConverter2 (object, dtype*) except 0
+    int PyArray_SearchsideConverter (object, void *) except 0
+    object PyArray_CheckAxis (ndarray, int *, int)
+    npy_intp PyArray_OverflowMultiplyList (npy_intp *, int)
+    int PyArray_SetBaseObject(ndarray, base) except -1 # NOTE: steals a reference to base! Use "set_array_base()" instead.
+
+    # The memory handler functions require the NumPy 1.22 API
+    # and may require defining NPY_TARGET_VERSION
+    ctypedef struct PyDataMemAllocator:
+        void *ctx
+        void* (*malloc) (void *ctx, size_t size)
+        void* (*calloc) (void *ctx, size_t nelem, size_t elsize)
+        void* (*realloc) (void *ctx, void *ptr, size_t new_size)
+        void (*free) (void *ctx, void *ptr, size_t size)
+
+    ctypedef struct PyDataMem_Handler:
+        char* name
+        npy_uint8 version
+        PyDataMemAllocator allocator
+
+    object PyDataMem_SetHandler(object handler)
+    object PyDataMem_GetHandler()
+
+    # additional datetime related functions are defined below
+
+
+# Typedefs that matches the runtime dtype objects in
+# the numpy module.
+
+# The ones that are commented out needs an IFDEF function
+# in Cython to enable them only on the right systems.
+
+ctypedef npy_int8       int8_t
+ctypedef npy_int16      int16_t
+ctypedef npy_int32      int32_t
+ctypedef npy_int64      int64_t
+
+ctypedef npy_uint8      uint8_t
+ctypedef npy_uint16     uint16_t
+ctypedef npy_uint32     uint32_t
+ctypedef npy_uint64     uint64_t
+
+ctypedef npy_float32    float32_t
+ctypedef npy_float64    float64_t
+#ctypedef npy_float80    float80_t
+#ctypedef npy_float128   float128_t
+
+ctypedef float complex  complex64_t
+ctypedef double complex complex128_t
+
+ctypedef npy_longlong   longlong_t
+ctypedef npy_ulonglong  ulonglong_t
+
+ctypedef npy_intp       intp_t
+ctypedef npy_uintp      uintp_t
+
+ctypedef npy_double     float_t
+ctypedef npy_double     double_t
+ctypedef npy_longdouble longdouble_t
+
+ctypedef float complex       cfloat_t
+ctypedef double complex      cdouble_t
+ctypedef double complex      complex_t
+ctypedef long double complex clongdouble_t
+
+cdef inline object PyArray_MultiIterNew1(a):
+    return PyArray_MultiIterNew(1, <void*>a)
+
+cdef inline object PyArray_MultiIterNew2(a, b):
+    return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+
+cdef inline object PyArray_MultiIterNew3(a, b, c):
+    return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+
+cdef inline object PyArray_MultiIterNew4(a, b, c, d):
+    return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+
+cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
+    return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+
+cdef inline tuple PyDataType_SHAPE(dtype d):
+    if PyDataType_HASSUBARRAY(d):
+        return <tuple>d.subarray.shape
+    else:
+        return ()
+
+
+cdef extern from "numpy/ndarrayobject.h":
+    PyTypeObject PyTimedeltaArrType_Type
+    PyTypeObject PyDatetimeArrType_Type
+    ctypedef int64_t npy_timedelta
+    ctypedef int64_t npy_datetime
+
+cdef extern from "numpy/ndarraytypes.h":
+    ctypedef struct PyArray_DatetimeMetaData:
+        NPY_DATETIMEUNIT base
+        int64_t num
+
+    ctypedef struct npy_datetimestruct:
+        int64_t year
+        int32_t month, day, hour, min, sec, us, ps, as
+
+    # Iterator API added in v1.6
+    #
+    # These don't match the definition in the C API because Cython can't wrap
+    # function pointers that return functions.
+    # https://github.com/cython/cython/issues/6720
+    ctypedef int (*NpyIter_IterNextFunc "NpyIter_IterNextFunc *")(NpyIter* it) noexcept nogil
+    ctypedef void (*NpyIter_GetMultiIndexFunc "NpyIter_GetMultiIndexFunc *")(NpyIter* it, npy_intp* outcoords) noexcept nogil
+
+
+cdef extern from "numpy/arrayscalars.h":
+
+    # abstract types
+    ctypedef class numpy.generic [object PyObject]:
+        pass
+    ctypedef class numpy.number [object PyObject]:
+        pass
+    ctypedef class numpy.integer [object PyObject]:
+        pass
+    ctypedef class numpy.signedinteger [object PyObject]:
+        pass
+    ctypedef class numpy.unsignedinteger [object PyObject]:
+        pass
+    ctypedef class numpy.inexact [object PyObject]:
+        pass
+    ctypedef class numpy.floating [object PyObject]:
+        pass
+    ctypedef class numpy.complexfloating [object PyObject]:
+        pass
+    ctypedef class numpy.flexible [object PyObject]:
+        pass
+    ctypedef class numpy.character [object PyObject]:
+        pass
+
+    ctypedef struct PyDatetimeScalarObject:
+        # PyObject_HEAD
+        npy_datetime obval
+        PyArray_DatetimeMetaData obmeta
+
+    ctypedef struct PyTimedeltaScalarObject:
+        # PyObject_HEAD
+        npy_timedelta obval
+        PyArray_DatetimeMetaData obmeta
+
+    ctypedef enum NPY_DATETIMEUNIT:
+        NPY_FR_Y
+        NPY_FR_M
+        NPY_FR_W
+        NPY_FR_D
+        NPY_FR_B
+        NPY_FR_h
+        NPY_FR_m
+        NPY_FR_s
+        NPY_FR_ms
+        NPY_FR_us
+        NPY_FR_ns
+        NPY_FR_ps
+        NPY_FR_fs
+        NPY_FR_as
+        NPY_FR_GENERIC
+
+
+cdef extern from "numpy/arrayobject.h":
+    # These are part of the C-API defined in `__multiarray_api.h`
+
+    # NumPy internal definitions in datetime_strings.c:
+    int get_datetime_iso_8601_strlen "NpyDatetime_GetDatetimeISO8601StrLen" (
+            int local, NPY_DATETIMEUNIT base)
+    int make_iso_8601_datetime "NpyDatetime_MakeISO8601Datetime" (
+            npy_datetimestruct *dts, char *outstr, npy_intp outlen,
+            int local, int utc, NPY_DATETIMEUNIT base, int tzoffset,
+            NPY_CASTING casting) except -1
+
+    # NumPy internal definition in datetime.c:
+    # May return 1 to indicate that object does not appear to be a datetime
+    # (returns 0 on success).
+    int convert_pydatetime_to_datetimestruct "NpyDatetime_ConvertPyDateTimeToDatetimeStruct" (
+            PyObject *obj, npy_datetimestruct *out,
+            NPY_DATETIMEUNIT *out_bestunit, int apply_tzinfo) except -1
+    int convert_datetime64_to_datetimestruct "NpyDatetime_ConvertDatetime64ToDatetimeStruct" (
+            PyArray_DatetimeMetaData *meta, npy_datetime dt,
+            npy_datetimestruct *out) except -1
+    int convert_datetimestruct_to_datetime64 "NpyDatetime_ConvertDatetimeStructToDatetime64"(
+            PyArray_DatetimeMetaData *meta, const npy_datetimestruct *dts,
+            npy_datetime *out) except -1
+
+
+#
+# ufunc API
+#
+
+cdef extern from "numpy/ufuncobject.h":
+
+    ctypedef void (*PyUFuncGenericFunction) (char **, npy_intp *, npy_intp *, void *)
+
+    ctypedef class numpy.ufunc [object PyUFuncObject, check_size ignore]:
+        cdef:
+            int nin, nout, nargs
+            int identity
+            PyUFuncGenericFunction *functions
+            void **data
+            int ntypes
+            int check_return
+            char *name
+            char *types
+            char *doc
+            void *ptr
+            PyObject *obj
+            PyObject *userloops
+
+    cdef enum:
+        PyUFunc_Zero
+        PyUFunc_One
+        PyUFunc_None
+        # deprecated
+        UFUNC_FPE_DIVIDEBYZERO
+        UFUNC_FPE_OVERFLOW
+        UFUNC_FPE_UNDERFLOW
+        UFUNC_FPE_INVALID
+        # use these instead
+        NPY_FPE_DIVIDEBYZERO
+        NPY_FPE_OVERFLOW
+        NPY_FPE_UNDERFLOW
+        NPY_FPE_INVALID
+
+
+    object PyUFunc_FromFuncAndData(PyUFuncGenericFunction *,
+          void **, char *, int, int, int, int, char *, char *, int)
+    int PyUFunc_RegisterLoopForType(ufunc, int,
+                                    PyUFuncGenericFunction, int *, void *) except -1
+    void PyUFunc_f_f_As_d_d \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_d_d \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_f_f \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_g_g \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_F_F_As_D_D \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_F_F \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_D_D \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_G_G \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_O_O \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_ff_f_As_dd_d \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_ff_f \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_dd_d \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_gg_g \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_FF_F_As_DD_D \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_DD_D \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_FF_F \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_GG_G \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_OO_O \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_O_O_method \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_OO_O_method \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_On_Om \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_clearfperr()
+    int PyUFunc_getfperr()
+    int PyUFunc_ReplaceLoopBySignature \
+        (ufunc, PyUFuncGenericFunction, int *, PyUFuncGenericFunction *)
+    object PyUFunc_FromFuncAndDataAndSignature \
+             (PyUFuncGenericFunction *, void **, char *, int, int, int,
+              int, char *, char *, int, char *)
+
+    int _import_umath() except -1
+
+cdef inline void set_array_base(ndarray arr, object base) except *:
+    Py_INCREF(base) # important to do this before stealing the reference below!
+    PyArray_SetBaseObject(arr, base)
+
+cdef inline object get_array_base(ndarray arr):
+    base = PyArray_BASE(arr)
+    if base is NULL:
+        return None
+    return <object>base
+
+# Versions of the import_* functions which are more suitable for
+# Cython code.
+cdef inline int import_array() except -1:
+    try:
+        __pyx_import_array()
+    except Exception:
+        raise ImportError("numpy._core.multiarray failed to import")
+
+cdef inline int import_umath() except -1:
+    try:
+        _import_umath()
+    except Exception:
+        raise ImportError("numpy._core.umath failed to import")
+
+cdef inline int import_ufunc() except -1:
+    try:
+        _import_umath()
+    except Exception:
+        raise ImportError("numpy._core.umath failed to import")
+
+
+cdef inline bint is_timedelta64_object(object obj) noexcept:
+    """
+    Cython equivalent of `isinstance(obj, np.timedelta64)`
+
+    Parameters
+    ----------
+    obj : object
+
+    Returns
+    -------
+    bool
+    """
+    return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type)
+
+
+cdef inline bint is_datetime64_object(object obj) noexcept:
+    """
+    Cython equivalent of `isinstance(obj, np.datetime64)`
+
+    Parameters
+    ----------
+    obj : object
+
+    Returns
+    -------
+    bool
+    """
+    return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type)
+
+
+cdef inline npy_datetime get_datetime64_value(object obj) noexcept nogil:
+    """
+    returns the int64 value underlying scalar numpy datetime64 object
+
+    Note that to interpret this as a datetime, the corresponding unit is
+    also needed.  That can be found using `get_datetime64_unit`.
+    """
+    return (<PyDatetimeScalarObject*>obj).obval
+
+
+cdef inline npy_timedelta get_timedelta64_value(object obj) noexcept nogil:
+    """
+    returns the int64 value underlying scalar numpy timedelta64 object
+    """
+    return (<PyTimedeltaScalarObject*>obj).obval
+
+
+cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) noexcept nogil:
+    """
+    returns the unit part of the dtype for a numpy datetime64 object.
+    """
+    return <NPY_DATETIMEUNIT>(<PyDatetimeScalarObject*>obj).obmeta.base
+
+
+cdef extern from "numpy/arrayobject.h":
+
+    ctypedef struct NpyIter:
+        pass
+
+    cdef enum:
+        NPY_FAIL
+        NPY_SUCCEED
+
+    cdef enum:
+        # Track an index representing C order
+        NPY_ITER_C_INDEX
+        # Track an index representing Fortran order
+        NPY_ITER_F_INDEX
+        # Track a multi-index
+        NPY_ITER_MULTI_INDEX
+        # User code external to the iterator does the 1-dimensional innermost loop
+        NPY_ITER_EXTERNAL_LOOP
+        # Convert all the operands to a common data type
+        NPY_ITER_COMMON_DTYPE
+        # Operands may hold references, requiring API access during iteration
+        NPY_ITER_REFS_OK
+        # Zero-sized operands should be permitted, iteration checks IterSize for 0
+        NPY_ITER_ZEROSIZE_OK
+        # Permits reductions (size-0 stride with dimension size > 1)
+        NPY_ITER_REDUCE_OK
+        # Enables sub-range iteration
+        NPY_ITER_RANGED
+        # Enables buffering
+        NPY_ITER_BUFFERED
+        # When buffering is enabled, grows the inner loop if possible
+        NPY_ITER_GROWINNER
+        # Delay allocation of buffers until first Reset* call
+        NPY_ITER_DELAY_BUFALLOC
+        # When NPY_KEEPORDER is specified, disable reversing negative-stride axes
+        NPY_ITER_DONT_NEGATE_STRIDES
+        NPY_ITER_COPY_IF_OVERLAP
+        # The operand will be read from and written to
+        NPY_ITER_READWRITE
+        # The operand will only be read from
+        NPY_ITER_READONLY
+        # The operand will only be written to
+        NPY_ITER_WRITEONLY
+        # The operand's data must be in native byte order
+        NPY_ITER_NBO
+        # The operand's data must be aligned
+        NPY_ITER_ALIGNED
+        # The operand's data must be contiguous (within the inner loop)
+        NPY_ITER_CONTIG
+        # The operand may be copied to satisfy requirements
+        NPY_ITER_COPY
+        # The operand may be copied with WRITEBACKIFCOPY to satisfy requirements
+        NPY_ITER_UPDATEIFCOPY
+        # Allocate the operand if it is NULL
+        NPY_ITER_ALLOCATE
+        # If an operand is allocated, don't use any subtype
+        NPY_ITER_NO_SUBTYPE
+        # This is a virtual array slot, operand is NULL but temporary data is there
+        NPY_ITER_VIRTUAL
+        # Require that the dimension match the iterator dimensions exactly
+        NPY_ITER_NO_BROADCAST
+        # A mask is being used on this array, affects buffer -> array copy
+        NPY_ITER_WRITEMASKED
+        # This array is the mask for all WRITEMASKED operands
+        NPY_ITER_ARRAYMASK
+        # Assume iterator order data access for COPY_IF_OVERLAP
+        NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE
+
+    # construction and destruction functions
+    NpyIter* NpyIter_New(ndarray arr, npy_uint32 flags, NPY_ORDER order,
+                         NPY_CASTING casting, dtype datatype) except NULL
+    NpyIter* NpyIter_MultiNew(npy_intp nop, PyArrayObject** op, npy_uint32 flags,
+                              NPY_ORDER order, NPY_CASTING casting, npy_uint32*
+                              op_flags, PyArray_Descr** op_dtypes) except NULL
+    NpyIter* NpyIter_AdvancedNew(npy_intp nop, PyArrayObject** op,
+                                 npy_uint32 flags, NPY_ORDER order,
+                                 NPY_CASTING casting, npy_uint32* op_flags,
+                                 PyArray_Descr** op_dtypes, int oa_ndim,
+                                 int** op_axes, const npy_intp* itershape,
+                                 npy_intp buffersize) except NULL
+    NpyIter* NpyIter_Copy(NpyIter* it) except NULL
+    int NpyIter_RemoveAxis(NpyIter* it, int axis) except NPY_FAIL
+    int NpyIter_RemoveMultiIndex(NpyIter* it) except NPY_FAIL
+    int NpyIter_EnableExternalLoop(NpyIter* it) except NPY_FAIL
+    int NpyIter_Deallocate(NpyIter* it) except NPY_FAIL
+    int NpyIter_Reset(NpyIter* it, char** errmsg) except NPY_FAIL
+    int NpyIter_ResetToIterIndexRange(NpyIter* it, npy_intp istart,
+                                      npy_intp iend, char** errmsg) except NPY_FAIL
+    int NpyIter_ResetBasePointers(NpyIter* it, char** baseptrs, char** errmsg) except NPY_FAIL
+    int NpyIter_GotoMultiIndex(NpyIter* it, const npy_intp* multi_index) except NPY_FAIL
+    int NpyIter_GotoIndex(NpyIter* it, npy_intp index) except NPY_FAIL
+    npy_intp NpyIter_GetIterSize(NpyIter* it) nogil
+    npy_intp NpyIter_GetIterIndex(NpyIter* it) nogil
+    void NpyIter_GetIterIndexRange(NpyIter* it, npy_intp* istart,
+                                   npy_intp* iend) nogil
+    int NpyIter_GotoIterIndex(NpyIter* it, npy_intp iterindex) except NPY_FAIL
+    npy_bool NpyIter_HasDelayedBufAlloc(NpyIter* it) nogil
+    npy_bool NpyIter_HasExternalLoop(NpyIter* it) nogil
+    npy_bool NpyIter_HasMultiIndex(NpyIter* it) nogil
+    npy_bool NpyIter_HasIndex(NpyIter* it) nogil
+    npy_bool NpyIter_RequiresBuffering(NpyIter* it) nogil
+    npy_bool NpyIter_IsBuffered(NpyIter* it) nogil
+    npy_bool NpyIter_IsGrowInner(NpyIter* it) nogil
+    npy_intp NpyIter_GetBufferSize(NpyIter* it) nogil
+    int NpyIter_GetNDim(NpyIter* it) nogil
+    int NpyIter_GetNOp(NpyIter* it) nogil
+    npy_intp* NpyIter_GetAxisStrideArray(NpyIter* it, int axis) except NULL
+    int NpyIter_GetShape(NpyIter* it, npy_intp* outshape) nogil
+    PyArray_Descr** NpyIter_GetDescrArray(NpyIter* it)
+    PyArrayObject** NpyIter_GetOperandArray(NpyIter* it)
+    ndarray NpyIter_GetIterView(NpyIter* it, npy_intp i)
+    void NpyIter_GetReadFlags(NpyIter* it, char* outreadflags)
+    void NpyIter_GetWriteFlags(NpyIter* it, char* outwriteflags)
+    int NpyIter_CreateCompatibleStrides(NpyIter* it, npy_intp itemsize,
+                                        npy_intp* outstrides) except NPY_FAIL
+    npy_bool NpyIter_IsFirstVisit(NpyIter* it, int iop) nogil
+    # functions for iterating an NpyIter object
+    #
+    # These don't match the definition in the C API because Cython can't wrap
+    # function pointers that return functions.
+    NpyIter_IterNextFunc NpyIter_GetIterNext(NpyIter* it, char** errmsg) except NULL
+    NpyIter_GetMultiIndexFunc NpyIter_GetGetMultiIndex(NpyIter* it,
+                                                       char** errmsg) except NULL
+    char** NpyIter_GetDataPtrArray(NpyIter* it) nogil
+    char** NpyIter_GetInitialDataPtrArray(NpyIter* it) nogil
+    npy_intp* NpyIter_GetIndexPtr(NpyIter* it)
+    npy_intp* NpyIter_GetInnerStrideArray(NpyIter* it) nogil
+    npy_intp* NpyIter_GetInnerLoopSizePtr(NpyIter* it) nogil
+    void NpyIter_GetInnerFixedStrideArray(NpyIter* it, npy_intp* outstrides) nogil
+    npy_bool NpyIter_IterationNeedsAPI(NpyIter* it) nogil
+    void NpyIter_DebugPrint(NpyIter* it)
+
+# NpyString API
+cdef extern from "numpy/ndarraytypes.h":
+    ctypedef struct npy_string_allocator:
+        pass
+
+    ctypedef struct npy_packed_static_string:
+        pass
+
+    ctypedef struct npy_static_string:
+        size_t size
+        const char *buf
+
+    ctypedef struct PyArray_StringDTypeObject:
+        PyArray_Descr base
+        PyObject *na_object
+        char coerce
+        char has_nan_na
+        char has_string_na
+        char array_owned
+        npy_static_string default_string
+        npy_static_string na_name
+        npy_string_allocator *allocator
+
+cdef extern from "numpy/arrayobject.h":
+    npy_string_allocator *NpyString_acquire_allocator(const PyArray_StringDTypeObject *descr)
+    void NpyString_acquire_allocators(size_t n_descriptors, PyArray_Descr *const descrs[], npy_string_allocator *allocators[])
+    void NpyString_release_allocator(npy_string_allocator *allocator)
+    void NpyString_release_allocators(size_t length, npy_string_allocator *allocators[])
+    int NpyString_load(npy_string_allocator *allocator, const npy_packed_static_string *packed_string, npy_static_string *unpacked_string)
+    int NpyString_pack_null(npy_string_allocator *allocator, npy_packed_static_string *packed_string)
+    int NpyString_pack(npy_string_allocator *allocator, npy_packed_static_string *packed_string, const char *buf, size_t size)

.venv_haddock/lib/python3.12/site-packages/numpy/__init__.pxd

@@ -0,0 +1,1155 @@
+# NumPy static imports for Cython < 3.0
+#
+# If any of the PyArray_* functions are called, import_array must be
+# called first.
+#
+# Author: Dag Sverre Seljebotn
+#
+
+DEF _buffer_format_string_len = 255
+
+cimport cpython.buffer as pybuf
+from cpython.ref cimport Py_INCREF
+from cpython.mem cimport PyObject_Malloc, PyObject_Free
+from cpython.object cimport PyObject, PyTypeObject
+from cpython.buffer cimport PyObject_GetBuffer
+from cpython.type cimport type
+cimport libc.stdio as stdio
+
+
+cdef extern from *:
+    # Leave a marker that the NumPy declarations came from NumPy itself and not from Cython.
+    # See https://github.com/cython/cython/issues/3573
+    """
+    /* Using NumPy API declarations from "numpy/__init__.pxd" */
+    """
+
+
+cdef extern from "Python.h":
+    ctypedef int Py_intptr_t
+    bint PyObject_TypeCheck(object obj, PyTypeObject* type)
+
+cdef extern from "numpy/arrayobject.h":
+    # It would be nice to use size_t and ssize_t, but ssize_t has special
+    # implicit conversion rules, so just use "long".
+    # Note: The actual type only matters for Cython promotion, so long
+    #       is closer than int, but could lead to incorrect promotion.
+    #       (Not to worrying, and always the status-quo.)
+    ctypedef signed long npy_intp
+    ctypedef unsigned long npy_uintp
+
+    ctypedef unsigned char      npy_bool
+
+    ctypedef signed char      npy_byte
+    ctypedef signed short     npy_short
+    ctypedef signed int       npy_int
+    ctypedef signed long      npy_long
+    ctypedef signed long long npy_longlong
+
+    ctypedef unsigned char      npy_ubyte
+    ctypedef unsigned short     npy_ushort
+    ctypedef unsigned int       npy_uint
+    ctypedef unsigned long      npy_ulong
+    ctypedef unsigned long long npy_ulonglong
+
+    ctypedef float        npy_float
+    ctypedef double       npy_double
+    ctypedef long double  npy_longdouble
+
+    ctypedef signed char        npy_int8
+    ctypedef signed short       npy_int16
+    ctypedef signed int         npy_int32
+    ctypedef signed long long   npy_int64
+
+    ctypedef unsigned char      npy_uint8
+    ctypedef unsigned short     npy_uint16
+    ctypedef unsigned int       npy_uint32
+    ctypedef unsigned long long npy_uint64
+
+    ctypedef float        npy_float32
+    ctypedef double       npy_float64
+    ctypedef long double  npy_float80
+    ctypedef long double  npy_float96
+    ctypedef long double  npy_float128
+
+    ctypedef struct npy_cfloat:
+        pass
+
+    ctypedef struct npy_cdouble:
+        pass
+
+    ctypedef struct npy_clongdouble:
+        pass
+
+    ctypedef struct npy_complex64:
+        pass
+
+    ctypedef struct npy_complex128:
+        pass
+
+    ctypedef struct npy_complex160:
+        pass
+
+    ctypedef struct npy_complex192:
+        pass
+
+    ctypedef struct npy_complex256:
+        pass
+
+    ctypedef struct PyArray_Dims:
+        npy_intp *ptr
+        int len
+
+
+    cdef enum NPY_TYPES:
+        NPY_BOOL
+        NPY_BYTE
+        NPY_UBYTE
+        NPY_SHORT
+        NPY_USHORT
+        NPY_INT
+        NPY_UINT
+        NPY_LONG
+        NPY_ULONG
+        NPY_LONGLONG
+        NPY_ULONGLONG
+        NPY_FLOAT
+        NPY_DOUBLE
+        NPY_LONGDOUBLE
+        NPY_CFLOAT
+        NPY_CDOUBLE
+        NPY_CLONGDOUBLE
+        NPY_OBJECT
+        NPY_STRING
+        NPY_UNICODE
+        NPY_VSTRING
+        NPY_VOID
+        NPY_DATETIME
+        NPY_TIMEDELTA
+        NPY_NTYPES_LEGACY
+        NPY_NOTYPE
+
+        NPY_INT8
+        NPY_INT16
+        NPY_INT32
+        NPY_INT64
+        NPY_UINT8
+        NPY_UINT16
+        NPY_UINT32
+        NPY_UINT64
+        NPY_FLOAT16
+        NPY_FLOAT32
+        NPY_FLOAT64
+        NPY_FLOAT80
+        NPY_FLOAT96
+        NPY_FLOAT128
+        NPY_COMPLEX64
+        NPY_COMPLEX128
+        NPY_COMPLEX160
+        NPY_COMPLEX192
+        NPY_COMPLEX256
+
+        NPY_INTP
+        NPY_UINTP
+        NPY_DEFAULT_INT  # Not a compile time constant (normally)!
+
+    ctypedef enum NPY_ORDER:
+        NPY_ANYORDER
+        NPY_CORDER
+        NPY_FORTRANORDER
+        NPY_KEEPORDER
+
+    ctypedef enum NPY_CASTING:
+        NPY_NO_CASTING
+        NPY_EQUIV_CASTING
+        NPY_SAFE_CASTING
+        NPY_SAME_KIND_CASTING
+        NPY_UNSAFE_CASTING
+        NPY_SAME_VALUE_CASTING
+
+    ctypedef enum NPY_CLIPMODE:
+        NPY_CLIP
+        NPY_WRAP
+        NPY_RAISE
+
+    ctypedef enum NPY_SCALARKIND:
+        NPY_NOSCALAR,
+        NPY_BOOL_SCALAR,
+        NPY_INTPOS_SCALAR,
+        NPY_INTNEG_SCALAR,
+        NPY_FLOAT_SCALAR,
+        NPY_COMPLEX_SCALAR,
+        NPY_OBJECT_SCALAR
+
+    ctypedef enum NPY_SORTKIND:
+        NPY_QUICKSORT
+        NPY_HEAPSORT
+        NPY_MERGESORT
+
+    ctypedef enum NPY_SEARCHSIDE:
+        NPY_SEARCHLEFT
+        NPY_SEARCHRIGHT
+
+    enum:
+        NPY_ARRAY_C_CONTIGUOUS
+        NPY_ARRAY_F_CONTIGUOUS
+        NPY_ARRAY_OWNDATA
+        NPY_ARRAY_FORCECAST
+        NPY_ARRAY_ENSURECOPY
+        NPY_ARRAY_ENSUREARRAY
+        NPY_ARRAY_ELEMENTSTRIDES
+        NPY_ARRAY_ALIGNED
+        NPY_ARRAY_NOTSWAPPED
+        NPY_ARRAY_WRITEABLE
+        NPY_ARRAY_WRITEBACKIFCOPY
+
+        NPY_ARRAY_BEHAVED
+        NPY_ARRAY_BEHAVED_NS
+        NPY_ARRAY_CARRAY
+        NPY_ARRAY_CARRAY_RO
+        NPY_ARRAY_FARRAY
+        NPY_ARRAY_FARRAY_RO
+        NPY_ARRAY_DEFAULT
+
+        NPY_ARRAY_IN_ARRAY
+        NPY_ARRAY_OUT_ARRAY
+        NPY_ARRAY_INOUT_ARRAY
+        NPY_ARRAY_IN_FARRAY
+        NPY_ARRAY_OUT_FARRAY
+        NPY_ARRAY_INOUT_FARRAY
+
+        NPY_ARRAY_UPDATE_ALL
+
+    cdef enum:
+        NPY_MAXDIMS  # 64 on NumPy 2.x and 32 on NumPy 1.x
+        NPY_RAVEL_AXIS  # Used for functions like PyArray_Mean
+
+    ctypedef void (*PyArray_VectorUnaryFunc)(void *, void *, npy_intp, void *,  void *)
+
+    ctypedef struct PyArray_ArrayDescr:
+        # shape is a tuple, but Cython doesn't support "tuple shape"
+        # inside a non-PyObject declaration, so we have to declare it
+        # as just a PyObject*.
+        PyObject* shape
+
+    ctypedef struct PyArray_Descr:
+        pass
+
+    ctypedef class numpy.dtype [object PyArray_Descr, check_size ignore]:
+        # Use PyDataType_* macros when possible, however there are no macros
+        # for accessing some of the fields, so some are defined.
+        cdef PyTypeObject* typeobj
+        cdef char kind
+        cdef char type
+        # Numpy sometimes mutates this without warning (e.g. it'll
+        # sometimes change "|" to "<" in shared dtype objects on
+        # little-endian machines). If this matters to you, use
+        # PyArray_IsNativeByteOrder(dtype.byteorder) instead of
+        # directly accessing this field.
+        cdef char byteorder
+        # Flags are not directly accessible on Cython <3. Use PyDataType_FLAGS.
+        # cdef char flags
+        cdef int type_num
+        # itemsize/elsize, alignment, fields, names, and subarray must
+        # use the `PyDataType_*` accessor macros. With Cython 3 you can
+        # still use getter attributes `dtype.itemsize`
+
+    ctypedef class numpy.flatiter [object PyArrayIterObject, check_size ignore]:
+        # Use through macros
+        pass
+
+    ctypedef class numpy.broadcast [object PyArrayMultiIterObject, check_size ignore]:
+        cdef int numiter
+        cdef npy_intp size, index
+        cdef int nd
+        cdef npy_intp *dimensions
+        cdef void **iters
+
+    ctypedef struct PyArrayObject:
+        # For use in situations where ndarray can't replace PyArrayObject*,
+        # like PyArrayObject**.
+        pass
+
+    ctypedef class numpy.ndarray [object PyArrayObject, check_size ignore]:
+        cdef __cythonbufferdefaults__ = {"mode": "strided"}
+
+        cdef:
+            # Only taking a few of the most commonly used and stable fields.
+            # One should use PyArray_* macros instead to access the C fields.
+            char *data
+            int ndim "nd"
+            npy_intp *shape "dimensions"
+            npy_intp *strides
+            dtype descr  # deprecated since NumPy 1.7 !
+            PyObject* base #  NOT PUBLIC, DO NOT USE !
+
+
+    int _import_array() except -1
+    # A second definition so _import_array isn't marked as used when we use it here.
+    # Do not use - subject to change any time.
+    int __pyx_import_array "_import_array"() except -1
+
+    #
+    # Macros from ndarrayobject.h
+    #
+    bint PyArray_CHKFLAGS(ndarray m, int flags) nogil
+    bint PyArray_IS_C_CONTIGUOUS(ndarray arr) nogil
+    bint PyArray_IS_F_CONTIGUOUS(ndarray arr) nogil
+    bint PyArray_ISCONTIGUOUS(ndarray m) nogil
+    bint PyArray_ISWRITEABLE(ndarray m) nogil
+    bint PyArray_ISALIGNED(ndarray m) nogil
+
+    int PyArray_NDIM(ndarray) nogil
+    bint PyArray_ISONESEGMENT(ndarray) nogil
+    bint PyArray_ISFORTRAN(ndarray) nogil
+    int PyArray_FORTRANIF(ndarray) nogil
+
+    void* PyArray_DATA(ndarray) nogil
+    char* PyArray_BYTES(ndarray) nogil
+
+    npy_intp* PyArray_DIMS(ndarray) nogil
+    npy_intp* PyArray_STRIDES(ndarray) nogil
+    npy_intp PyArray_DIM(ndarray, size_t) nogil
+    npy_intp PyArray_STRIDE(ndarray, size_t) nogil
+
+    PyObject *PyArray_BASE(ndarray) nogil  # returns borrowed reference!
+    PyArray_Descr *PyArray_DESCR(ndarray) nogil  # returns borrowed reference to dtype!
+    PyArray_Descr *PyArray_DTYPE(ndarray) nogil  # returns borrowed reference to dtype! NP 1.7+ alias for descr.
+    int PyArray_FLAGS(ndarray) nogil
+    void PyArray_CLEARFLAGS(ndarray, int flags) nogil  # Added in NumPy 1.7
+    void PyArray_ENABLEFLAGS(ndarray, int flags) nogil  # Added in NumPy 1.7
+    npy_intp PyArray_ITEMSIZE(ndarray) nogil
+    int PyArray_TYPE(ndarray arr) nogil
+
+    object PyArray_GETITEM(ndarray arr, void *itemptr)
+    int PyArray_SETITEM(ndarray arr, void *itemptr, object obj) except -1
+
+    bint PyTypeNum_ISBOOL(int) nogil
+    bint PyTypeNum_ISUNSIGNED(int) nogil
+    bint PyTypeNum_ISSIGNED(int) nogil
+    bint PyTypeNum_ISINTEGER(int) nogil
+    bint PyTypeNum_ISFLOAT(int) nogil
+    bint PyTypeNum_ISNUMBER(int) nogil
+    bint PyTypeNum_ISSTRING(int) nogil
+    bint PyTypeNum_ISCOMPLEX(int) nogil
+    bint PyTypeNum_ISFLEXIBLE(int) nogil
+    bint PyTypeNum_ISUSERDEF(int) nogil
+    bint PyTypeNum_ISEXTENDED(int) nogil
+    bint PyTypeNum_ISOBJECT(int) nogil
+
+    npy_intp PyDataType_ELSIZE(dtype) nogil
+    npy_intp PyDataType_ALIGNMENT(dtype) nogil
+    PyObject* PyDataType_METADATA(dtype) nogil
+    PyArray_ArrayDescr* PyDataType_SUBARRAY(dtype) nogil
+    PyObject* PyDataType_NAMES(dtype) nogil
+    PyObject* PyDataType_FIELDS(dtype) nogil
+
+    bint PyDataType_ISBOOL(dtype) nogil
+    bint PyDataType_ISUNSIGNED(dtype) nogil
+    bint PyDataType_ISSIGNED(dtype) nogil
+    bint PyDataType_ISINTEGER(dtype) nogil
+    bint PyDataType_ISFLOAT(dtype) nogil
+    bint PyDataType_ISNUMBER(dtype) nogil
+    bint PyDataType_ISSTRING(dtype) nogil
+    bint PyDataType_ISCOMPLEX(dtype) nogil
+    bint PyDataType_ISFLEXIBLE(dtype) nogil
+    bint PyDataType_ISUSERDEF(dtype) nogil
+    bint PyDataType_ISEXTENDED(dtype) nogil
+    bint PyDataType_ISOBJECT(dtype) nogil
+    bint PyDataType_HASFIELDS(dtype) nogil
+    bint PyDataType_HASSUBARRAY(dtype) nogil
+    npy_uint64 PyDataType_FLAGS(dtype) nogil
+
+    bint PyArray_ISBOOL(ndarray) nogil
+    bint PyArray_ISUNSIGNED(ndarray) nogil
+    bint PyArray_ISSIGNED(ndarray) nogil
+    bint PyArray_ISINTEGER(ndarray) nogil
+    bint PyArray_ISFLOAT(ndarray) nogil
+    bint PyArray_ISNUMBER(ndarray) nogil
+    bint PyArray_ISSTRING(ndarray) nogil
+    bint PyArray_ISCOMPLEX(ndarray) nogil
+    bint PyArray_ISFLEXIBLE(ndarray) nogil
+    bint PyArray_ISUSERDEF(ndarray) nogil
+    bint PyArray_ISEXTENDED(ndarray) nogil
+    bint PyArray_ISOBJECT(ndarray) nogil
+    bint PyArray_HASFIELDS(ndarray) nogil
+
+    bint PyArray_ISVARIABLE(ndarray) nogil
+
+    bint PyArray_SAFEALIGNEDCOPY(ndarray) nogil
+    bint PyArray_ISNBO(char) nogil              # works on ndarray.byteorder
+    bint PyArray_IsNativeByteOrder(char) nogil # works on ndarray.byteorder
+    bint PyArray_ISNOTSWAPPED(ndarray) nogil
+    bint PyArray_ISBYTESWAPPED(ndarray) nogil
+
+    bint PyArray_FLAGSWAP(ndarray, int) nogil
+
+    bint PyArray_ISCARRAY(ndarray) nogil
+    bint PyArray_ISCARRAY_RO(ndarray) nogil
+    bint PyArray_ISFARRAY(ndarray) nogil
+    bint PyArray_ISFARRAY_RO(ndarray) nogil
+    bint PyArray_ISBEHAVED(ndarray) nogil
+    bint PyArray_ISBEHAVED_RO(ndarray) nogil
+
+
+    bint PyDataType_ISNOTSWAPPED(dtype) nogil
+    bint PyDataType_ISBYTESWAPPED(dtype) nogil
+
+    bint PyArray_DescrCheck(object)
+
+    bint PyArray_Check(object)
+    bint PyArray_CheckExact(object)
+
+    # Cannot be supported due to out arg:
+    # bint PyArray_HasArrayInterfaceType(object, dtype, object, object&)
+    # bint PyArray_HasArrayInterface(op, out)
+
+
+    bint PyArray_IsZeroDim(object)
+    # Cannot be supported due to ## ## in macro:
+    # bint PyArray_IsScalar(object, verbatim work)
+    bint PyArray_CheckScalar(object)
+    bint PyArray_IsPythonNumber(object)
+    bint PyArray_IsPythonScalar(object)
+    bint PyArray_IsAnyScalar(object)
+    bint PyArray_CheckAnyScalar(object)
+
+    ndarray PyArray_GETCONTIGUOUS(ndarray)
+    bint PyArray_SAMESHAPE(ndarray, ndarray) nogil
+    npy_intp PyArray_SIZE(ndarray) nogil
+    npy_intp PyArray_NBYTES(ndarray) nogil
+
+    object PyArray_FROM_O(object)
+    object PyArray_FROM_OF(object m, int flags)
+    object PyArray_FROM_OT(object m, int type)
+    object PyArray_FROM_OTF(object m, int type, int flags)
+    object PyArray_FROMANY(object m, int type, int min, int max, int flags)
+    object PyArray_ZEROS(int nd, npy_intp* dims, int type, int fortran)
+    object PyArray_EMPTY(int nd, npy_intp* dims, int type, int fortran)
+    void PyArray_FILLWBYTE(ndarray, int val)
+    object PyArray_ContiguousFromAny(op, int, int min_depth, int max_depth)
+    unsigned char PyArray_EquivArrTypes(ndarray a1, ndarray a2)
+    bint PyArray_EquivByteorders(int b1, int b2) nogil
+    object PyArray_SimpleNew(int nd, npy_intp* dims, int typenum)
+    object PyArray_SimpleNewFromData(int nd, npy_intp* dims, int typenum, void* data)
+    #object PyArray_SimpleNewFromDescr(int nd, npy_intp* dims, dtype descr)
+    object PyArray_ToScalar(void* data, ndarray arr)
+
+    void* PyArray_GETPTR1(ndarray m, npy_intp i) nogil
+    void* PyArray_GETPTR2(ndarray m, npy_intp i, npy_intp j) nogil
+    void* PyArray_GETPTR3(ndarray m, npy_intp i, npy_intp j, npy_intp k) nogil
+    void* PyArray_GETPTR4(ndarray m, npy_intp i, npy_intp j, npy_intp k, npy_intp l) nogil
+
+    # Cannot be supported due to out arg
+    # void PyArray_DESCR_REPLACE(descr)
+
+
+    object PyArray_Copy(ndarray)
+    object PyArray_FromObject(object op, int type, int min_depth, int max_depth)
+    object PyArray_ContiguousFromObject(object op, int type, int min_depth, int max_depth)
+    object PyArray_CopyFromObject(object op, int type, int min_depth, int max_depth)
+
+    object PyArray_Cast(ndarray mp, int type_num)
+    object PyArray_Take(ndarray ap, object items, int axis)
+    object PyArray_Put(ndarray ap, object items, object values)
+
+    void PyArray_ITER_RESET(flatiter it) nogil
+    void PyArray_ITER_NEXT(flatiter it) nogil
+    void PyArray_ITER_GOTO(flatiter it, npy_intp* destination) nogil
+    void PyArray_ITER_GOTO1D(flatiter it, npy_intp ind) nogil
+    void* PyArray_ITER_DATA(flatiter it) nogil
+    bint PyArray_ITER_NOTDONE(flatiter it) nogil
+
+    void PyArray_MultiIter_RESET(broadcast multi) nogil
+    void PyArray_MultiIter_NEXT(broadcast multi) nogil
+    void PyArray_MultiIter_GOTO(broadcast multi, npy_intp dest) nogil
+    void PyArray_MultiIter_GOTO1D(broadcast multi, npy_intp ind) nogil
+    void* PyArray_MultiIter_DATA(broadcast multi, npy_intp i) nogil
+    void PyArray_MultiIter_NEXTi(broadcast multi, npy_intp i) nogil
+    bint PyArray_MultiIter_NOTDONE(broadcast multi) nogil
+    npy_intp PyArray_MultiIter_SIZE(broadcast multi) nogil
+    int PyArray_MultiIter_NDIM(broadcast multi) nogil
+    npy_intp PyArray_MultiIter_INDEX(broadcast multi) nogil
+    int PyArray_MultiIter_NUMITER(broadcast multi) nogil
+    npy_intp* PyArray_MultiIter_DIMS(broadcast multi) nogil
+    void** PyArray_MultiIter_ITERS(broadcast multi) nogil
+
+    # Functions from __multiarray_api.h
+
+    # Functions taking dtype and returning object/ndarray are disabled
+    # for now as they steal dtype references. I'm conservative and disable
+    # more than is probably needed until it can be checked further.
+    int PyArray_INCREF (ndarray) except *  # uses PyArray_Item_INCREF...
+    int PyArray_XDECREF (ndarray) except *  # uses PyArray_Item_DECREF...
+    dtype PyArray_DescrFromType (int)
+    object PyArray_TypeObjectFromType (int)
+    char * PyArray_Zero (ndarray)
+    char * PyArray_One (ndarray)
+    #object PyArray_CastToType (ndarray, dtype, int)
+    int PyArray_CanCastSafely (int, int)  # writes errors
+    npy_bool PyArray_CanCastTo (dtype, dtype)  # writes errors
+    int PyArray_ObjectType (object, int) except 0
+    dtype PyArray_DescrFromObject (object, dtype)
+    #ndarray* PyArray_ConvertToCommonType (object, int *)
+    dtype PyArray_DescrFromScalar (object)
+    dtype PyArray_DescrFromTypeObject (object)
+    npy_intp PyArray_Size (object)
+    #object PyArray_Scalar (void *, dtype, object)
+    #object PyArray_FromScalar (object, dtype)
+    void PyArray_ScalarAsCtype (object, void *)
+    #int PyArray_CastScalarToCtype (object, void *, dtype)
+    #int PyArray_CastScalarDirect (object, dtype, void *, int)
+    #PyArray_VectorUnaryFunc * PyArray_GetCastFunc (dtype, int)
+    #object PyArray_FromAny (object, dtype, int, int, int, object)
+    object PyArray_EnsureArray (object)
+    object PyArray_EnsureAnyArray (object)
+    #object PyArray_FromFile (stdio.FILE *, dtype, npy_intp, char *)
+    #object PyArray_FromString (char *, npy_intp, dtype, npy_intp, char *)
+    #object PyArray_FromBuffer (object, dtype, npy_intp, npy_intp)
+    #object PyArray_FromIter (object, dtype, npy_intp)
+    object PyArray_Return (ndarray)
+    #object PyArray_GetField (ndarray, dtype, int)
+    #int PyArray_SetField (ndarray, dtype, int, object) except -1
+    object PyArray_Byteswap (ndarray, npy_bool)
+    object PyArray_Resize (ndarray, PyArray_Dims *, int, NPY_ORDER)
+    int PyArray_CopyInto (ndarray, ndarray) except -1
+    int PyArray_CopyAnyInto (ndarray, ndarray) except -1
+    int PyArray_CopyObject (ndarray, object) except -1
+    object PyArray_NewCopy (ndarray, NPY_ORDER)
+    object PyArray_ToList (ndarray)
+    object PyArray_ToString (ndarray, NPY_ORDER)
+    int PyArray_ToFile (ndarray, stdio.FILE *, char *, char *) except -1
+    int PyArray_Dump (object, object, int) except -1
+    object PyArray_Dumps (object, int)
+    int PyArray_ValidType (int)  # Cannot error
+    void PyArray_UpdateFlags (ndarray, int)
+    object PyArray_New (type, int, npy_intp *, int, npy_intp *, void *, int, int, object)
+    #object PyArray_NewFromDescr (type, dtype, int, npy_intp *, npy_intp *, void *, int, object)
+    #dtype PyArray_DescrNew (dtype)
+    dtype PyArray_DescrNewFromType (int)
+    double PyArray_GetPriority (object, double)  # clears errors as of 1.25
+    object PyArray_IterNew (object)
+    object PyArray_MultiIterNew (int, ...)
+
+    int PyArray_PyIntAsInt (object) except? -1
+    npy_intp PyArray_PyIntAsIntp (object)
+    int PyArray_Broadcast (broadcast) except -1
+    int PyArray_FillWithScalar (ndarray, object) except -1
+    npy_bool PyArray_CheckStrides (int, int, npy_intp, npy_intp, npy_intp *, npy_intp *)
+    dtype PyArray_DescrNewByteorder (dtype, char)
+    object PyArray_IterAllButAxis (object, int *)
+    #object PyArray_CheckFromAny (object, dtype, int, int, int, object)
+    #object PyArray_FromArray (ndarray, dtype, int)
+    object PyArray_FromInterface (object)
+    object PyArray_FromStructInterface (object)
+    #object PyArray_FromArrayAttr (object, dtype, object)
+    #NPY_SCALARKIND PyArray_ScalarKind (int, ndarray*)
+    int PyArray_CanCoerceScalar (int, int, NPY_SCALARKIND)
+    npy_bool PyArray_CanCastScalar (type, type)
+    int PyArray_RemoveSmallest (broadcast) except -1
+    int PyArray_ElementStrides (object)
+    void PyArray_Item_INCREF (char *, dtype) except *
+    void PyArray_Item_XDECREF (char *, dtype) except *
+    object PyArray_Transpose (ndarray, PyArray_Dims *)
+    object PyArray_TakeFrom (ndarray, object, int, ndarray, NPY_CLIPMODE)
+    object PyArray_PutTo (ndarray, object, object, NPY_CLIPMODE)
+    object PyArray_PutMask (ndarray, object, object)
+    object PyArray_Repeat (ndarray, object, int)
+    object PyArray_Choose (ndarray, object, ndarray, NPY_CLIPMODE)
+    int PyArray_Sort (ndarray, int, NPY_SORTKIND) except -1
+    object PyArray_ArgSort (ndarray, int, NPY_SORTKIND)
+    object PyArray_SearchSorted (ndarray, object, NPY_SEARCHSIDE, PyObject *)
+    object PyArray_ArgMax (ndarray, int, ndarray)
+    object PyArray_ArgMin (ndarray, int, ndarray)
+    object PyArray_Reshape (ndarray, object)
+    object PyArray_Newshape (ndarray, PyArray_Dims *, NPY_ORDER)
+    object PyArray_Squeeze (ndarray)
+    #object PyArray_View (ndarray, dtype, type)
+    object PyArray_SwapAxes (ndarray, int, int)
+    object PyArray_Max (ndarray, int, ndarray)
+    object PyArray_Min (ndarray, int, ndarray)
+    object PyArray_Ptp (ndarray, int, ndarray)
+    object PyArray_Mean (ndarray, int, int, ndarray)
+    object PyArray_Trace (ndarray, int, int, int, int, ndarray)
+    object PyArray_Diagonal (ndarray, int, int, int)
+    object PyArray_Clip (ndarray, object, object, ndarray)
+    object PyArray_Conjugate (ndarray, ndarray)
+    object PyArray_Nonzero (ndarray)
+    object PyArray_Std (ndarray, int, int, ndarray, int)
+    object PyArray_Sum (ndarray, int, int, ndarray)
+    object PyArray_CumSum (ndarray, int, int, ndarray)
+    object PyArray_Prod (ndarray, int, int, ndarray)
+    object PyArray_CumProd (ndarray, int, int, ndarray)
+    object PyArray_All (ndarray, int, ndarray)
+    object PyArray_Any (ndarray, int, ndarray)
+    object PyArray_Compress (ndarray, object, int, ndarray)
+    object PyArray_Flatten (ndarray, NPY_ORDER)
+    object PyArray_Ravel (ndarray, NPY_ORDER)
+    npy_intp PyArray_MultiplyList (npy_intp *, int)
+    int PyArray_MultiplyIntList (int *, int)
+    void * PyArray_GetPtr (ndarray, npy_intp*)
+    int PyArray_CompareLists (npy_intp *, npy_intp *, int)
+    #int PyArray_AsCArray (object*, void *, npy_intp *, int, dtype)
+    int PyArray_Free (object, void *)
+    #int PyArray_Converter (object, object*)
+    int PyArray_IntpFromSequence (object, npy_intp *, int) except -1
+    object PyArray_Concatenate (object, int)
+    object PyArray_InnerProduct (object, object)
+    object PyArray_MatrixProduct (object, object)
+    object PyArray_Correlate (object, object, int)
+    #int PyArray_DescrConverter (object, dtype*) except 0
+    #int PyArray_DescrConverter2 (object, dtype*) except 0
+    int PyArray_IntpConverter (object, PyArray_Dims *) except 0
+    #int PyArray_BufferConverter (object, chunk) except 0
+    int PyArray_AxisConverter (object, int *) except 0
+    int PyArray_BoolConverter (object, npy_bool *) except 0
+    int PyArray_ByteorderConverter (object, char *) except 0
+    int PyArray_OrderConverter (object, NPY_ORDER *) except 0
+    unsigned char PyArray_EquivTypes (dtype, dtype)  # clears errors
+    #object PyArray_Zeros (int, npy_intp *, dtype, int)
+    #object PyArray_Empty (int, npy_intp *, dtype, int)
+    object PyArray_Where (object, object, object)
+    object PyArray_Arange (double, double, double, int)
+    #object PyArray_ArangeObj (object, object, object, dtype)
+    int PyArray_SortkindConverter (object, NPY_SORTKIND *) except 0
+    object PyArray_LexSort (object, int)
+    object PyArray_Round (ndarray, int, ndarray)
+    unsigned char PyArray_EquivTypenums (int, int)
+    int PyArray_RegisterDataType (dtype) except -1
+    int PyArray_RegisterCastFunc (dtype, int, PyArray_VectorUnaryFunc *) except -1
+    int PyArray_RegisterCanCast (dtype, int, NPY_SCALARKIND) except -1
+    #void PyArray_InitArrFuncs (PyArray_ArrFuncs *)
+    object PyArray_IntTupleFromIntp (int, npy_intp *)
+    int PyArray_ClipmodeConverter (object, NPY_CLIPMODE *) except 0
+    #int PyArray_OutputConverter (object, ndarray*) except 0
+    object PyArray_BroadcastToShape (object, npy_intp *, int)
+    #int PyArray_DescrAlignConverter (object, dtype*) except 0
+    #int PyArray_DescrAlignConverter2 (object, dtype*) except 0
+    int PyArray_SearchsideConverter (object, void *) except 0
+    object PyArray_CheckAxis (ndarray, int *, int)
+    npy_intp PyArray_OverflowMultiplyList (npy_intp *, int)
+    int PyArray_SetBaseObject(ndarray, base) except -1 # NOTE: steals a reference to base! Use "set_array_base()" instead.
+
+    # The memory handler functions require the NumPy 1.22 API
+    # and may require defining NPY_TARGET_VERSION
+    ctypedef struct PyDataMemAllocator:
+        void *ctx
+        void* (*malloc) (void *ctx, size_t size)
+        void* (*calloc) (void *ctx, size_t nelem, size_t elsize)
+        void* (*realloc) (void *ctx, void *ptr, size_t new_size)
+        void (*free) (void *ctx, void *ptr, size_t size)
+
+    ctypedef struct PyDataMem_Handler:
+        char* name
+        npy_uint8 version
+        PyDataMemAllocator allocator
+
+    object PyDataMem_SetHandler(object handler)
+    object PyDataMem_GetHandler()
+
+    # additional datetime related functions are defined below
+
+
+# Typedefs that matches the runtime dtype objects in
+# the numpy module.
+
+# The ones that are commented out needs an IFDEF function
+# in Cython to enable them only on the right systems.
+
+ctypedef npy_int8       int8_t
+ctypedef npy_int16      int16_t
+ctypedef npy_int32      int32_t
+ctypedef npy_int64      int64_t
+
+ctypedef npy_uint8      uint8_t
+ctypedef npy_uint16     uint16_t
+ctypedef npy_uint32     uint32_t
+ctypedef npy_uint64     uint64_t
+
+ctypedef npy_float32    float32_t
+ctypedef npy_float64    float64_t
+#ctypedef npy_float80    float80_t
+#ctypedef npy_float128   float128_t
+
+ctypedef float complex  complex64_t
+ctypedef double complex complex128_t
+
+ctypedef npy_longlong   longlong_t
+ctypedef npy_ulonglong  ulonglong_t
+
+ctypedef npy_intp       intp_t
+ctypedef npy_uintp      uintp_t
+
+ctypedef npy_double     float_t
+ctypedef npy_double     double_t
+ctypedef npy_longdouble longdouble_t
+
+ctypedef float complex       cfloat_t
+ctypedef double complex      cdouble_t
+ctypedef double complex      complex_t
+ctypedef long double complex clongdouble_t
+
+cdef inline object PyArray_MultiIterNew1(a):
+    return PyArray_MultiIterNew(1, <void*>a)
+
+cdef inline object PyArray_MultiIterNew2(a, b):
+    return PyArray_MultiIterNew(2, <void*>a, <void*>b)
+
+cdef inline object PyArray_MultiIterNew3(a, b, c):
+    return PyArray_MultiIterNew(3, <void*>a, <void*>b, <void*> c)
+
+cdef inline object PyArray_MultiIterNew4(a, b, c, d):
+    return PyArray_MultiIterNew(4, <void*>a, <void*>b, <void*>c, <void*> d)
+
+cdef inline object PyArray_MultiIterNew5(a, b, c, d, e):
+    return PyArray_MultiIterNew(5, <void*>a, <void*>b, <void*>c, <void*> d, <void*> e)
+
+cdef inline tuple PyDataType_SHAPE(dtype d):
+    if PyDataType_HASSUBARRAY(d):
+        return <tuple>d.subarray.shape
+    else:
+        return ()
+
+
+cdef extern from "numpy/ndarrayobject.h":
+    PyTypeObject PyTimedeltaArrType_Type
+    PyTypeObject PyDatetimeArrType_Type
+    ctypedef int64_t npy_timedelta
+    ctypedef int64_t npy_datetime
+
+cdef extern from "numpy/ndarraytypes.h":
+    ctypedef struct PyArray_DatetimeMetaData:
+        NPY_DATETIMEUNIT base
+        int64_t num
+
+    ctypedef struct npy_datetimestruct:
+        int64_t year
+        int32_t month, day, hour, min, sec, us, ps, as
+
+    # Iterator API added in v1.6
+    #
+    # These don't match the definition in the C API because Cython can't wrap
+    # function pointers that return functions.
+    # https://github.com/cython/cython/issues/6720
+    ctypedef int (*NpyIter_IterNextFunc "NpyIter_IterNextFunc *")(NpyIter* it) noexcept nogil
+    ctypedef void (*NpyIter_GetMultiIndexFunc "NpyIter_GetMultiIndexFunc *")(NpyIter* it, npy_intp* outcoords) noexcept nogil
+
+cdef extern from "numpy/arrayscalars.h":
+
+    # abstract types
+    ctypedef class numpy.generic [object PyObject]:
+        pass
+    ctypedef class numpy.number [object PyObject]:
+        pass
+    ctypedef class numpy.integer [object PyObject]:
+        pass
+    ctypedef class numpy.signedinteger [object PyObject]:
+        pass
+    ctypedef class numpy.unsignedinteger [object PyObject]:
+        pass
+    ctypedef class numpy.inexact [object PyObject]:
+        pass
+    ctypedef class numpy.floating [object PyObject]:
+        pass
+    ctypedef class numpy.complexfloating [object PyObject]:
+        pass
+    ctypedef class numpy.flexible [object PyObject]:
+        pass
+    ctypedef class numpy.character [object PyObject]:
+        pass
+
+    ctypedef struct PyDatetimeScalarObject:
+        # PyObject_HEAD
+        npy_datetime obval
+        PyArray_DatetimeMetaData obmeta
+
+    ctypedef struct PyTimedeltaScalarObject:
+        # PyObject_HEAD
+        npy_timedelta obval
+        PyArray_DatetimeMetaData obmeta
+
+    ctypedef enum NPY_DATETIMEUNIT:
+        NPY_FR_Y
+        NPY_FR_M
+        NPY_FR_W
+        NPY_FR_D
+        NPY_FR_B
+        NPY_FR_h
+        NPY_FR_m
+        NPY_FR_s
+        NPY_FR_ms
+        NPY_FR_us
+        NPY_FR_ns
+        NPY_FR_ps
+        NPY_FR_fs
+        NPY_FR_as
+        NPY_FR_GENERIC
+
+
+cdef extern from "numpy/arrayobject.h":
+    # These are part of the C-API defined in `__multiarray_api.h`
+
+    # NumPy internal definitions in datetime_strings.c:
+    int get_datetime_iso_8601_strlen "NpyDatetime_GetDatetimeISO8601StrLen" (
+            int local, NPY_DATETIMEUNIT base)
+    int make_iso_8601_datetime "NpyDatetime_MakeISO8601Datetime" (
+            npy_datetimestruct *dts, char *outstr, npy_intp outlen,
+            int local, int utc, NPY_DATETIMEUNIT base, int tzoffset,
+            NPY_CASTING casting) except -1
+
+    # NumPy internal definition in datetime.c:
+    # May return 1 to indicate that object does not appear to be a datetime
+    # (returns 0 on success).
+    int convert_pydatetime_to_datetimestruct "NpyDatetime_ConvertPyDateTimeToDatetimeStruct" (
+            PyObject *obj, npy_datetimestruct *out,
+            NPY_DATETIMEUNIT *out_bestunit, int apply_tzinfo) except -1
+    int convert_datetime64_to_datetimestruct "NpyDatetime_ConvertDatetime64ToDatetimeStruct" (
+            PyArray_DatetimeMetaData *meta, npy_datetime dt,
+            npy_datetimestruct *out) except -1
+    int convert_datetimestruct_to_datetime64 "NpyDatetime_ConvertDatetimeStructToDatetime64"(
+            PyArray_DatetimeMetaData *meta, const npy_datetimestruct *dts,
+            npy_datetime *out) except -1
+
+
+#
+# ufunc API
+#
+
+cdef extern from "numpy/ufuncobject.h":
+
+    ctypedef void (*PyUFuncGenericFunction) (char **, npy_intp *, npy_intp *, void *)
+
+    ctypedef class numpy.ufunc [object PyUFuncObject, check_size ignore]:
+        cdef:
+            int nin, nout, nargs
+            int identity
+            PyUFuncGenericFunction *functions
+            void **data
+            int ntypes
+            int check_return
+            char *name
+            char *types
+            char *doc
+            void *ptr
+            PyObject *obj
+            PyObject *userloops
+
+    cdef enum:
+        PyUFunc_Zero
+        PyUFunc_One
+        PyUFunc_None
+        # deprecated
+        UFUNC_FPE_DIVIDEBYZERO
+        UFUNC_FPE_OVERFLOW
+        UFUNC_FPE_UNDERFLOW
+        UFUNC_FPE_INVALID
+        # use these instead
+        NPY_FPE_DIVIDEBYZERO
+        NPY_FPE_OVERFLOW
+        NPY_FPE_UNDERFLOW
+        NPY_FPE_INVALID
+
+    object PyUFunc_FromFuncAndData(PyUFuncGenericFunction *,
+          void **, char *, int, int, int, int, char *, char *, int)
+    int PyUFunc_RegisterLoopForType(ufunc, int,
+                                    PyUFuncGenericFunction, int *, void *) except -1
+    void PyUFunc_f_f_As_d_d \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_d_d \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_f_f \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_g_g \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_F_F_As_D_D \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_F_F \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_D_D \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_G_G \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_O_O \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_ff_f_As_dd_d \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_ff_f \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_dd_d \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_gg_g \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_FF_F_As_DD_D \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_DD_D \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_FF_F \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_GG_G \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_OO_O \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_O_O_method \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_OO_O_method \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_On_Om \
+         (char **, npy_intp *, npy_intp *, void *)
+    void PyUFunc_clearfperr()
+    int PyUFunc_getfperr()
+    int PyUFunc_ReplaceLoopBySignature \
+        (ufunc, PyUFuncGenericFunction, int *, PyUFuncGenericFunction *)
+    object PyUFunc_FromFuncAndDataAndSignature \
+             (PyUFuncGenericFunction *, void **, char *, int, int, int,
+              int, char *, char *, int, char *)
+
+    int _import_umath() except -1
+
+cdef inline void set_array_base(ndarray arr, object base):
+    Py_INCREF(base) # important to do this before stealing the reference below!
+    PyArray_SetBaseObject(arr, base)
+
+cdef inline object get_array_base(ndarray arr):
+    base = PyArray_BASE(arr)
+    if base is NULL:
+        return None
+    return <object>base
+
+# Versions of the import_* functions which are more suitable for
+# Cython code.
+cdef inline int import_array() except -1:
+    try:
+        __pyx_import_array()
+    except Exception:
+        raise ImportError("numpy._core.multiarray failed to import")
+
+cdef inline int import_umath() except -1:
+    try:
+        _import_umath()
+    except Exception:
+        raise ImportError("numpy._core.umath failed to import")
+
+cdef inline int import_ufunc() except -1:
+    try:
+        _import_umath()
+    except Exception:
+        raise ImportError("numpy._core.umath failed to import")
+
+
+cdef inline bint is_timedelta64_object(object obj):
+    """
+    Cython equivalent of `isinstance(obj, np.timedelta64)`
+
+    Parameters
+    ----------
+    obj : object
+
+    Returns
+    -------
+    bool
+    """
+    return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type)
+
+
+cdef inline bint is_datetime64_object(object obj):
+    """
+    Cython equivalent of `isinstance(obj, np.datetime64)`
+
+    Parameters
+    ----------
+    obj : object
+
+    Returns
+    -------
+    bool
+    """
+    return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type)
+
+
+cdef inline npy_datetime get_datetime64_value(object obj) nogil:
+    """
+    returns the int64 value underlying scalar numpy datetime64 object
+
+    Note that to interpret this as a datetime, the corresponding unit is
+    also needed.  That can be found using `get_datetime64_unit`.
+    """
+    return (<PyDatetimeScalarObject*>obj).obval
+
+
+cdef inline npy_timedelta get_timedelta64_value(object obj) nogil:
+    """
+    returns the int64 value underlying scalar numpy timedelta64 object
+    """
+    return (<PyTimedeltaScalarObject*>obj).obval
+
+
+cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) nogil:
+    """
+    returns the unit part of the dtype for a numpy datetime64 object.
+    """
+    return <NPY_DATETIMEUNIT>(<PyDatetimeScalarObject*>obj).obmeta.base
+
+
+cdef extern from "numpy/arrayobject.h":
+
+    ctypedef struct NpyIter:
+        pass
+
+    cdef enum:
+        NPY_FAIL
+        NPY_SUCCEED
+
+    cdef enum:
+        # Track an index representing C order
+        NPY_ITER_C_INDEX
+        # Track an index representing Fortran order
+        NPY_ITER_F_INDEX
+        # Track a multi-index
+        NPY_ITER_MULTI_INDEX
+        # User code external to the iterator does the 1-dimensional innermost loop
+        NPY_ITER_EXTERNAL_LOOP
+        # Convert all the operands to a common data type
+        NPY_ITER_COMMON_DTYPE
+        # Operands may hold references, requiring API access during iteration
+        NPY_ITER_REFS_OK
+        # Zero-sized operands should be permitted, iteration checks IterSize for 0
+        NPY_ITER_ZEROSIZE_OK
+        # Permits reductions (size-0 stride with dimension size > 1)
+        NPY_ITER_REDUCE_OK
+        # Enables sub-range iteration
+        NPY_ITER_RANGED
+        # Enables buffering
+        NPY_ITER_BUFFERED
+        # When buffering is enabled, grows the inner loop if possible
+        NPY_ITER_GROWINNER
+        # Delay allocation of buffers until first Reset* call
+        NPY_ITER_DELAY_BUFALLOC
+        # When NPY_KEEPORDER is specified, disable reversing negative-stride axes
+        NPY_ITER_DONT_NEGATE_STRIDES
+        NPY_ITER_COPY_IF_OVERLAP
+        # The operand will be read from and written to
+        NPY_ITER_READWRITE
+        # The operand will only be read from
+        NPY_ITER_READONLY
+        # The operand will only be written to
+        NPY_ITER_WRITEONLY
+        # The operand's data must be in native byte order
+        NPY_ITER_NBO
+        # The operand's data must be aligned
+        NPY_ITER_ALIGNED
+        # The operand's data must be contiguous (within the inner loop)
+        NPY_ITER_CONTIG
+        # The operand may be copied to satisfy requirements
+        NPY_ITER_COPY
+        # The operand may be copied with WRITEBACKIFCOPY to satisfy requirements
+        NPY_ITER_UPDATEIFCOPY
+        # Allocate the operand if it is NULL
+        NPY_ITER_ALLOCATE
+        # If an operand is allocated, don't use any subtype
+        NPY_ITER_NO_SUBTYPE
+        # This is a virtual array slot, operand is NULL but temporary data is there
+        NPY_ITER_VIRTUAL
+        # Require that the dimension match the iterator dimensions exactly
+        NPY_ITER_NO_BROADCAST
+        # A mask is being used on this array, affects buffer -> array copy
+        NPY_ITER_WRITEMASKED
+        # This array is the mask for all WRITEMASKED operands
+        NPY_ITER_ARRAYMASK
+        # Assume iterator order data access for COPY_IF_OVERLAP
+        NPY_ITER_OVERLAP_ASSUME_ELEMENTWISE
+
+    # construction and destruction functions
+    NpyIter* NpyIter_New(ndarray arr, npy_uint32 flags, NPY_ORDER order,
+                         NPY_CASTING casting, dtype datatype) except NULL
+    NpyIter* NpyIter_MultiNew(npy_intp nop, PyArrayObject** op, npy_uint32 flags,
+                              NPY_ORDER order, NPY_CASTING casting, npy_uint32*
+                              op_flags, PyArray_Descr** op_dtypes) except NULL
+    NpyIter* NpyIter_AdvancedNew(npy_intp nop, PyArrayObject** op,
+                                 npy_uint32 flags, NPY_ORDER order,
+                                 NPY_CASTING casting, npy_uint32* op_flags,
+                                 PyArray_Descr** op_dtypes, int oa_ndim,
+                                 int** op_axes, const npy_intp* itershape,
+                                 npy_intp buffersize) except NULL
+    NpyIter* NpyIter_Copy(NpyIter* it) except NULL
+    int NpyIter_RemoveAxis(NpyIter* it, int axis) except NPY_FAIL
+    int NpyIter_RemoveMultiIndex(NpyIter* it) except NPY_FAIL
+    int NpyIter_EnableExternalLoop(NpyIter* it) except NPY_FAIL
+    int NpyIter_Deallocate(NpyIter* it) except NPY_FAIL
+    int NpyIter_Reset(NpyIter* it, char** errmsg) except NPY_FAIL
+    int NpyIter_ResetToIterIndexRange(NpyIter* it, npy_intp istart,
+                                      npy_intp iend, char** errmsg) except NPY_FAIL
+    int NpyIter_ResetBasePointers(NpyIter* it, char** baseptrs, char** errmsg) except NPY_FAIL
+    int NpyIter_GotoMultiIndex(NpyIter* it, const npy_intp* multi_index) except NPY_FAIL
+    int NpyIter_GotoIndex(NpyIter* it, npy_intp index) except NPY_FAIL
+    npy_intp NpyIter_GetIterSize(NpyIter* it) nogil
+    npy_intp NpyIter_GetIterIndex(NpyIter* it) nogil
+    void NpyIter_GetIterIndexRange(NpyIter* it, npy_intp* istart,
+                                   npy_intp* iend) nogil
+    int NpyIter_GotoIterIndex(NpyIter* it, npy_intp iterindex) except NPY_FAIL
+    npy_bool NpyIter_HasDelayedBufAlloc(NpyIter* it) nogil
+    npy_bool NpyIter_HasExternalLoop(NpyIter* it) nogil
+    npy_bool NpyIter_HasMultiIndex(NpyIter* it) nogil
+    npy_bool NpyIter_HasIndex(NpyIter* it) nogil
+    npy_bool NpyIter_RequiresBuffering(NpyIter* it) nogil
+    npy_bool NpyIter_IsBuffered(NpyIter* it) nogil
+    npy_bool NpyIter_IsGrowInner(NpyIter* it) nogil
+    npy_intp NpyIter_GetBufferSize(NpyIter* it) nogil
+    int NpyIter_GetNDim(NpyIter* it) nogil
+    int NpyIter_GetNOp(NpyIter* it) nogil
+    npy_intp* NpyIter_GetAxisStrideArray(NpyIter* it, int axis) except NULL
+    int NpyIter_GetShape(NpyIter* it, npy_intp* outshape) nogil
+    PyArray_Descr** NpyIter_GetDescrArray(NpyIter* it)
+    PyArrayObject** NpyIter_GetOperandArray(NpyIter* it)
+    ndarray NpyIter_GetIterView(NpyIter* it, npy_intp i)
+    void NpyIter_GetReadFlags(NpyIter* it, char* outreadflags)
+    void NpyIter_GetWriteFlags(NpyIter* it, char* outwriteflags)
+    int NpyIter_CreateCompatibleStrides(NpyIter* it, npy_intp itemsize,
+                                        npy_intp* outstrides) except NPY_FAIL
+    npy_bool NpyIter_IsFirstVisit(NpyIter* it, int iop) nogil
+    # functions for iterating an NpyIter object
+    #
+    # These don't match the definition in the C API because Cython can't wrap
+    # function pointers that return functions.
+    NpyIter_IterNextFunc* NpyIter_GetIterNext(NpyIter* it, char** errmsg) except NULL
+    NpyIter_GetMultiIndexFunc* NpyIter_GetGetMultiIndex(NpyIter* it,
+                                                        char** errmsg) except NULL
+    char** NpyIter_GetDataPtrArray(NpyIter* it) nogil
+    char** NpyIter_GetInitialDataPtrArray(NpyIter* it) nogil
+    npy_intp* NpyIter_GetIndexPtr(NpyIter* it)
+    npy_intp* NpyIter_GetInnerStrideArray(NpyIter* it) nogil
+    npy_intp* NpyIter_GetInnerLoopSizePtr(NpyIter* it) nogil
+    void NpyIter_GetInnerFixedStrideArray(NpyIter* it, npy_intp* outstrides) nogil
+    npy_bool NpyIter_IterationNeedsAPI(NpyIter* it) nogil
+    void NpyIter_DebugPrint(NpyIter* it)
+
+# NpyString API
+cdef extern from "numpy/ndarraytypes.h":
+    ctypedef struct npy_string_allocator:
+        pass
+
+    ctypedef struct npy_packed_static_string:
+        pass
+
+    ctypedef struct npy_static_string:
+        size_t size
+        const char *buf
+
+    ctypedef struct PyArray_StringDTypeObject:
+        PyArray_Descr base
+        PyObject *na_object
+        char coerce
+        char has_nan_na
+        char has_string_na
+        char array_owned
+        npy_static_string default_string
+        npy_static_string na_name
+        npy_string_allocator *allocator
+
+cdef extern from "numpy/arrayobject.h":
+    npy_string_allocator *NpyString_acquire_allocator(const PyArray_StringDTypeObject *descr)
+    void NpyString_acquire_allocators(size_t n_descriptors, PyArray_Descr *const descrs[], npy_string_allocator *allocators[])
+    void NpyString_release_allocator(npy_string_allocator *allocator)
+    void NpyString_release_allocators(size_t length, npy_string_allocator *allocators[])
+    int NpyString_load(npy_string_allocator *allocator, const npy_packed_static_string *packed_string, npy_static_string *unpacked_string)
+    int NpyString_pack_null(npy_string_allocator *allocator, npy_packed_static_string *packed_string)
+    int NpyString_pack(npy_string_allocator *allocator, npy_packed_static_string *packed_string, const char *buf, size_t size)

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

@@ -0,0 +1,942 @@
+"""
+NumPy
+=====
+
+Provides
+  1. An array object of arbitrary homogeneous items
+  2. Fast mathematical operations over arrays
+  3. Linear Algebra, Fourier Transforms, Random Number Generation
+
+How to use the documentation
+----------------------------
+Documentation is available in two forms: docstrings provided
+with the code, and a loose standing reference guide, available from
+`the NumPy homepage <https://numpy.org>`_.
+
+We recommend exploring the docstrings using
+`IPython <https://ipython.org>`_, an advanced Python shell with
+TAB-completion and introspection capabilities.  See below for further
+instructions.
+
+The docstring examples assume that `numpy` has been imported as ``np``::
+
+  >>> import numpy as np
+
+Code snippets are indicated by three greater-than signs::
+
+  >>> x = 42
+  >>> x = x + 1
+
+Use the built-in ``help`` function to view a function's docstring::
+
+  >>> help(np.sort)
+  ... # doctest: +SKIP
+
+For some objects, ``np.info(obj)`` may provide additional help.  This is
+particularly true if you see the line "Help on ufunc object:" at the top
+of the help() page.  Ufuncs are implemented in C, not Python, for speed.
+The native Python help() does not know how to view their help, but our
+np.info() function does.
+
+Available subpackages
+---------------------
+lib
+    Basic functions used by several sub-packages.
+random
+    Core Random Tools
+linalg
+    Core Linear Algebra Tools
+fft
+    Core FFT routines
+polynomial
+    Polynomial tools
+testing
+    NumPy testing tools
+distutils
+    Enhancements to distutils with support for
+    Fortran compilers support and more (for Python <= 3.11)
+
+Utilities
+---------
+test
+    Run numpy unittests
+show_config
+    Show numpy build configuration
+__version__
+    NumPy version string
+
+Viewing documentation using IPython
+-----------------------------------
+
+Start IPython and import `numpy` usually under the alias ``np``: `import
+numpy as np`.  Then, directly past or use the ``%cpaste`` magic to paste
+examples into the shell.  To see which functions are available in `numpy`,
+type ``np.<TAB>`` (where ``<TAB>`` refers to the TAB key), or use
+``np.*cos*?<ENTER>`` (where ``<ENTER>`` refers to the ENTER key) to narrow
+down the list.  To view the docstring for a function, use
+``np.cos?<ENTER>`` (to view the docstring) and ``np.cos??<ENTER>`` (to view
+the source code).
+
+Copies vs. in-place operation
+-----------------------------
+Most of the functions in `numpy` return a copy of the array argument
+(e.g., `np.sort`).  In-place versions of these functions are often
+available as array methods, i.e. ``x = np.array([1,2,3]); x.sort()``.
+Exceptions to this rule are documented.
+
+"""
+import os
+import sys
+import warnings
+
+# If a version with git hash was stored, use that instead
+from . import version
+from ._expired_attrs_2_0 import __expired_attributes__
+from ._globals import _CopyMode, _NoValue
+from .version import __version__
+
+# We first need to detect if we're being called as part of the numpy setup
+# procedure itself in a reliable manner.
+try:
+    __NUMPY_SETUP__  # noqa: B018
+except NameError:
+    __NUMPY_SETUP__ = False
+
+if __NUMPY_SETUP__:
+    sys.stderr.write('Running from numpy source directory.\n')
+else:
+    # Allow distributors to run custom init code before importing numpy._core
+    from . import _distributor_init
+
+    try:
+        from numpy.__config__ import show_config
+    except ImportError as e:
+        if isinstance(e, ModuleNotFoundError) and e.name == "numpy.__config__":
+            # The __config__ module itself was not found, so add this info:
+            msg = """Error importing numpy: you should not try to import numpy from
+            its source directory; please exit the numpy source tree, and relaunch
+            your python interpreter from there."""
+            raise ImportError(msg) from e
+        raise
+
+    from . import _core
+    from ._core import (
+        False_,
+        ScalarType,
+        True_,
+        abs,
+        absolute,
+        acos,
+        acosh,
+        add,
+        all,
+        allclose,
+        amax,
+        amin,
+        any,
+        arange,
+        arccos,
+        arccosh,
+        arcsin,
+        arcsinh,
+        arctan,
+        arctan2,
+        arctanh,
+        argmax,
+        argmin,
+        argpartition,
+        argsort,
+        argwhere,
+        around,
+        array,
+        array2string,
+        array_equal,
+        array_equiv,
+        array_repr,
+        array_str,
+        asanyarray,
+        asarray,
+        ascontiguousarray,
+        asfortranarray,
+        asin,
+        asinh,
+        astype,
+        atan,
+        atan2,
+        atanh,
+        atleast_1d,
+        atleast_2d,
+        atleast_3d,
+        base_repr,
+        binary_repr,
+        bitwise_and,
+        bitwise_count,
+        bitwise_invert,
+        bitwise_left_shift,
+        bitwise_not,
+        bitwise_or,
+        bitwise_right_shift,
+        bitwise_xor,
+        block,
+        bool,
+        bool_,
+        broadcast,
+        busday_count,
+        busday_offset,
+        busdaycalendar,
+        byte,
+        bytes_,
+        can_cast,
+        cbrt,
+        cdouble,
+        ceil,
+        character,
+        choose,
+        clip,
+        clongdouble,
+        complex64,
+        complex128,
+        complexfloating,
+        compress,
+        concat,
+        concatenate,
+        conj,
+        conjugate,
+        convolve,
+        copysign,
+        copyto,
+        correlate,
+        cos,
+        cosh,
+        count_nonzero,
+        cross,
+        csingle,
+        cumprod,
+        cumsum,
+        cumulative_prod,
+        cumulative_sum,
+        datetime64,
+        datetime_as_string,
+        datetime_data,
+        deg2rad,
+        degrees,
+        diagonal,
+        divide,
+        divmod,
+        dot,
+        double,
+        dtype,
+        e,
+        einsum,
+        einsum_path,
+        empty,
+        empty_like,
+        equal,
+        errstate,
+        euler_gamma,
+        exp,
+        exp2,
+        expm1,
+        fabs,
+        finfo,
+        flatiter,
+        flatnonzero,
+        flexible,
+        float16,
+        float32,
+        float64,
+        float_power,
+        floating,
+        floor,
+        floor_divide,
+        fmax,
+        fmin,
+        fmod,
+        format_float_positional,
+        format_float_scientific,
+        frexp,
+        from_dlpack,
+        frombuffer,
+        fromfile,
+        fromfunction,
+        fromiter,
+        frompyfunc,
+        fromstring,
+        full,
+        full_like,
+        gcd,
+        generic,
+        geomspace,
+        get_printoptions,
+        getbufsize,
+        geterr,
+        geterrcall,
+        greater,
+        greater_equal,
+        half,
+        heaviside,
+        hstack,
+        hypot,
+        identity,
+        iinfo,
+        indices,
+        inexact,
+        inf,
+        inner,
+        int8,
+        int16,
+        int32,
+        int64,
+        int_,
+        intc,
+        integer,
+        intp,
+        invert,
+        is_busday,
+        isclose,
+        isdtype,
+        isfinite,
+        isfortran,
+        isinf,
+        isnan,
+        isnat,
+        isscalar,
+        issubdtype,
+        lcm,
+        ldexp,
+        left_shift,
+        less,
+        less_equal,
+        lexsort,
+        linspace,
+        little_endian,
+        log,
+        log1p,
+        log2,
+        log10,
+        logaddexp,
+        logaddexp2,
+        logical_and,
+        logical_not,
+        logical_or,
+        logical_xor,
+        logspace,
+        long,
+        longdouble,
+        longlong,
+        matmul,
+        matrix_transpose,
+        matvec,
+        max,
+        maximum,
+        may_share_memory,
+        mean,
+        memmap,
+        min,
+        min_scalar_type,
+        minimum,
+        mod,
+        modf,
+        moveaxis,
+        multiply,
+        nan,
+        ndarray,
+        ndim,
+        nditer,
+        negative,
+        nested_iters,
+        newaxis,
+        nextafter,
+        nonzero,
+        not_equal,
+        number,
+        object_,
+        ones,
+        ones_like,
+        outer,
+        partition,
+        permute_dims,
+        pi,
+        positive,
+        pow,
+        power,
+        printoptions,
+        prod,
+        promote_types,
+        ptp,
+        put,
+        putmask,
+        rad2deg,
+        radians,
+        ravel,
+        recarray,
+        reciprocal,
+        record,
+        remainder,
+        repeat,
+        require,
+        reshape,
+        resize,
+        result_type,
+        right_shift,
+        rint,
+        roll,
+        rollaxis,
+        round,
+        sctypeDict,
+        searchsorted,
+        set_printoptions,
+        setbufsize,
+        seterr,
+        seterrcall,
+        shape,
+        shares_memory,
+        short,
+        sign,
+        signbit,
+        signedinteger,
+        sin,
+        single,
+        sinh,
+        size,
+        sort,
+        spacing,
+        sqrt,
+        square,
+        squeeze,
+        stack,
+        std,
+        str_,
+        subtract,
+        sum,
+        swapaxes,
+        take,
+        tan,
+        tanh,
+        tensordot,
+        timedelta64,
+        trace,
+        transpose,
+        true_divide,
+        trunc,
+        typecodes,
+        ubyte,
+        ufunc,
+        uint,
+        uint8,
+        uint16,
+        uint32,
+        uint64,
+        uintc,
+        uintp,
+        ulong,
+        ulonglong,
+        unsignedinteger,
+        unstack,
+        ushort,
+        var,
+        vdot,
+        vecdot,
+        vecmat,
+        void,
+        vstack,
+        where,
+        zeros,
+        zeros_like,
+    )
+
+    # NOTE: It's still under discussion whether these aliases
+    # should be removed.
+    for ta in ["float96", "float128", "complex192", "complex256"]:
+        try:
+            globals()[ta] = getattr(_core, ta)
+        except AttributeError:
+            pass
+    del ta
+
+    from . import lib, matrixlib as _mat
+    from .lib import scimath as emath
+    from .lib._arraypad_impl import pad
+    from .lib._arraysetops_impl import (
+        ediff1d,
+        intersect1d,
+        isin,
+        setdiff1d,
+        setxor1d,
+        union1d,
+        unique,
+        unique_all,
+        unique_counts,
+        unique_inverse,
+        unique_values,
+    )
+    from .lib._function_base_impl import (
+        angle,
+        append,
+        asarray_chkfinite,
+        average,
+        bartlett,
+        bincount,
+        blackman,
+        copy,
+        corrcoef,
+        cov,
+        delete,
+        diff,
+        digitize,
+        extract,
+        flip,
+        gradient,
+        hamming,
+        hanning,
+        i0,
+        insert,
+        interp,
+        iterable,
+        kaiser,
+        median,
+        meshgrid,
+        percentile,
+        piecewise,
+        place,
+        quantile,
+        rot90,
+        select,
+        sinc,
+        sort_complex,
+        trapezoid,
+        trim_zeros,
+        unwrap,
+        vectorize,
+    )
+    from .lib._histograms_impl import histogram, histogram_bin_edges, histogramdd
+    from .lib._index_tricks_impl import (
+        c_,
+        diag_indices,
+        diag_indices_from,
+        fill_diagonal,
+        index_exp,
+        ix_,
+        mgrid,
+        ndenumerate,
+        ndindex,
+        ogrid,
+        r_,
+        ravel_multi_index,
+        s_,
+        unravel_index,
+    )
+    from .lib._nanfunctions_impl import (
+        nanargmax,
+        nanargmin,
+        nancumprod,
+        nancumsum,
+        nanmax,
+        nanmean,
+        nanmedian,
+        nanmin,
+        nanpercentile,
+        nanprod,
+        nanquantile,
+        nanstd,
+        nansum,
+        nanvar,
+    )
+    from .lib._npyio_impl import (
+        fromregex,
+        genfromtxt,
+        load,
+        loadtxt,
+        packbits,
+        save,
+        savetxt,
+        savez,
+        savez_compressed,
+        unpackbits,
+    )
+    from .lib._polynomial_impl import (
+        poly,
+        poly1d,
+        polyadd,
+        polyder,
+        polydiv,
+        polyfit,
+        polyint,
+        polymul,
+        polysub,
+        polyval,
+        roots,
+    )
+    from .lib._shape_base_impl import (
+        apply_along_axis,
+        apply_over_axes,
+        array_split,
+        column_stack,
+        dsplit,
+        dstack,
+        expand_dims,
+        hsplit,
+        kron,
+        put_along_axis,
+        row_stack,
+        split,
+        take_along_axis,
+        tile,
+        vsplit,
+    )
+    from .lib._stride_tricks_impl import (
+        broadcast_arrays,
+        broadcast_shapes,
+        broadcast_to,
+    )
+    from .lib._twodim_base_impl import (
+        diag,
+        diagflat,
+        eye,
+        fliplr,
+        flipud,
+        histogram2d,
+        mask_indices,
+        tri,
+        tril,
+        tril_indices,
+        tril_indices_from,
+        triu,
+        triu_indices,
+        triu_indices_from,
+        vander,
+    )
+    from .lib._type_check_impl import (
+        common_type,
+        imag,
+        iscomplex,
+        iscomplexobj,
+        isreal,
+        isrealobj,
+        mintypecode,
+        nan_to_num,
+        real,
+        real_if_close,
+        typename,
+    )
+    from .lib._ufunclike_impl import fix, isneginf, isposinf
+    from .lib._utils_impl import get_include, info, show_runtime
+    from .matrixlib import asmatrix, bmat, matrix
+
+    # public submodules are imported lazily, therefore are accessible from
+    # __getattr__. Note that `distutils` (deprecated) and `array_api`
+    # (experimental label) are not added here, because `from numpy import *`
+    # must not raise any warnings - that's too disruptive.
+    __numpy_submodules__ = {
+        "linalg", "fft", "dtypes", "random", "polynomial", "ma",
+        "exceptions", "lib", "ctypeslib", "testing", "typing",
+        "f2py", "test", "rec", "char", "core", "strings",
+    }
+
+    # We build warning messages for former attributes
+    _msg = (
+        "module 'numpy' has no attribute '{n}'.\n"
+        "`np.{n}` was a deprecated alias for the builtin `{n}`. "
+        "To avoid this error in existing code, use `{n}` by itself. "
+        "Doing this will not modify any behavior and is safe. {extended_msg}\n"
+        "The aliases was originally deprecated in NumPy 1.20; for more "
+        "details and guidance see the original release note at:\n"
+        "    https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations")
+
+    _specific_msg = (
+        "If you specifically wanted the numpy scalar type, use `np.{}` here.")
+
+    _int_extended_msg = (
+        "When replacing `np.{}`, you may wish to use e.g. `np.int64` "
+        "or `np.int32` to specify the precision. If you wish to review "
+        "your current use, check the release note link for "
+        "additional information.")
+
+    _type_info = [
+        ("object", ""),  # The NumPy scalar only exists by name.
+        ("float", _specific_msg.format("float64")),
+        ("complex", _specific_msg.format("complex128")),
+        ("str", _specific_msg.format("str_")),
+        ("int", _int_extended_msg.format("int"))]
+
+    __former_attrs__ = {
+         n: _msg.format(n=n, extended_msg=extended_msg)
+         for n, extended_msg in _type_info
+     }
+
+    # Some of these could be defined right away, but most were aliases to
+    # the Python objects and only removed in NumPy 1.24.  Defining them should
+    # probably wait for NumPy 1.26 or 2.0.
+    # When defined, these should possibly not be added to `__all__` to avoid
+    # import with `from numpy import *`.
+    __future_scalars__ = {"str", "bytes", "object"}
+
+    __array_api_version__ = "2024.12"
+
+    from ._array_api_info import __array_namespace_info__
+
+    __all__ = list(
+        __numpy_submodules__ |
+        set(_core.__all__) |
+        set(_mat.__all__) |
+        set(lib._histograms_impl.__all__) |
+        set(lib._nanfunctions_impl.__all__) |
+        set(lib._function_base_impl.__all__) |
+        set(lib._twodim_base_impl.__all__) |
+        set(lib._shape_base_impl.__all__) |
+        set(lib._type_check_impl.__all__) |
+        set(lib._arraysetops_impl.__all__) |
+        set(lib._ufunclike_impl.__all__) |
+        set(lib._arraypad_impl.__all__) |
+        set(lib._utils_impl.__all__) |
+        set(lib._stride_tricks_impl.__all__) |
+        set(lib._polynomial_impl.__all__) |
+        set(lib._npyio_impl.__all__) |
+        set(lib._index_tricks_impl.__all__) |
+        {"emath", "show_config", "__version__", "__array_namespace_info__"}
+    )
+
+    # Filter out Cython harmless warnings
+    warnings.filterwarnings("ignore", message="numpy.dtype size changed")
+    warnings.filterwarnings("ignore", message="numpy.ufunc size changed")
+    warnings.filterwarnings("ignore", message="numpy.ndarray size changed")
+
+    def __getattr__(attr):
+        # Warn for expired attributes
+        import warnings
+
+        if attr == "linalg":
+            import numpy.linalg as linalg
+            return linalg
+        elif attr == "fft":
+            import numpy.fft as fft
+            return fft
+        elif attr == "dtypes":
+            import numpy.dtypes as dtypes
+            return dtypes
+        elif attr == "random":
+            import numpy.random as random
+            return random
+        elif attr == "polynomial":
+            import numpy.polynomial as polynomial
+            return polynomial
+        elif attr == "ma":
+            import numpy.ma as ma
+            return ma
+        elif attr == "ctypeslib":
+            import numpy.ctypeslib as ctypeslib
+            return ctypeslib
+        elif attr == "exceptions":
+            import numpy.exceptions as exceptions
+            return exceptions
+        elif attr == "testing":
+            import numpy.testing as testing
+            return testing
+        elif attr == "matlib":
+            import numpy.matlib as matlib
+            return matlib
+        elif attr == "f2py":
+            import numpy.f2py as f2py
+            return f2py
+        elif attr == "typing":
+            import numpy.typing as typing
+            return typing
+        elif attr == "rec":
+            import numpy.rec as rec
+            return rec
+        elif attr == "char":
+            import numpy.char as char
+            return char
+        elif attr == "array_api":
+            raise AttributeError("`numpy.array_api` is not available from "
+                                 "numpy 2.0 onwards", name=None)
+        elif attr == "core":
+            import numpy.core as core
+            return core
+        elif attr == "strings":
+            import numpy.strings as strings
+            return strings
+        elif attr == "distutils":
+            if 'distutils' in __numpy_submodules__:
+                import numpy.distutils as distutils
+                return distutils
+            else:
+                raise AttributeError("`numpy.distutils` is not available from "
+                                     "Python 3.12 onwards", name=None)
+
+        if attr in __future_scalars__:
+            # And future warnings for those that will change, but also give
+            # the AttributeError
+            warnings.warn(
+                f"In the future `np.{attr}` will be defined as the "
+                "corresponding NumPy scalar.", FutureWarning, stacklevel=2)
+
+        if attr in __former_attrs__:
+            raise AttributeError(__former_attrs__[attr], name=None)
+
+        if attr in __expired_attributes__:
+            raise AttributeError(
+                f"`np.{attr}` was removed in the NumPy 2.0 release. "
+                f"{__expired_attributes__[attr]}",
+                name=None
+            )
+
+        if attr == "chararray":
+            warnings.warn(
+                "`np.chararray` is deprecated and will be removed from "
+                "the main namespace in the future. Use an array with a string "
+                "or bytes dtype instead.", DeprecationWarning, stacklevel=2)
+            import numpy.char as char
+            return char.chararray
+
+        raise AttributeError(f"module {__name__!r} has no attribute {attr!r}")
+
+    def __dir__():
+        public_symbols = (
+            globals().keys() | __numpy_submodules__
+        )
+        public_symbols -= {
+            "matrixlib", "matlib", "tests", "conftest", "version",
+            "distutils", "array_api"
+        }
+        return list(public_symbols)
+
+    # Pytest testing
+    from numpy._pytesttester import PytestTester
+    test = PytestTester(__name__)
+    del PytestTester
+
+    def _sanity_check():
+        """
+        Quick sanity checks for common bugs caused by environment.
+        There are some cases e.g. with wrong BLAS ABI that cause wrong
+        results under specific runtime conditions that are not necessarily
+        achieved during test suite runs, and it is useful to catch those early.
+
+        See https://github.com/numpy/numpy/issues/8577 and other
+        similar bug reports.
+
+        """
+        try:
+            x = ones(2, dtype=float32)
+            if not abs(x.dot(x) - float32(2.0)) < 1e-5:
+                raise AssertionError
+        except AssertionError:
+            msg = ("The current Numpy installation ({!r}) fails to "
+                   "pass simple sanity checks. This can be caused for example "
+                   "by incorrect BLAS library being linked in, or by mixing "
+                   "package managers (pip, conda, apt, ...). Search closed "
+                   "numpy issues for similar problems.")
+            raise RuntimeError(msg.format(__file__)) from None
+
+    _sanity_check()
+    del _sanity_check
+
+    def _mac_os_check():
+        """
+        Quick Sanity check for Mac OS look for accelerate build bugs.
+        Testing numpy polyfit calls init_dgelsd(LAPACK)
+        """
+        try:
+            c = array([3., 2., 1.])
+            x = linspace(0, 2, 5)
+            y = polyval(c, x)
+            _ = polyfit(x, y, 2, cov=True)
+        except ValueError:
+            pass
+
+    if sys.platform == "darwin":
+        from . import exceptions
+        with warnings.catch_warnings(record=True) as w:
+            _mac_os_check()
+            # Throw runtime error, if the test failed
+            # Check for warning and report the error_message
+            if len(w) > 0:
+                for _wn in w:
+                    if _wn.category is exceptions.RankWarning:
+                        # Ignore other warnings, they may not be relevant (see gh-25433)
+                        error_message = (
+                            f"{_wn.category.__name__}: {_wn.message}"
+                        )
+                        msg = (
+                            "Polyfit sanity test emitted a warning, most likely due "
+                            "to using a buggy Accelerate backend."
+                            "\nIf you compiled yourself, more information is available at:"  # noqa: E501
+                            "\nhttps://numpy.org/devdocs/building/index.html"
+                            "\nOtherwise report this to the vendor "
+                            f"that provided NumPy.\n\n{error_message}\n")
+                        raise RuntimeError(msg)
+                del _wn
+            del w
+    del _mac_os_check
+
+    def blas_fpe_check():
+        # Check if BLAS adds spurious FPEs, mostly seen on M4 arms with Accelerate.
+        with errstate(all='raise'):
+            x = ones((20, 20))
+            try:
+                x @ x
+            except FloatingPointError:
+                res = _core._multiarray_umath._blas_supports_fpe(False)
+                if res:  # res was not modified (hardcoded to True for now)
+                    warnings.warn(
+                        "Spurious warnings given by blas but suppression not "
+                        "set up on this platform. Please open a NumPy issue.",
+                        UserWarning, stacklevel=2)
+
+    blas_fpe_check()
+    del blas_fpe_check
+
+    def hugepage_setup():
+        """
+        We usually use madvise hugepages support, but on some old kernels it
+        is slow and thus better avoided. Specifically kernel version 4.6
+        had a bug fix which probably fixed this:
+        https://github.com/torvalds/linux/commit/7cf91a98e607c2f935dbcc177d70011e95b8faff
+        """
+        use_hugepage = os.environ.get("NUMPY_MADVISE_HUGEPAGE", None)
+        if sys.platform == "linux" and use_hugepage is None:
+            # If there is an issue with parsing the kernel version,
+            # set use_hugepage to 0. Usage of LooseVersion will handle
+            # the kernel version parsing better, but avoided since it
+            # will increase the import time.
+            # See: #16679 for related discussion.
+            try:
+                use_hugepage = 1
+                kernel_version = os.uname().release.split(".")[:2]
+                kernel_version = tuple(int(v) for v in kernel_version)
+                if kernel_version < (4, 6):
+                    use_hugepage = 0
+            except ValueError:
+                use_hugepage = 0
+        elif use_hugepage is None:
+            # This is not Linux, so it should not matter, just enable anyway
+            use_hugepage = 1
+        else:
+            use_hugepage = int(use_hugepage)
+        return use_hugepage
+
+    # Note that this will currently only make a difference on Linux
+    _core.multiarray._set_madvise_hugepage(hugepage_setup())
+    del hugepage_setup
+
+    # Give a warning if NumPy is reloaded or imported on a sub-interpreter
+    # We do this from python, since the C-module may not be reloaded and
+    # it is tidier organized.
+    _core.multiarray._multiarray_umath._reload_guard()
+
+    # TODO: Remove the environment variable entirely now that it is "weak"
+    if (os.environ.get("NPY_PROMOTION_STATE", "weak") != "weak"):
+        warnings.warn(
+            "NPY_PROMOTION_STATE was a temporary feature for NumPy 2.0 "
+            "transition and is ignored after NumPy 2.2.",
+            UserWarning, stacklevel=2)
+
+    # Tell PyInstaller where to find hook-numpy.py
+    def _pyinstaller_hooks_dir():
+        from pathlib import Path
+        return [str(Path(__file__).with_name("_pyinstaller").resolve())]
+
+
+# Remove symbols imported for internal use
+del os, sys, warnings

.venv_haddock/lib/python3.12/site-packages/numpy/_array_api_info.py

@@ -0,0 +1,346 @@
+"""
+Array API Inspection namespace
+
+This is the namespace for inspection functions as defined by the array API
+standard. See
+https://data-apis.org/array-api/latest/API_specification/inspection.html for
+more details.
+
+"""
+from numpy._core import (
+    bool,
+    complex64,
+    complex128,
+    dtype,
+    float32,
+    float64,
+    int8,
+    int16,
+    int32,
+    int64,
+    intp,
+    uint8,
+    uint16,
+    uint32,
+    uint64,
+)
+from numpy._utils import set_module
+
+
+@set_module('numpy')
+class __array_namespace_info__:
+    """
+    Get the array API inspection namespace for NumPy.
+
+    The array API inspection namespace defines the following functions:
+
+    - capabilities()
+    - default_device()
+    - default_dtypes()
+    - dtypes()
+    - devices()
+
+    See
+    https://data-apis.org/array-api/latest/API_specification/inspection.html
+    for more details.
+
+    Returns
+    -------
+    info : ModuleType
+        The array API inspection namespace for NumPy.
+
+    Examples
+    --------
+    >>> info = np.__array_namespace_info__()
+    >>> info.default_dtypes()
+    {'real floating': numpy.float64,
+     'complex floating': numpy.complex128,
+     'integral': numpy.int64,
+     'indexing': numpy.int64}
+
+    """
+
+    def capabilities(self):
+        """
+        Return a dictionary of array API library capabilities.
+
+        The resulting dictionary has the following keys:
+
+        - **"boolean indexing"**: boolean indicating whether an array library
+          supports boolean indexing. Always ``True`` for NumPy.
+
+        - **"data-dependent shapes"**: boolean indicating whether an array
+          library supports data-dependent output shapes. Always ``True`` for
+          NumPy.
+
+        See
+        https://data-apis.org/array-api/latest/API_specification/generated/array_api.info.capabilities.html
+        for more details.
+
+        See Also
+        --------
+        __array_namespace_info__.default_device,
+        __array_namespace_info__.default_dtypes,
+        __array_namespace_info__.dtypes,
+        __array_namespace_info__.devices
+
+        Returns
+        -------
+        capabilities : dict
+            A dictionary of array API library capabilities.
+
+        Examples
+        --------
+        >>> info = np.__array_namespace_info__()
+        >>> info.capabilities()
+        {'boolean indexing': True,
+         'data-dependent shapes': True,
+         'max dimensions': 64}
+
+        """
+        return {
+            "boolean indexing": True,
+            "data-dependent shapes": True,
+            "max dimensions": 64,
+        }
+
+    def default_device(self):
+        """
+        The default device used for new NumPy arrays.
+
+        For NumPy, this always returns ``'cpu'``.
+
+        See Also
+        --------
+        __array_namespace_info__.capabilities,
+        __array_namespace_info__.default_dtypes,
+        __array_namespace_info__.dtypes,
+        __array_namespace_info__.devices
+
+        Returns
+        -------
+        device : str
+            The default device used for new NumPy arrays.
+
+        Examples
+        --------
+        >>> info = np.__array_namespace_info__()
+        >>> info.default_device()
+        'cpu'
+
+        """
+        return "cpu"
+
+    def default_dtypes(self, *, device=None):
+        """
+        The default data types used for new NumPy arrays.
+
+        For NumPy, this always returns the following dictionary:
+
+        - **"real floating"**: ``numpy.float64``
+        - **"complex floating"**: ``numpy.complex128``
+        - **"integral"**: ``numpy.intp``
+        - **"indexing"**: ``numpy.intp``
+
+        Parameters
+        ----------
+        device : str, optional
+            The device to get the default data types for. For NumPy, only
+            ``'cpu'`` is allowed.
+
+        Returns
+        -------
+        dtypes : dict
+            A dictionary describing the default data types used for new NumPy
+            arrays.
+
+        See Also
+        --------
+        __array_namespace_info__.capabilities,
+        __array_namespace_info__.default_device,
+        __array_namespace_info__.dtypes,
+        __array_namespace_info__.devices
+
+        Examples
+        --------
+        >>> info = np.__array_namespace_info__()
+        >>> info.default_dtypes()
+        {'real floating': numpy.float64,
+         'complex floating': numpy.complex128,
+         'integral': numpy.int64,
+         'indexing': numpy.int64}
+
+        """
+        if device not in ["cpu", None]:
+            raise ValueError(
+                'Device not understood. Only "cpu" is allowed, but received:'
+                f' {device}'
+            )
+        return {
+            "real floating": dtype(float64),
+            "complex floating": dtype(complex128),
+            "integral": dtype(intp),
+            "indexing": dtype(intp),
+        }
+
+    def dtypes(self, *, device=None, kind=None):
+        """
+        The array API data types supported by NumPy.
+
+        Note that this function only returns data types that are defined by
+        the array API.
+
+        Parameters
+        ----------
+        device : str, optional
+            The device to get the data types for. For NumPy, only ``'cpu'`` is
+            allowed.
+        kind : str or tuple of str, optional
+            The kind of data types to return. If ``None``, all data types are
+            returned. If a string, only data types of that kind are returned.
+            If a tuple, a dictionary containing the union of the given kinds
+            is returned. The following kinds are supported:
+
+            - ``'bool'``: boolean data types (i.e., ``bool``).
+            - ``'signed integer'``: signed integer data types (i.e., ``int8``,
+              ``int16``, ``int32``, ``int64``).
+            - ``'unsigned integer'``: unsigned integer data types (i.e.,
+              ``uint8``, ``uint16``, ``uint32``, ``uint64``).
+            - ``'integral'``: integer data types. Shorthand for ``('signed
+              integer', 'unsigned integer')``.
+            - ``'real floating'``: real-valued floating-point data types
+              (i.e., ``float32``, ``float64``).
+            - ``'complex floating'``: complex floating-point data types (i.e.,
+              ``complex64``, ``complex128``).
+            - ``'numeric'``: numeric data types. Shorthand for ``('integral',
+              'real floating', 'complex floating')``.
+
+        Returns
+        -------
+        dtypes : dict
+            A dictionary mapping the names of data types to the corresponding
+            NumPy data types.
+
+        See Also
+        --------
+        __array_namespace_info__.capabilities,
+        __array_namespace_info__.default_device,
+        __array_namespace_info__.default_dtypes,
+        __array_namespace_info__.devices
+
+        Examples
+        --------
+        >>> info = np.__array_namespace_info__()
+        >>> info.dtypes(kind='signed integer')
+        {'int8': numpy.int8,
+         'int16': numpy.int16,
+         'int32': numpy.int32,
+         'int64': numpy.int64}
+
+        """
+        if device not in ["cpu", None]:
+            raise ValueError(
+                'Device not understood. Only "cpu" is allowed, but received:'
+                f' {device}'
+            )
+        if kind is None:
+            return {
+                "bool": dtype(bool),
+                "int8": dtype(int8),
+                "int16": dtype(int16),
+                "int32": dtype(int32),
+                "int64": dtype(int64),
+                "uint8": dtype(uint8),
+                "uint16": dtype(uint16),
+                "uint32": dtype(uint32),
+                "uint64": dtype(uint64),
+                "float32": dtype(float32),
+                "float64": dtype(float64),
+                "complex64": dtype(complex64),
+                "complex128": dtype(complex128),
+            }
+        if kind == "bool":
+            return {"bool": bool}
+        if kind == "signed integer":
+            return {
+                "int8": dtype(int8),
+                "int16": dtype(int16),
+                "int32": dtype(int32),
+                "int64": dtype(int64),
+            }
+        if kind == "unsigned integer":
+            return {
+                "uint8": dtype(uint8),
+                "uint16": dtype(uint16),
+                "uint32": dtype(uint32),
+                "uint64": dtype(uint64),
+            }
+        if kind == "integral":
+            return {
+                "int8": dtype(int8),
+                "int16": dtype(int16),
+                "int32": dtype(int32),
+                "int64": dtype(int64),
+                "uint8": dtype(uint8),
+                "uint16": dtype(uint16),
+                "uint32": dtype(uint32),
+                "uint64": dtype(uint64),
+            }
+        if kind == "real floating":
+            return {
+                "float32": dtype(float32),
+                "float64": dtype(float64),
+            }
+        if kind == "complex floating":
+            return {
+                "complex64": dtype(complex64),
+                "complex128": dtype(complex128),
+            }
+        if kind == "numeric":
+            return {
+                "int8": dtype(int8),
+                "int16": dtype(int16),
+                "int32": dtype(int32),
+                "int64": dtype(int64),
+                "uint8": dtype(uint8),
+                "uint16": dtype(uint16),
+                "uint32": dtype(uint32),
+                "uint64": dtype(uint64),
+                "float32": dtype(float32),
+                "float64": dtype(float64),
+                "complex64": dtype(complex64),
+                "complex128": dtype(complex128),
+            }
+        if isinstance(kind, tuple):
+            res = {}
+            for k in kind:
+                res.update(self.dtypes(kind=k))
+            return res
+        raise ValueError(f"unsupported kind: {kind!r}")
+
+    def devices(self):
+        """
+        The devices supported by NumPy.
+
+        For NumPy, this always returns ``['cpu']``.
+
+        Returns
+        -------
+        devices : list of str
+            The devices supported by NumPy.
+
+        See Also
+        --------
+        __array_namespace_info__.capabilities,
+        __array_namespace_info__.default_device,
+        __array_namespace_info__.default_dtypes,
+        __array_namespace_info__.dtypes
+
+        Examples
+        --------
+        >>> info = np.__array_namespace_info__()
+        >>> info.devices()
+        ['cpu']
+
+        """
+        return ["cpu"]

.venv_haddock/lib/python3.12/site-packages/numpy/_array_api_info.pyi

@@ -0,0 +1,206 @@
+from typing import (
+    Literal,
+    Never,
+    TypeAlias,
+    TypedDict,
+    TypeVar,
+    final,
+    overload,
+    type_check_only,
+)
+
+import numpy as np
+
+_Device: TypeAlias = Literal["cpu"]
+_DeviceLike: TypeAlias = _Device | None
+
+_Capabilities = TypedDict(
+    "_Capabilities",
+    {
+        "boolean indexing": Literal[True],
+        "data-dependent shapes": Literal[True],
+    },
+)
+
+_DefaultDTypes = TypedDict(
+    "_DefaultDTypes",
+    {
+        "real floating": np.dtype[np.float64],
+        "complex floating": np.dtype[np.complex128],
+        "integral": np.dtype[np.intp],
+        "indexing": np.dtype[np.intp],
+    },
+)
+
+_KindBool: TypeAlias = Literal["bool"]
+_KindInt: TypeAlias = Literal["signed integer"]
+_KindUInt: TypeAlias = Literal["unsigned integer"]
+_KindInteger: TypeAlias = Literal["integral"]
+_KindFloat: TypeAlias = Literal["real floating"]
+_KindComplex: TypeAlias = Literal["complex floating"]
+_KindNumber: TypeAlias = Literal["numeric"]
+_Kind: TypeAlias = (
+    _KindBool
+    | _KindInt
+    | _KindUInt
+    | _KindInteger
+    | _KindFloat
+    | _KindComplex
+    | _KindNumber
+)
+
+_T1 = TypeVar("_T1")
+_T2 = TypeVar("_T2")
+_T3 = TypeVar("_T3")
+_Permute1: TypeAlias = _T1 | tuple[_T1]
+_Permute2: TypeAlias = tuple[_T1, _T2] | tuple[_T2, _T1]
+_Permute3: TypeAlias = (
+    tuple[_T1, _T2, _T3] | tuple[_T1, _T3, _T2]
+    | tuple[_T2, _T1, _T3] | tuple[_T2, _T3, _T1]
+    | tuple[_T3, _T1, _T2] | tuple[_T3, _T2, _T1]
+)
+
+@type_check_only
+class _DTypesBool(TypedDict):
+    bool: np.dtype[np.bool]
+
+@type_check_only
+class _DTypesInt(TypedDict):
+    int8: np.dtype[np.int8]
+    int16: np.dtype[np.int16]
+    int32: np.dtype[np.int32]
+    int64: np.dtype[np.int64]
+
+@type_check_only
+class _DTypesUInt(TypedDict):
+    uint8: np.dtype[np.uint8]
+    uint16: np.dtype[np.uint16]
+    uint32: np.dtype[np.uint32]
+    uint64: np.dtype[np.uint64]
+
+@type_check_only
+class _DTypesInteger(_DTypesInt, _DTypesUInt): ...
+
+@type_check_only
+class _DTypesFloat(TypedDict):
+    float32: np.dtype[np.float32]
+    float64: np.dtype[np.float64]
+
+@type_check_only
+class _DTypesComplex(TypedDict):
+    complex64: np.dtype[np.complex64]
+    complex128: np.dtype[np.complex128]
+
+@type_check_only
+class _DTypesNumber(_DTypesInteger, _DTypesFloat, _DTypesComplex): ...
+
+@type_check_only
+class _DTypes(_DTypesBool, _DTypesNumber): ...
+
+@type_check_only
+class _DTypesUnion(TypedDict, total=False):
+    bool: np.dtype[np.bool]
+    int8: np.dtype[np.int8]
+    int16: np.dtype[np.int16]
+    int32: np.dtype[np.int32]
+    int64: np.dtype[np.int64]
+    uint8: np.dtype[np.uint8]
+    uint16: np.dtype[np.uint16]
+    uint32: np.dtype[np.uint32]
+    uint64: np.dtype[np.uint64]
+    float32: np.dtype[np.float32]
+    float64: np.dtype[np.float64]
+    complex64: np.dtype[np.complex64]
+    complex128: np.dtype[np.complex128]
+
+_EmptyDict: TypeAlias = dict[Never, Never]
+
+@final
+class __array_namespace_info__:
+    __module__: Literal["numpy"] = "numpy"
+
+    def capabilities(self) -> _Capabilities: ...
+    def default_device(self) -> _Device: ...
+    def default_dtypes(
+        self,
+        *,
+        device: _DeviceLike = None,
+    ) -> _DefaultDTypes: ...
+    def devices(self) -> list[_Device]: ...
+
+    @overload
+    def dtypes(
+        self,
+        *,
+        device: _DeviceLike = None,
+        kind: None = None,
+    ) -> _DTypes: ...
+    @overload
+    def dtypes(
+        self,
+        *,
+        device: _DeviceLike = None,
+        kind: _Permute1[_KindBool],
+    ) -> _DTypesBool: ...
+    @overload
+    def dtypes(
+        self,
+        *,
+        device: _DeviceLike = None,
+        kind: _Permute1[_KindInt],
+    ) -> _DTypesInt: ...
+    @overload
+    def dtypes(
+        self,
+        *,
+        device: _DeviceLike = None,
+        kind: _Permute1[_KindUInt],
+    ) -> _DTypesUInt: ...
+    @overload
+    def dtypes(
+        self,
+        *,
+        device: _DeviceLike = None,
+        kind: _Permute1[_KindFloat],
+    ) -> _DTypesFloat: ...
+    @overload
+    def dtypes(
+        self,
+        *,
+        device: _DeviceLike = None,
+        kind: _Permute1[_KindComplex],
+    ) -> _DTypesComplex: ...
+    @overload
+    def dtypes(
+        self,
+        *,
+        device: _DeviceLike = None,
+        kind: (
+            _Permute1[_KindInteger]
+            | _Permute2[_KindInt, _KindUInt]
+        ),
+    ) -> _DTypesInteger: ...
+    @overload
+    def dtypes(
+        self,
+        *,
+        device: _DeviceLike = None,
+        kind: (
+            _Permute1[_KindNumber]
+            | _Permute3[_KindInteger, _KindFloat, _KindComplex]
+        ),
+    ) -> _DTypesNumber: ...
+    @overload
+    def dtypes(
+        self,
+        *,
+        device: _DeviceLike = None,
+        kind: tuple[()],
+    ) -> _EmptyDict: ...
+    @overload
+    def dtypes(
+        self,
+        *,
+        device: _DeviceLike = None,
+        kind: tuple[_Kind, ...],
+    ) -> _DTypesUnion: ...

.venv_haddock/lib/python3.12/site-packages/numpy/_configtool.py

@@ -0,0 +1,39 @@
+import argparse
+import sys
+from pathlib import Path
+
+from .lib._utils_impl import get_include
+from .version import __version__
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=__version__,
+        help="Print the version and exit.",
+    )
+    parser.add_argument(
+        "--cflags",
+        action="store_true",
+        help="Compile flag needed when using the NumPy headers.",
+    )
+    parser.add_argument(
+        "--pkgconfigdir",
+        action="store_true",
+        help=("Print the pkgconfig directory in which `numpy.pc` is stored "
+              "(useful for setting $PKG_CONFIG_PATH)."),
+    )
+    args = parser.parse_args()
+    if not sys.argv[1:]:
+        parser.print_help()
+    if args.cflags:
+        print("-I" + get_include())
+    if args.pkgconfigdir:
+        _path = Path(get_include()) / '..' / 'lib' / 'pkgconfig'
+        print(_path.resolve())
+
+
+if __name__ == "__main__":
+    main()

.venv_haddock/lib/python3.12/site-packages/numpy/_distributor_init.pyi

@@ -0,0 +1 @@
+# intentionally left blank

.venv_haddock/lib/python3.12/site-packages/numpy/_globals.py

@@ -0,0 +1,121 @@
+"""
+Module defining global singleton classes.
+
+This module raises a RuntimeError if an attempt to reload it is made. In that
+way the identities of the classes defined here are fixed and will remain so
+even if numpy itself is reloaded. In particular, a function like the following
+will still work correctly after numpy is reloaded::
+
+    def foo(arg=np._NoValue):
+        if arg is np._NoValue:
+            ...
+
+That was not the case when the singleton classes were defined in the numpy
+``__init__.py`` file. See gh-7844 for a discussion of the reload problem that
+motivated this module.
+
+"""
+import enum
+
+from ._utils import set_module as _set_module
+
+__all__ = ['_NoValue', '_CopyMode']
+
+
+# Disallow reloading this module so as to preserve the identities of the
+# classes defined here.
+if '_is_loaded' in globals():
+    raise RuntimeError('Reloading numpy._globals is not allowed')
+_is_loaded = True
+
+
+class _NoValueType:
+    """Special keyword value.
+
+    The instance of this class may be used as the default value assigned to a
+    keyword if no other obvious default (e.g., `None`) is suitable,
+
+    Common reasons for using this keyword are:
+
+    - A new keyword is added to a function, and that function forwards its
+      inputs to another function or method which can be defined outside of
+      NumPy. For example, ``np.std(x)`` calls ``x.std``, so when a ``keepdims``
+      keyword was added that could only be forwarded if the user explicitly
+      specified ``keepdims``; downstream array libraries may not have added
+      the same keyword, so adding ``x.std(..., keepdims=keepdims)``
+      unconditionally could have broken previously working code.
+    - A keyword is being deprecated, and a deprecation warning must only be
+      emitted when the keyword is used.
+
+    """
+    __instance = None
+
+    def __new__(cls):
+        # ensure that only one instance exists
+        if not cls.__instance:
+            cls.__instance = super().__new__(cls)
+        return cls.__instance
+
+    def __repr__(self):
+        return "<no value>"
+
+
+_NoValue = _NoValueType()
+
+
+@_set_module("numpy")
+class _CopyMode(enum.Enum):
+    """
+    An enumeration for the copy modes supported
+    by numpy.copy() and numpy.array(). The following three modes are supported,
+
+    - ALWAYS: This means that a deep copy of the input
+              array will always be taken.
+    - IF_NEEDED: This means that a deep copy of the input
+                 array will be taken only if necessary.
+    - NEVER: This means that the deep copy will never be taken.
+             If a copy cannot be avoided then a `ValueError` will be
+             raised.
+
+    Note that the buffer-protocol could in theory do copies.  NumPy currently
+    assumes an object exporting the buffer protocol will never do this.
+    """
+
+    ALWAYS = True
+    NEVER = False
+    IF_NEEDED = 2
+
+    def __bool__(self):
+        # For backwards compatibility
+        if self == _CopyMode.ALWAYS:
+            return True
+
+        if self == _CopyMode.NEVER:
+            return False
+
+        raise ValueError(f"{self} is neither True nor False.")
+
+
+class _SignatureDescriptor:
+    # A descriptor to store on the ufunc __dict__ that avoids definig a
+    # signature for the ufunc class/type but allows the instance to have one.
+    # This is needed because inspect.signature() chokes on normal properties
+    # (as of 3.14 at least).
+    # We could also set __signature__ on the instance but this allows deferred
+    # computation of the signature.
+    def __get__(self, obj, objtype=None):
+        # Delay import, not a critical path but need to avoid circular import.
+        from numpy._core._internal import _ufunc_inspect_signature_builder
+
+        if obj is None:
+            # could also return None, which is accepted as "not set" by
+            # inspect.signature().
+            raise AttributeError(
+                "type object 'numpy.ufunc' has no attribute '__signature__'")
+
+        # Store on the instance, after this the descriptor won't be used.
+        obj.__signature__ = _ufunc_inspect_signature_builder(obj)
+        return obj.__signature__
+
+
+_signature_descriptor = _SignatureDescriptor()

.venv_haddock/lib/python3.12/site-packages/numpy/_globals.pyi

@@ -0,0 +1,17 @@
+__all__ = ["_CopyMode", "_NoValue"]
+
+import enum
+from typing import Final, final
+
+@final
+class _CopyMode(enum.Enum):
+    ALWAYS = True
+    NEVER = False
+    IF_NEEDED = 2
+
+    def __bool__(self, /) -> bool: ...
+
+@final
+class _NoValueType: ...
+
+_NoValue: Final[_NoValueType] = ...

.venv_haddock/lib/python3.12/site-packages/numpy/_pytesttester.pyi

@@ -0,0 +1,18 @@
+from collections.abc import Iterable
+from typing import Literal as L
+
+__all__ = ["PytestTester"]
+
+class PytestTester:
+    module_name: str
+    def __init__(self, module_name: str) -> None: ...
+    def __call__(
+        self,
+        label: L["fast", "full"] = "fast",
+        verbose: int = 1,
+        extra_argv: Iterable[str] | None = None,
+        doctests: L[False] = False,
+        coverage: bool = False,
+        durations: int = -1,
+        tests: Iterable[str] | None = None,
+    ) -> bool: ...

.venv_haddock/lib/python3.12/site-packages/numpy/conftest.py

@@ -0,0 +1,248 @@
+"""
+Pytest configuration and fixtures for the Numpy test suite.
+"""
+import os
+import sys
+import tempfile
+import warnings
+from contextlib import contextmanager
+from pathlib import Path
+
+import hypothesis
+import pytest
+
+import numpy
+from numpy._core._multiarray_tests import get_fpu_mode
+from numpy.testing._private.utils import NOGIL_BUILD
+
+try:
+    from scipy_doctest.conftest import dt_config
+    HAVE_SCPDT = True
+except ModuleNotFoundError:
+    HAVE_SCPDT = False
+
+try:
+    import pytest_run_parallel  # noqa: F401
+    PARALLEL_RUN_AVALIABLE = True
+except ModuleNotFoundError:
+    PARALLEL_RUN_AVALIABLE = False
+
+_old_fpu_mode = None
+_collect_results = {}
+
+# Use a known and persistent tmpdir for hypothesis' caches, which
+# can be automatically cleared by the OS or user.
+hypothesis.configuration.set_hypothesis_home_dir(
+    os.path.join(tempfile.gettempdir(), ".hypothesis")
+)
+
+# We register two custom profiles for Numpy - for details see
+# https://hypothesis.readthedocs.io/en/latest/settings.html
+# The first is designed for our own CI runs; the latter also
+# forces determinism and is designed for use via np.test()
+hypothesis.settings.register_profile(
+    name="numpy-profile", deadline=None, print_blob=True,
+)
+hypothesis.settings.register_profile(
+    name="np.test() profile",
+    deadline=None, print_blob=True, database=None, derandomize=True,
+    suppress_health_check=list(hypothesis.HealthCheck),
+)
+# Note that the default profile is chosen based on the presence
+# of pytest.ini, but can be overridden by passing the
+# --hypothesis-profile=NAME argument to pytest.
+_pytest_ini = os.path.join(os.path.dirname(__file__), "..", "pytest.ini")
+hypothesis.settings.load_profile(
+    "numpy-profile" if os.path.isfile(_pytest_ini) else "np.test() profile"
+)
+
+# The experimentalAPI is used in _umath_tests
+os.environ["NUMPY_EXPERIMENTAL_DTYPE_API"] = "1"
+
+def pytest_configure(config):
+    config.addinivalue_line("markers",
+        "valgrind_error: Tests that are known to error under valgrind.")
+    config.addinivalue_line("markers",
+        "leaks_references: Tests that are known to leak references.")
+    config.addinivalue_line("markers",
+        "slow: Tests that are very slow.")
+    config.addinivalue_line("markers",
+        "slow_pypy: Tests that are very slow on pypy.")
+    if not PARALLEL_RUN_AVALIABLE:
+        config.addinivalue_line("markers",
+            "parallel_threads(n): run the given test function in parallel "
+            "using `n` threads.",
+        )
+        config.addinivalue_line("markers",
+            "iterations(n): run the given test function `n` times in each thread",
+        )
+        config.addinivalue_line("markers",
+            "thread_unsafe: mark the test function as single-threaded",
+        )
+
+
+def pytest_addoption(parser):
+    parser.addoption("--available-memory", action="store", default=None,
+                     help=("Set amount of memory available for running the "
+                           "test suite. This can result to tests requiring "
+                           "especially large amounts of memory to be skipped. "
+                           "Equivalent to setting environment variable "
+                           "NPY_AVAILABLE_MEM. Default: determined"
+                           "automatically."))
+
+
+gil_enabled_at_start = True
+if NOGIL_BUILD:
+    gil_enabled_at_start = sys._is_gil_enabled()
+
+
+def pytest_sessionstart(session):
+    available_mem = session.config.getoption('available_memory')
+    if available_mem is not None:
+        os.environ['NPY_AVAILABLE_MEM'] = available_mem
+
+
+def pytest_terminal_summary(terminalreporter, exitstatus, config):
+    if NOGIL_BUILD and not gil_enabled_at_start and sys._is_gil_enabled():
+        tr = terminalreporter
+        tr.ensure_newline()
+        tr.section("GIL re-enabled", sep="=", red=True, bold=True)
+        tr.line("The GIL was re-enabled at runtime during the tests.")
+        tr.line("This can happen with no test failures if the RuntimeWarning")
+        tr.line("raised by Python when this happens is filtered by a test.")
+        tr.line("")
+        tr.line("Please ensure all new C modules declare support for running")
+        tr.line("without the GIL. Any new tests that intentionally imports ")
+        tr.line("code that re-enables the GIL should do so in a subprocess.")
+        pytest.exit("GIL re-enabled during tests", returncode=1)
+
+# FIXME when yield tests are gone.
+@pytest.hookimpl(tryfirst=True)
+def pytest_itemcollected(item):
+    """
+    Check FPU precision mode was not changed during test collection.
+
+    The clumsy way we do it here is mainly necessary because numpy
+    still uses yield tests, which can execute code at test collection
+    time.
+    """
+    global _old_fpu_mode
+
+    mode = get_fpu_mode()
+
+    if _old_fpu_mode is None:
+        _old_fpu_mode = mode
+    elif mode != _old_fpu_mode:
+        _collect_results[item] = (_old_fpu_mode, mode)
+        _old_fpu_mode = mode
+
+    # mark f2py tests as thread unsafe
+    if Path(item.fspath).parent == Path(__file__).parent / 'f2py' / 'tests':
+        item.add_marker(pytest.mark.thread_unsafe(
+            reason="f2py tests are thread-unsafe"))
+
+
+@pytest.fixture(scope="function", autouse=True)
+def check_fpu_mode(request):
+    """
+    Check FPU precision mode was not changed during the test.
+    """
+    old_mode = get_fpu_mode()
+    yield
+    new_mode = get_fpu_mode()
+
+    if old_mode != new_mode:
+        raise AssertionError(f"FPU precision mode changed from {old_mode:#x} to "
+                             f"{new_mode:#x} during the test")
+
+    collect_result = _collect_results.get(request.node)
+    if collect_result is not None:
+        old_mode, new_mode = collect_result
+        raise AssertionError(f"FPU precision mode changed from {old_mode:#x} to "
+                             f"{new_mode:#x} when collecting the test")
+
+
+@pytest.fixture(autouse=True)
+def add_np(doctest_namespace):
+    doctest_namespace['np'] = numpy
+
+
+if HAVE_SCPDT:
+
+    @contextmanager
+    def warnings_errors_and_rng(test=None):
+        """Filter out the wall of DeprecationWarnings.
+        """
+        msgs = ["The numpy.linalg.linalg",
+                "The numpy.fft.helper",
+                "dep_util",
+                "pkg_resources",
+                "numpy.core.umath",
+                "msvccompiler",
+                "Deprecated call",
+                "numpy.core",
+                "Importing from numpy.matlib",
+                "This function is deprecated.",    # random_integers
+                "Data type alias 'a'",     # numpy.rec.fromfile
+                "Arrays of 2-dimensional vectors",   # matlib.cross
+                "NumPy warning suppression and assertion utilities are deprecated."
+        ]
+        msg = "|".join(msgs)
+
+        msgs_r = [
+            "invalid value encountered",
+            "divide by zero encountered"
+        ]
+        msg_r = "|".join(msgs_r)
+
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                'ignore', category=DeprecationWarning, message=msg
+            )
+            warnings.filterwarnings(
+                'ignore', category=RuntimeWarning, message=msg_r
+            )
+            yield
+
+    # find and check doctests under this context manager
+    dt_config.user_context_mgr = warnings_errors_and_rng
+
+    # numpy specific tweaks from refguide-check
+    dt_config.rndm_markers.add('#uninitialized')
+    dt_config.rndm_markers.add('# uninitialized')
+
+    # make the checker pick on mismatched dtypes
+    dt_config.strict_check = True
+
+    import doctest
+    dt_config.optionflags = doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS
+
+    # recognize the StringDType repr
+    dt_config.check_namespace['StringDType'] = numpy.dtypes.StringDType
+
+    # temporary skips
+    dt_config.skiplist = {
+        'numpy.savez',    # unclosed file
+        'numpy.matlib.savez',
+        'numpy.__array_namespace_info__',
+        'numpy.matlib.__array_namespace_info__',
+    }
+
+    # xfail problematic tutorials
+    dt_config.pytest_extra_xfail = {
+        'how-to-verify-bug.rst': '',
+        'c-info.ufunc-tutorial.rst': '',
+        'basics.interoperability.rst': 'needs pandas',
+        'basics.dispatch.rst': 'errors out in /testing/overrides.py',
+        'basics.subclassing.rst': '.. testcode:: admonitions not understood',
+        'misc.rst': 'manipulates warnings',
+    }
+
+    # ignores are for things fail doctest collection (optionals etc)
+    dt_config.pytest_extra_ignore = [
+        'numpy/distutils',
+        'numpy/_core/cversions.py',
+        'numpy/_pyinstaller',
+        'numpy/random/_examples',
+        'numpy/f2py/_backends/_distutils.py',
+    ]

.venv_haddock/lib/python3.12/site-packages/numpy/dtypes.py

@@ -0,0 +1,41 @@
+"""
+This module is home to specific dtypes related functionality and their classes.
+For more general information about dtypes, also see `numpy.dtype` and
+:ref:`arrays.dtypes`.
+
+Similar to the builtin ``types`` module, this submodule defines types (classes)
+that are not widely used directly.
+
+.. versionadded:: NumPy 1.25
+
+    The dtypes module is new in NumPy 1.25.  Previously DType classes were
+    only accessible indirectly.
+
+
+DType classes
+-------------
+
+The following are the classes of the corresponding NumPy dtype instances and
+NumPy scalar types.  The classes can be used in ``isinstance`` checks and can
+also be instantiated or used directly.  Direct use of these classes is not
+typical, since their scalar counterparts (e.g. ``np.float64``) or strings
+like ``"float64"`` can be used.
+"""
+
+# See doc/source/reference/routines.dtypes.rst for module-level docs
+
+__all__ = []
+
+
+def _add_dtype_helper(DType, alias):
+    # Function to add DTypes a bit more conveniently without channeling them
+    # through `numpy._core._multiarray_umath` namespace or similar.
+    from numpy import dtypes
+
+    setattr(dtypes, DType.__name__, DType)
+    __all__.append(DType.__name__)
+
+    if alias:
+        alias = alias.removeprefix("numpy.dtypes.")
+        setattr(dtypes, alias, DType)
+        __all__.append(alias)

.venv_haddock/lib/python3.12/site-packages/numpy/dtypes.pyi

@@ -0,0 +1,630 @@
+# ruff: noqa: ANN401
+from typing import (
+    Any,
+    Generic,
+    Literal as L,
+    LiteralString,
+    Never,
+    NoReturn,
+    Self,
+    TypeAlias,
+    final,
+    overload,
+    type_check_only,
+)
+from typing_extensions import TypeVar
+
+import numpy as np
+
+__all__ = [  # noqa: RUF022
+    "BoolDType",
+    "Int8DType",
+    "ByteDType",
+    "UInt8DType",
+    "UByteDType",
+    "Int16DType",
+    "ShortDType",
+    "UInt16DType",
+    "UShortDType",
+    "Int32DType",
+    "IntDType",
+    "UInt32DType",
+    "UIntDType",
+    "Int64DType",
+    "LongDType",
+    "UInt64DType",
+    "ULongDType",
+    "LongLongDType",
+    "ULongLongDType",
+    "Float16DType",
+    "Float32DType",
+    "Float64DType",
+    "LongDoubleDType",
+    "Complex64DType",
+    "Complex128DType",
+    "CLongDoubleDType",
+    "ObjectDType",
+    "BytesDType",
+    "StrDType",
+    "VoidDType",
+    "DateTime64DType",
+    "TimeDelta64DType",
+    "StringDType",
+]
+
+# Helper base classes (typing-only)
+
+_ScalarT_co = TypeVar("_ScalarT_co", bound=np.generic, covariant=True)
+
+@type_check_only
+class _SimpleDType(np.dtype[_ScalarT_co], Generic[_ScalarT_co]):  # type: ignore[misc]  # pyright: ignore[reportGeneralTypeIssues]
+    names: None  # pyright: ignore[reportIncompatibleVariableOverride]
+    def __new__(cls, /) -> Self: ...
+    def __getitem__(self, key: Any, /) -> NoReturn: ...
+    @property
+    def base(self) -> np.dtype[_ScalarT_co]: ...
+    @property
+    def fields(self) -> None: ...
+    @property
+    def isalignedstruct(self) -> L[False]: ...
+    @property
+    def isnative(self) -> L[True]: ...
+    @property
+    def ndim(self) -> L[0]: ...
+    @property
+    def shape(self) -> tuple[()]: ...
+    @property
+    def subdtype(self) -> None: ...
+
+@type_check_only
+class _LiteralDType(_SimpleDType[_ScalarT_co], Generic[_ScalarT_co]):  # type: ignore[misc]
+    @property
+    def flags(self) -> L[0]: ...
+    @property
+    def hasobject(self) -> L[False]: ...
+
+# Helper mixins (typing-only):
+
+_KindT_co = TypeVar("_KindT_co", bound=LiteralString, covariant=True)
+_CharT_co = TypeVar("_CharT_co", bound=LiteralString, covariant=True)
+_NumT_co = TypeVar("_NumT_co", bound=int, covariant=True)
+
+@type_check_only
+class _TypeCodes(Generic[_KindT_co, _CharT_co, _NumT_co]):
+    @final
+    @property
+    def kind(self) -> _KindT_co: ...
+    @final
+    @property
+    def char(self) -> _CharT_co: ...
+    @final
+    @property
+    def num(self) -> _NumT_co: ...
+
+@type_check_only
+class _NoOrder:
+    @final
+    @property
+    def byteorder(self) -> L["|"]: ...
+
+@type_check_only
+class _NativeOrder:
+    @final
+    @property
+    def byteorder(self) -> L["="]: ...
+
+_DataSize_co = TypeVar("_DataSize_co", bound=int, covariant=True)
+_ItemSize_co = TypeVar("_ItemSize_co", bound=int, covariant=True, default=int)
+
+@type_check_only
+class _NBit(Generic[_DataSize_co, _ItemSize_co]):
+    @final
+    @property
+    def alignment(self) -> _DataSize_co: ...
+    @final
+    @property
+    def itemsize(self) -> _ItemSize_co: ...
+
+@type_check_only
+class _8Bit(_NoOrder, _NBit[L[1], L[1]]): ...
+
+# Boolean:
+
+@final
+class BoolDType(  # type: ignore[misc]
+    _TypeCodes[L["b"], L["?"], L[0]],
+    _8Bit,
+    _LiteralDType[np.bool],
+):
+    @property
+    def name(self) -> L["bool"]: ...
+    @property
+    def str(self) -> L["|b1"]: ...
+
+# Sized integers:
+
+@final
+class Int8DType(  # type: ignore[misc]
+    _TypeCodes[L["i"], L["b"], L[1]],
+    _8Bit,
+    _LiteralDType[np.int8],
+):
+    @property
+    def name(self) -> L["int8"]: ...
+    @property
+    def str(self) -> L["|i1"]: ...
+
+@final
+class UInt8DType(  # type: ignore[misc]
+    _TypeCodes[L["u"], L["B"], L[2]],
+    _8Bit,
+    _LiteralDType[np.uint8],
+):
+    @property
+    def name(self) -> L["uint8"]: ...
+    @property
+    def str(self) -> L["|u1"]: ...
+
+@final
+class Int16DType(  # type: ignore[misc]
+    _TypeCodes[L["i"], L["h"], L[3]],
+    _NativeOrder,
+    _NBit[L[2], L[2]],
+    _LiteralDType[np.int16],
+):
+    @property
+    def name(self) -> L["int16"]: ...
+    @property
+    def str(self) -> L["<i2", ">i2"]: ...
+
+@final
+class UInt16DType(  # type: ignore[misc]
+    _TypeCodes[L["u"], L["H"], L[4]],
+    _NativeOrder,
+    _NBit[L[2], L[2]],
+    _LiteralDType[np.uint16],
+):
+    @property
+    def name(self) -> L["uint16"]: ...
+    @property
+    def str(self) -> L["<u2", ">u2"]: ...
+
+@final
+class Int32DType(  # type: ignore[misc]
+    _TypeCodes[L["i"], L["i", "l"], L[5, 7]],
+    _NativeOrder,
+    _NBit[L[4], L[4]],
+    _LiteralDType[np.int32],
+):
+    @property
+    def name(self) -> L["int32"]: ...
+    @property
+    def str(self) -> L["<i4", ">i4"]: ...
+
+@final
+class UInt32DType(  # type: ignore[misc]
+    _TypeCodes[L["u"], L["I", "L"], L[6, 8]],
+    _NativeOrder,
+    _NBit[L[4], L[4]],
+    _LiteralDType[np.uint32],
+):
+    @property
+    def name(self) -> L["uint32"]: ...
+    @property
+    def str(self) -> L["<u4", ">u4"]: ...
+
+@final
+class Int64DType(  # type: ignore[misc]
+    _TypeCodes[L["i"], L["l", "q"], L[7, 9]],
+    _NativeOrder,
+    _NBit[L[8], L[8]],
+    _LiteralDType[np.int64],
+):
+    @property
+    def name(self) -> L["int64"]: ...
+    @property
+    def str(self) -> L["<i8", ">i8"]: ...
+
+@final
+class UInt64DType(  # type: ignore[misc]
+    _TypeCodes[L["u"], L["L", "Q"], L[8, 10]],
+    _NativeOrder,
+    _NBit[L[8], L[8]],
+    _LiteralDType[np.uint64],
+):
+    @property
+    def name(self) -> L["uint64"]: ...
+    @property
+    def str(self) -> L["<u8", ">u8"]: ...
+
+# Standard C-named version/alias:
+# NOTE: Don't make these `Final`: it will break stubtest
+ByteDType = Int8DType
+UByteDType = UInt8DType
+ShortDType = Int16DType
+UShortDType = UInt16DType
+
+@final
+class IntDType(  # type: ignore[misc]
+    _TypeCodes[L["i"], L["i"], L[5]],
+    _NativeOrder,
+    _NBit[L[4], L[4]],
+    _LiteralDType[np.intc],
+):
+    @property
+    def name(self) -> L["int32"]: ...
+    @property
+    def str(self) -> L["<i4", ">i4"]: ...
+
+@final
+class UIntDType(  # type: ignore[misc]
+    _TypeCodes[L["u"], L["I"], L[6]],
+    _NativeOrder,
+    _NBit[L[4], L[4]],
+    _LiteralDType[np.uintc],
+):
+    @property
+    def name(self) -> L["uint32"]: ...
+    @property
+    def str(self) -> L["<u4", ">u4"]: ...
+
+@final
+class LongDType(  # type: ignore[misc]
+    _TypeCodes[L["i"], L["l"], L[7]],
+    _NativeOrder,
+    _NBit[L[4, 8], L[4, 8]],
+    _LiteralDType[np.long],
+):
+    @property
+    def name(self) -> L["int32", "int64"]: ...
+    @property
+    def str(self) -> L["<i4", ">i4", "<i8", ">i8"]: ...
+
+@final
+class ULongDType(  # type: ignore[misc]
+    _TypeCodes[L["u"], L["L"], L[8]],
+    _NativeOrder,
+    _NBit[L[4, 8], L[4, 8]],
+    _LiteralDType[np.ulong],
+):
+    @property
+    def name(self) -> L["uint32", "uint64"]: ...
+    @property
+    def str(self) -> L["<u4", ">u4", "<u8", ">u8"]: ...
+
+@final
+class LongLongDType(  # type: ignore[misc]
+    _TypeCodes[L["i"], L["q"], L[9]],
+    _NativeOrder,
+    _NBit[L[8], L[8]],
+    _LiteralDType[np.longlong],
+):
+    @property
+    def name(self) -> L["int64"]: ...
+    @property
+    def str(self) -> L["<i8", ">i8"]: ...
+
+@final
+class ULongLongDType(  # type: ignore[misc]
+    _TypeCodes[L["u"], L["Q"], L[10]],
+    _NativeOrder,
+    _NBit[L[8], L[8]],
+    _LiteralDType[np.ulonglong],
+):
+    @property
+    def name(self) -> L["uint64"]: ...
+    @property
+    def str(self) -> L["<u8", ">u8"]: ...
+
+# Floats:
+
+@final
+class Float16DType(  # type: ignore[misc]
+    _TypeCodes[L["f"], L["e"], L[23]],
+    _NativeOrder,
+    _NBit[L[2], L[2]],
+    _LiteralDType[np.float16],
+):
+    @property
+    def name(self) -> L["float16"]: ...
+    @property
+    def str(self) -> L["<f2", ">f2"]: ...
+
+@final
+class Float32DType(  # type: ignore[misc]
+    _TypeCodes[L["f"], L["f"], L[11]],
+    _NativeOrder,
+    _NBit[L[4], L[4]],
+    _LiteralDType[np.float32],
+):
+    @property
+    def name(self) -> L["float32"]: ...
+    @property
+    def str(self) -> L["<f4", ">f4"]: ...
+
+@final
+class Float64DType(  # type: ignore[misc]
+    _TypeCodes[L["f"], L["d"], L[12]],
+    _NativeOrder,
+    _NBit[L[8], L[8]],
+    _LiteralDType[np.float64],
+):
+    @property
+    def name(self) -> L["float64"]: ...
+    @property
+    def str(self) -> L["<f8", ">f8"]: ...
+
+@final
+class LongDoubleDType(  # type: ignore[misc]
+    _TypeCodes[L["f"], L["g"], L[13]],
+    _NativeOrder,
+    _NBit[L[8, 12, 16], L[8, 12, 16]],
+    _LiteralDType[np.longdouble],
+):
+    @property
+    def name(self) -> L["float64", "float96", "float128"]: ...
+    @property
+    def str(self) -> L["<f8", ">f8", "<f12", ">f12", "<f16", ">f16"]: ...
+
+# Complex:
+
+@final
+class Complex64DType(  # type: ignore[misc]
+    _TypeCodes[L["c"], L["F"], L[14]],
+    _NativeOrder,
+    _NBit[L[4], L[8]],
+    _LiteralDType[np.complex64],
+):
+    @property
+    def name(self) -> L["complex64"]: ...
+    @property
+    def str(self) -> L["<c8", ">c8"]: ...
+
+@final
+class Complex128DType(  # type: ignore[misc]
+    _TypeCodes[L["c"], L["D"], L[15]],
+    _NativeOrder,
+    _NBit[L[8], L[16]],
+    _LiteralDType[np.complex128],
+):
+    @property
+    def name(self) -> L["complex128"]: ...
+    @property
+    def str(self) -> L["<c16", ">c16"]: ...
+
+@final
+class CLongDoubleDType(  # type: ignore[misc]
+    _TypeCodes[L["c"], L["G"], L[16]],
+    _NativeOrder,
+    _NBit[L[8, 12, 16], L[16, 24, 32]],
+    _LiteralDType[np.clongdouble],
+):
+    @property
+    def name(self) -> L["complex128", "complex192", "complex256"]: ...
+    @property
+    def str(self) -> L["<c16", ">c16", "<c24", ">c24", "<c32", ">c32"]: ...
+
+# Python objects:
+
+@final
+class ObjectDType(  # type: ignore[misc]
+    _TypeCodes[L["O"], L["O"], L[17]],
+    _NoOrder,
+    _NBit[L[8], L[8]],
+    _SimpleDType[np.object_],
+):
+    @property
+    def hasobject(self) -> L[True]: ...
+    @property
+    def name(self) -> L["object"]: ...
+    @property
+    def str(self) -> L["|O"]: ...
+
+# Flexible:
+
+@final
+class BytesDType(  # type: ignore[misc]
+    _TypeCodes[L["S"], L["S"], L[18]],
+    _NoOrder,
+    _NBit[L[1], _ItemSize_co],
+    _SimpleDType[np.bytes_],
+    Generic[_ItemSize_co],
+):
+    def __new__(cls, size: _ItemSize_co, /) -> BytesDType[_ItemSize_co]: ...
+    @property
+    def hasobject(self) -> L[False]: ...
+    @property
+    def name(self) -> LiteralString: ...
+    @property
+    def str(self) -> LiteralString: ...
+
+@final
+class StrDType(  # type: ignore[misc]
+    _TypeCodes[L["U"], L["U"], L[19]],
+    _NativeOrder,
+    _NBit[L[4], _ItemSize_co],
+    _SimpleDType[np.str_],
+    Generic[_ItemSize_co],
+):
+    def __new__(cls, size: _ItemSize_co, /) -> StrDType[_ItemSize_co]: ...
+    @property
+    def hasobject(self) -> L[False]: ...
+    @property
+    def name(self) -> LiteralString: ...
+    @property
+    def str(self) -> LiteralString: ...
+
+@final
+class VoidDType(  # type: ignore[misc]
+    _TypeCodes[L["V"], L["V"], L[20]],
+    _NoOrder,
+    _NBit[L[1], _ItemSize_co],
+    np.dtype[np.void],  # pyright: ignore[reportGeneralTypeIssues]
+    Generic[_ItemSize_co],
+):
+    # NOTE: `VoidDType(...)` raises a `TypeError` at the moment
+    def __new__(cls, length: _ItemSize_co, /) -> NoReturn: ...
+    @property
+    def base(self) -> Self: ...
+    @property
+    def isalignedstruct(self) -> L[False]: ...
+    @property
+    def isnative(self) -> L[True]: ...
+    @property
+    def ndim(self) -> L[0]: ...
+    @property
+    def shape(self) -> tuple[()]: ...
+    @property
+    def subdtype(self) -> None: ...
+    @property
+    def name(self) -> LiteralString: ...
+    @property
+    def str(self) -> LiteralString: ...
+
+# Other:
+
+_DateUnit: TypeAlias = L["Y", "M", "W", "D"]
+_TimeUnit: TypeAlias = L["h", "m", "s", "ms", "us", "ns", "ps", "fs", "as"]
+_DateTimeUnit: TypeAlias = _DateUnit | _TimeUnit
+
+@final
+class DateTime64DType(  # type: ignore[misc]
+    _TypeCodes[L["M"], L["M"], L[21]],
+    _NativeOrder,
+    _NBit[L[8], L[8]],
+    _LiteralDType[np.datetime64],
+):
+    # NOTE: `DateTime64DType(...)` raises a `TypeError` at the moment
+    # TODO: Once implemented, don't forget the`unit: L["μs"]` overload.
+    def __new__(cls, unit: _DateTimeUnit, /) -> NoReturn: ...
+    @property
+    def name(self) -> L[
+        "datetime64",
+        "datetime64[Y]",
+        "datetime64[M]",
+        "datetime64[W]",
+        "datetime64[D]",
+        "datetime64[h]",
+        "datetime64[m]",
+        "datetime64[s]",
+        "datetime64[ms]",
+        "datetime64[us]",
+        "datetime64[ns]",
+        "datetime64[ps]",
+        "datetime64[fs]",
+        "datetime64[as]",
+    ]: ...
+    @property
+    def str(self) -> L[
+        "<M8", ">M8",
+        "<M8[Y]", ">M8[Y]",
+        "<M8[M]", ">M8[M]",
+        "<M8[W]", ">M8[W]",
+        "<M8[D]", ">M8[D]",
+        "<M8[h]", ">M8[h]",
+        "<M8[m]", ">M8[m]",
+        "<M8[s]", ">M8[s]",
+        "<M8[ms]", ">M8[ms]",
+        "<M8[us]", ">M8[us]",
+        "<M8[ns]", ">M8[ns]",
+        "<M8[ps]", ">M8[ps]",
+        "<M8[fs]", ">M8[fs]",
+        "<M8[as]", ">M8[as]",
+    ]: ...
+
+@final
+class TimeDelta64DType(  # type: ignore[misc]
+    _TypeCodes[L["m"], L["m"], L[22]],
+    _NativeOrder,
+    _NBit[L[8], L[8]],
+    _LiteralDType[np.timedelta64],
+):
+    # NOTE: `TimeDelta64DType(...)` raises a `TypeError` at the moment
+    # TODO: Once implemented, don't forget to overload on `unit: L["μs"]`.
+    def __new__(cls, unit: _DateTimeUnit, /) -> NoReturn: ...
+    @property
+    def name(self) -> L[
+        "timedelta64",
+        "timedelta64[Y]",
+        "timedelta64[M]",
+        "timedelta64[W]",
+        "timedelta64[D]",
+        "timedelta64[h]",
+        "timedelta64[m]",
+        "timedelta64[s]",
+        "timedelta64[ms]",
+        "timedelta64[us]",
+        "timedelta64[ns]",
+        "timedelta64[ps]",
+        "timedelta64[fs]",
+        "timedelta64[as]",
+    ]: ...
+    @property
+    def str(self) -> L[
+        "<m8", ">m8",
+        "<m8[Y]", ">m8[Y]",
+        "<m8[M]", ">m8[M]",
+        "<m8[W]", ">m8[W]",
+        "<m8[D]", ">m8[D]",
+        "<m8[h]", ">m8[h]",
+        "<m8[m]", ">m8[m]",
+        "<m8[s]", ">m8[s]",
+        "<m8[ms]", ">m8[ms]",
+        "<m8[us]", ">m8[us]",
+        "<m8[ns]", ">m8[ns]",
+        "<m8[ps]", ">m8[ps]",
+        "<m8[fs]", ">m8[fs]",
+        "<m8[as]", ">m8[as]",
+    ]: ...
+
+_NaObjectT_co = TypeVar("_NaObjectT_co", default=Never, covariant=True)
+
+@final
+class StringDType(  # type: ignore[misc]
+    _TypeCodes[L["T"], L["T"], L[2056]],
+    _NativeOrder,
+    _NBit[L[8], L[16]],
+    # TODO(jorenham): change once we have a string scalar type:
+    # https://github.com/numpy/numpy/issues/28165
+    np.dtype[str],  # type: ignore[type-var]  # pyright: ignore[reportGeneralTypeIssues, reportInvalidTypeArguments]
+    Generic[_NaObjectT_co],
+):
+    @property
+    def na_object(self) -> _NaObjectT_co: ...
+    @property
+    def coerce(self) -> L[True]: ...
+
+    #
+    @overload
+    def __new__(cls, /, *, coerce: bool = True) -> Self: ...
+    @overload
+    def __new__(cls, /, *, na_object: _NaObjectT_co, coerce: bool = True) -> Self: ...
+
+    #
+    def __getitem__(self, key: Never, /) -> NoReturn: ...  # type: ignore[override]  # pyright: ignore[reportIncompatibleMethodOverride]
+    @property
+    def fields(self) -> None: ...
+    @property
+    def base(self) -> Self: ...
+    @property
+    def ndim(self) -> L[0]: ...
+    @property
+    def shape(self) -> tuple[()]: ...
+
+    #
+    @property
+    def name(self) -> L["StringDType64", "StringDType128"]: ...
+    @property
+    def subdtype(self) -> None: ...
+    @property
+    def type(self) -> type[str]: ...
+    @property
+    def str(self) -> L["|T8", "|T16"]: ...
+
+    #
+    @property
+    def hasobject(self) -> L[True]: ...
+    @property
+    def isalignedstruct(self) -> L[False]: ...
+    @property
+    def isnative(self) -> L[True]: ...

.venv_haddock/lib/python3.12/site-packages/numpy/exceptions.pyi

@@ -0,0 +1,27 @@
+from typing import overload
+
+__all__ = [
+    "ComplexWarning",
+    "VisibleDeprecationWarning",
+    "ModuleDeprecationWarning",
+    "TooHardError",
+    "AxisError",
+    "DTypePromotionError",
+]
+
+class ComplexWarning(RuntimeWarning): ...
+class ModuleDeprecationWarning(DeprecationWarning): ...
+class VisibleDeprecationWarning(UserWarning): ...
+class RankWarning(RuntimeWarning): ...
+class TooHardError(RuntimeError): ...
+class DTypePromotionError(TypeError): ...
+
+class AxisError(ValueError, IndexError):
+    __slots__ = "_msg", "axis", "ndim"
+
+    axis: int | None
+    ndim: int | None
+    @overload
+    def __init__(self, axis: str, ndim: None = None, msg_prefix: None = None) -> None: ...
+    @overload
+    def __init__(self, axis: int, ndim: int, msg_prefix: str | None = None) -> None: ...

.venv_haddock/lib/python3.12/site-packages/numpy/matlib.pyi

@@ -0,0 +1,582 @@
+from typing import Any, Literal, TypeAlias, TypeVar, overload
+
+import numpy as np
+import numpy.typing as npt
+from numpy import (  # noqa: F401
+    False_,
+    ScalarType,
+    True_,
+    __array_namespace_info__,
+    __version__,
+    abs,
+    absolute,
+    acos,
+    acosh,
+    add,
+    all,
+    allclose,
+    amax,
+    amin,
+    angle,
+    any,
+    append,
+    apply_along_axis,
+    apply_over_axes,
+    arange,
+    arccos,
+    arccosh,
+    arcsin,
+    arcsinh,
+    arctan,
+    arctan2,
+    arctanh,
+    argmax,
+    argmin,
+    argpartition,
+    argsort,
+    argwhere,
+    around,
+    array,
+    array2string,
+    array_equal,
+    array_equiv,
+    array_repr,
+    array_split,
+    array_str,
+    asanyarray,
+    asarray,
+    asarray_chkfinite,
+    ascontiguousarray,
+    asfortranarray,
+    asin,
+    asinh,
+    asmatrix,
+    astype,
+    atan,
+    atan2,
+    atanh,
+    atleast_1d,
+    atleast_2d,
+    atleast_3d,
+    average,
+    bartlett,
+    base_repr,
+    binary_repr,
+    bincount,
+    bitwise_and,
+    bitwise_count,
+    bitwise_invert,
+    bitwise_left_shift,
+    bitwise_not,
+    bitwise_or,
+    bitwise_right_shift,
+    bitwise_xor,
+    blackman,
+    block,
+    bmat,
+    bool,
+    bool_,
+    broadcast,
+    broadcast_arrays,
+    broadcast_shapes,
+    broadcast_to,
+    busday_count,
+    busday_offset,
+    busdaycalendar,
+    byte,
+    bytes_,
+    c_,
+    can_cast,
+    cbrt,
+    cdouble,
+    ceil,
+    char,
+    character,
+    choose,
+    clip,
+    clongdouble,
+    column_stack,
+    common_type,
+    complex64,
+    complex128,
+    complex192,
+    complex256,
+    complexfloating,
+    compress,
+    concat,
+    concatenate,
+    conj,
+    conjugate,
+    convolve,
+    copy,
+    copysign,
+    copyto,
+    core,
+    corrcoef,
+    correlate,
+    cos,
+    cosh,
+    count_nonzero,
+    cov,
+    cross,
+    csingle,
+    ctypeslib,
+    cumprod,
+    cumsum,
+    cumulative_prod,
+    cumulative_sum,
+    datetime64,
+    datetime_as_string,
+    datetime_data,
+    deg2rad,
+    degrees,
+    delete,
+    diag,
+    diag_indices,
+    diag_indices_from,
+    diagflat,
+    diagonal,
+    diff,
+    digitize,
+    divide,
+    divmod,
+    dot,
+    double,
+    dsplit,
+    dstack,
+    dtype,
+    dtypes,
+    e,
+    ediff1d,
+    einsum,
+    einsum_path,
+    emath,
+    empty_like,
+    equal,
+    errstate,
+    euler_gamma,
+    exceptions,
+    exp,
+    exp2,
+    expand_dims,
+    expm1,
+    extract,
+    f2py,
+    fabs,
+    fft,
+    fill_diagonal,
+    finfo,
+    fix,
+    flatiter,
+    flatnonzero,
+    flexible,
+    flip,
+    fliplr,
+    flipud,
+    float16,
+    float32,
+    float64,
+    float96,
+    float128,
+    float_power,
+    floating,
+    floor,
+    floor_divide,
+    fmax,
+    fmin,
+    fmod,
+    format_float_positional,
+    format_float_scientific,
+    frexp,
+    from_dlpack,
+    frombuffer,
+    fromfile,
+    fromfunction,
+    fromiter,
+    frompyfunc,
+    fromregex,
+    fromstring,
+    full,
+    full_like,
+    gcd,
+    generic,
+    genfromtxt,
+    geomspace,
+    get_include,
+    get_printoptions,
+    getbufsize,
+    geterr,
+    geterrcall,
+    gradient,
+    greater,
+    greater_equal,
+    half,
+    hamming,
+    hanning,
+    heaviside,
+    histogram,
+    histogram2d,
+    histogram_bin_edges,
+    histogramdd,
+    hsplit,
+    hstack,
+    hypot,
+    i0,
+    iinfo,
+    imag,
+    index_exp,
+    indices,
+    inexact,
+    inf,
+    info,
+    inner,
+    insert,
+    int8,
+    int16,
+    int32,
+    int64,
+    int_,
+    intc,
+    integer,
+    interp,
+    intersect1d,
+    intp,
+    invert,
+    is_busday,
+    isclose,
+    iscomplex,
+    iscomplexobj,
+    isdtype,
+    isfinite,
+    isfortran,
+    isin,
+    isinf,
+    isnan,
+    isnat,
+    isneginf,
+    isposinf,
+    isreal,
+    isrealobj,
+    isscalar,
+    issubdtype,
+    iterable,
+    ix_,
+    kaiser,
+    kron,
+    lcm,
+    ldexp,
+    left_shift,
+    less,
+    less_equal,
+    lexsort,
+    lib,
+    linalg,
+    linspace,
+    little_endian,
+    load,
+    loadtxt,
+    log,
+    log1p,
+    log2,
+    log10,
+    logaddexp,
+    logaddexp2,
+    logical_and,
+    logical_not,
+    logical_or,
+    logical_xor,
+    logspace,
+    long,
+    longdouble,
+    longlong,
+    ma,
+    mask_indices,
+    matmul,
+    matrix,
+    matrix_transpose,
+    matvec,
+    max,
+    maximum,
+    may_share_memory,
+    mean,
+    median,
+    memmap,
+    meshgrid,
+    mgrid,
+    min,
+    min_scalar_type,
+    minimum,
+    mintypecode,
+    mod,
+    modf,
+    moveaxis,
+    multiply,
+    nan,
+    nan_to_num,
+    nanargmax,
+    nanargmin,
+    nancumprod,
+    nancumsum,
+    nanmax,
+    nanmean,
+    nanmedian,
+    nanmin,
+    nanpercentile,
+    nanprod,
+    nanquantile,
+    nanstd,
+    nansum,
+    nanvar,
+    ndarray,
+    ndenumerate,
+    ndim,
+    ndindex,
+    nditer,
+    negative,
+    nested_iters,
+    newaxis,
+    nextafter,
+    nonzero,
+    not_equal,
+    number,
+    object_,
+    ogrid,
+    ones_like,
+    outer,
+    packbits,
+    pad,
+    partition,
+    percentile,
+    permute_dims,
+    pi,
+    piecewise,
+    place,
+    poly,
+    poly1d,
+    polyadd,
+    polyder,
+    polydiv,
+    polyfit,
+    polyint,
+    polymul,
+    polynomial,
+    polysub,
+    polyval,
+    positive,
+    pow,
+    power,
+    printoptions,
+    prod,
+    promote_types,
+    ptp,
+    put,
+    put_along_axis,
+    putmask,
+    quantile,
+    r_,
+    rad2deg,
+    radians,
+    random,
+    ravel,
+    ravel_multi_index,
+    real,
+    real_if_close,
+    rec,
+    recarray,
+    reciprocal,
+    record,
+    remainder,
+    repeat,
+    require,
+    reshape,
+    resize,
+    result_type,
+    right_shift,
+    rint,
+    roll,
+    rollaxis,
+    roots,
+    rot90,
+    round,
+    row_stack,
+    s_,
+    save,
+    savetxt,
+    savez,
+    savez_compressed,
+    sctypeDict,
+    searchsorted,
+    select,
+    set_printoptions,
+    setbufsize,
+    setdiff1d,
+    seterr,
+    seterrcall,
+    setxor1d,
+    shape,
+    shares_memory,
+    short,
+    show_config,
+    show_runtime,
+    sign,
+    signbit,
+    signedinteger,
+    sin,
+    sinc,
+    single,
+    sinh,
+    size,
+    sort,
+    sort_complex,
+    spacing,
+    split,
+    sqrt,
+    square,
+    squeeze,
+    stack,
+    std,
+    str_,
+    strings,
+    subtract,
+    sum,
+    swapaxes,
+    take,
+    take_along_axis,
+    tan,
+    tanh,
+    tensordot,
+    test,
+    testing,
+    tile,
+    timedelta64,
+    trace,
+    transpose,
+    trapezoid,
+    tri,
+    tril,
+    tril_indices,
+    tril_indices_from,
+    trim_zeros,
+    triu,
+    triu_indices,
+    triu_indices_from,
+    true_divide,
+    trunc,
+    typecodes,
+    typename,
+    typing,
+    ubyte,
+    ufunc,
+    uint,
+    uint8,
+    uint16,
+    uint32,
+    uint64,
+    uintc,
+    uintp,
+    ulong,
+    ulonglong,
+    union1d,
+    unique,
+    unique_all,
+    unique_counts,
+    unique_inverse,
+    unique_values,
+    unpackbits,
+    unravel_index,
+    unsignedinteger,
+    unstack,
+    unwrap,
+    ushort,
+    vander,
+    var,
+    vdot,
+    vecdot,
+    vecmat,
+    vectorize,
+    void,
+    vsplit,
+    vstack,
+    where,
+    zeros_like,
+)
+from numpy._typing import _ArrayLike, _DTypeLike
+
+__all__ = ["rand", "randn", "repmat"]
+__all__ += np.__all__
+
+###
+
+_ScalarT = TypeVar("_ScalarT", bound=np.generic)
+_Matrix: TypeAlias = np.matrix[tuple[int, int], np.dtype[_ScalarT]]
+_Order: TypeAlias = Literal["C", "F"]
+
+###
+
+#
+@overload
+def empty(shape: int | tuple[int, int], dtype: None = None, order: _Order = "C") -> _Matrix[np.float64]: ...
+@overload
+def empty(shape: int | tuple[int, int], dtype: _DTypeLike[_ScalarT], order: _Order = "C") -> _Matrix[_ScalarT]: ...
+@overload
+def empty(shape: int | tuple[int, int], dtype: npt.DTypeLike, order: _Order = "C") -> _Matrix[Any]: ...
+
+#
+@overload
+def ones(shape: int | tuple[int, int], dtype: None = None, order: _Order = "C") -> _Matrix[np.float64]: ...
+@overload
+def ones(shape: int | tuple[int, int], dtype: _DTypeLike[_ScalarT], order: _Order = "C") -> _Matrix[_ScalarT]: ...
+@overload
+def ones(shape: int | tuple[int, int], dtype: npt.DTypeLike, order: _Order = "C") -> _Matrix[Any]: ...
+
+#
+@overload
+def zeros(shape: int | tuple[int, int], dtype: None = None, order: _Order = "C") -> _Matrix[np.float64]: ...
+@overload
+def zeros(shape: int | tuple[int, int], dtype: _DTypeLike[_ScalarT], order: _Order = "C") -> _Matrix[_ScalarT]: ...
+@overload
+def zeros(shape: int | tuple[int, int], dtype: npt.DTypeLike, order: _Order = "C") -> _Matrix[Any]: ...
+
+#
+@overload
+def identity(n: int, dtype: None = None) -> _Matrix[np.float64]: ...
+@overload
+def identity(n: int, dtype: _DTypeLike[_ScalarT]) -> _Matrix[_ScalarT]: ...
+@overload
+def identity(n: int, dtype: npt.DTypeLike | None = None) -> _Matrix[Any]: ...
+
+#
+@overload
+def eye(
+    n: int,
+    M: int | None = None,
+    k: int = 0,
+    dtype: type[np.float64] | None = ...,
+    order: _Order = "C",
+) -> _Matrix[np.float64]: ...
+@overload
+def eye(n: int, M: int | None, k: int, dtype: _DTypeLike[_ScalarT], order: _Order = "C") -> _Matrix[_ScalarT]: ...
+@overload
+def eye(n: int, M: int | None = None, k: int = 0, *, dtype: _DTypeLike[_ScalarT], order: _Order = "C") -> _Matrix[_ScalarT]: ...
+@overload
+def eye(n: int, M: int | None = None, k: int = 0, dtype: npt.DTypeLike | None = ..., order: _Order = "C") -> _Matrix[Any]: ...
+
+#
+@overload
+def rand(arg: int | tuple[()] | tuple[int] | tuple[int, int], /) -> _Matrix[np.float64]: ...
+@overload
+def rand(arg: int, /, *args: int) -> _Matrix[np.float64]: ...
+
+#
+@overload
+def randn(arg: int | tuple[()] | tuple[int] | tuple[int, int], /) -> _Matrix[np.float64]: ...
+@overload
+def randn(arg: int, /, *args: int) -> _Matrix[np.float64]: ...
+
+#
+@overload
+def repmat(a: _Matrix[_ScalarT], m: int, n: int) -> _Matrix[_ScalarT]: ...
+@overload
+def repmat(a: _ArrayLike[_ScalarT], m: int, n: int) -> npt.NDArray[_ScalarT]: ...
+@overload
+def repmat(a: npt.ArrayLike, m: int, n: int) -> npt.NDArray[Any]: ...

.venv_haddock/lib/python3.12/site-packages/numpy/version.py

@@ -0,0 +1,11 @@
+
+"""
+Module to expose more detailed version info for the installed `numpy`
+"""
+version = "2.4.4"
+__version__ = version
+full_version = version
+
+git_revision = "be93fe2960dbf49b4647f5783c66d967fb2c65b5"
+release = 'dev' not in version and '+' not in version
+short_version = version.split("+")[0]

.venv_haddock/lib/python3.12/site-packages/numpy/version.pyi

@@ -0,0 +1,9 @@
+from typing import Final, LiteralString
+
+version: Final[LiteralString] = ...
+__version__: Final[LiteralString] = ...
+full_version: Final[LiteralString] = ...
+
+git_revision: Final[LiteralString] = ...
+release: Final[bool] = ...
+short_version: Final[LiteralString] = ...

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

@@ -0,0 +1,15 @@
+# This file is dual licensed under the terms of the Apache License, Version
+# 2.0, and the BSD License. See the LICENSE file in the root of this repository
+# for complete details.
+
+__title__ = "packaging"
+__summary__ = "Core utilities for Python packages"
+__uri__ = "https://github.com/pypa/packaging"
+
+__version__ = "26.1"
+
+__author__ = "Donald Stufft and individual contributors"
+__email__ = "donald@stufft.io"
+
+__license__ = "BSD-2-Clause or Apache-2.0"
+__copyright__ = f"2014 {__author__}"

.venv_haddock/lib/python3.12/site-packages/packaging/_elffile.py

@@ -0,0 +1,108 @@
+"""
+ELF file parser.
+
+This provides a class ``ELFFile`` that parses an ELF executable in a similar
+interface to ``ZipFile``. Only the read interface is implemented.
+
+ELF header: https://refspecs.linuxfoundation.org/elf/gabi4+/ch4.eheader.html
+"""
+
+from __future__ import annotations
+
+import enum
+import os
+import struct
+from typing import IO
+
+
+class ELFInvalid(ValueError):
+    pass
+
+
+class EIClass(enum.IntEnum):
+    C32 = 1
+    C64 = 2
+
+
+class EIData(enum.IntEnum):
+    Lsb = 1
+    Msb = 2
+
+
+class EMachine(enum.IntEnum):
+    I386 = 3
+    S390 = 22
+    Arm = 40
+    X8664 = 62
+    AArc64 = 183
+
+
+class ELFFile:
+    """
+    Representation of an ELF executable.
+    """
+
+    def __init__(self, f: IO[bytes]) -> None:
+        self._f = f
+
+        try:
+            ident = self._read("16B")
+        except struct.error as e:
+            raise ELFInvalid("unable to parse identification") from e
+        magic = bytes(ident[:4])
+        if magic != b"\x7fELF":
+            raise ELFInvalid(f"invalid magic: {magic!r}")
+
+        self.capacity = ident[4]  # Format for program header (bitness).
+        self.encoding = ident[5]  # Data structure encoding (endianness).
+
+        try:
+            # e_fmt: Format for program header.
+            # p_fmt: Format for section header.
+            # p_idx: Indexes to find p_type, p_offset, and p_filesz.
+            e_fmt, self._p_fmt, self._p_idx = {
+                (1, 1): ("<HHIIIIIHHH", "<IIIIIIII", (0, 1, 4)),  # 32-bit LSB.
+                (1, 2): (">HHIIIIIHHH", ">IIIIIIII", (0, 1, 4)),  # 32-bit MSB.
+                (2, 1): ("<HHIQQQIHHH", "<IIQQQQQQ", (0, 2, 5)),  # 64-bit LSB.
+                (2, 2): (">HHIQQQIHHH", ">IIQQQQQQ", (0, 2, 5)),  # 64-bit MSB.
+            }[(self.capacity, self.encoding)]
+        except KeyError as e:
+            raise ELFInvalid(
+                f"unrecognized capacity ({self.capacity}) or encoding ({self.encoding})"
+            ) from e
+
+        try:
+            (
+                _,
+                self.machine,  # Architecture type.
+                _,
+                _,
+                self._e_phoff,  # Offset of program header.
+                _,
+                self.flags,  # Processor-specific flags.
+                _,
+                self._e_phentsize,  # Size of section.
+                self._e_phnum,  # Number of sections.
+            ) = self._read(e_fmt)
+        except struct.error as e:
+            raise ELFInvalid("unable to parse machine and section information") from e
+
+    def _read(self, fmt: str) -> tuple[int, ...]:
+        return struct.unpack(fmt, self._f.read(struct.calcsize(fmt)))
+
+    @property
+    def interpreter(self) -> str | None:
+        """
+        The path recorded in the ``PT_INTERP`` section header.
+        """
+        for index in range(self._e_phnum):
+            self._f.seek(self._e_phoff + self._e_phentsize * index)
+            try:
+                data = self._read(self._p_fmt)
+            except struct.error:
+                continue
+            if data[self._p_idx[0]] != 3:  # Not PT_INTERP.
+                continue
+            self._f.seek(data[self._p_idx[1]])
+            return os.fsdecode(self._f.read(data[self._p_idx[2]])).strip("\0")
+        return None

.venv_haddock/lib/python3.12/site-packages/packaging/_manylinux.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+import collections
+import contextlib
+import functools
+import os
+import re
+import sys
+import warnings
+from typing import Generator, Iterator, NamedTuple, Sequence
+
+from ._elffile import EIClass, EIData, ELFFile, EMachine
+
+EF_ARM_ABIMASK = 0xFF000000
+EF_ARM_ABI_VER5 = 0x05000000
+EF_ARM_ABI_FLOAT_HARD = 0x00000400
+
+_ALLOWED_ARCHS = {
+    "x86_64",
+    "aarch64",
+    "ppc64",
+    "ppc64le",
+    "s390x",
+    "loongarch64",
+    "riscv64",
+}
+
+
+# `os.PathLike` not a generic type until Python 3.9, so sticking with `str`
+# as the type for `path` until then.
+@contextlib.contextmanager
+def _parse_elf(path: str) -> Generator[ELFFile | None, None, None]:
+    try:
+        with open(path, "rb") as f:
+            yield ELFFile(f)
+    except (OSError, TypeError, ValueError):
+        yield None
+
+
+def _is_linux_armhf(executable: str) -> bool:
+    # hard-float ABI can be detected from the ELF header of the running
+    # process
+    # https://static.docs.arm.com/ihi0044/g/aaelf32.pdf
+    with _parse_elf(executable) as f:
+        return (
+            f is not None
+            and f.capacity == EIClass.C32
+            and f.encoding == EIData.Lsb
+            and f.machine == EMachine.Arm
+            and f.flags & EF_ARM_ABIMASK == EF_ARM_ABI_VER5
+            and f.flags & EF_ARM_ABI_FLOAT_HARD == EF_ARM_ABI_FLOAT_HARD
+        )
+
+
+def _is_linux_i686(executable: str) -> bool:
+    with _parse_elf(executable) as f:
+        return (
+            f is not None
+            and f.capacity == EIClass.C32
+            and f.encoding == EIData.Lsb
+            and f.machine == EMachine.I386
+        )
+
+
+def _have_compatible_abi(executable: str, archs: Sequence[str]) -> bool:
+    if "armv7l" in archs:
+        return _is_linux_armhf(executable)
+    if "i686" in archs:
+        return _is_linux_i686(executable)
+    return any(arch in _ALLOWED_ARCHS for arch in archs)
+
+
+# If glibc ever changes its major version, we need to know what the last
+# minor version was, so we can build the complete list of all versions.
+# For now, guess what the highest minor version might be, assume it will
+# be 50 for testing. Once this actually happens, update the dictionary
+# with the actual value.
+_LAST_GLIBC_MINOR: dict[int, int] = collections.defaultdict(lambda: 50)
+
+
+class _GLibCVersion(NamedTuple):
+    major: int
+    minor: int
+
+
+def _glibc_version_string_confstr() -> str | None:
+    """
+    Primary implementation of glibc_version_string using os.confstr.
+    """
+    # os.confstr is quite a bit faster than ctypes.DLL. It's also less likely
+    # to be broken or missing. This strategy is used in the standard library
+    # platform module.
+    # https://github.com/python/cpython/blob/fcf1d003bf4f0100c/Lib/platform.py#L175-L183
+    try:
+        # Should be a string like "glibc 2.17".
+        version_string: str | None = os.confstr("CS_GNU_LIBC_VERSION")
+        assert version_string is not None
+        _, version = version_string.rsplit()
+    except (AssertionError, AttributeError, OSError, ValueError):
+        # os.confstr() or CS_GNU_LIBC_VERSION not available (or a bad value)...
+        return None
+    return version
+
+
+def _glibc_version_string_ctypes() -> str | None:
+    """
+    Fallback implementation of glibc_version_string using ctypes.
+    """
+    try:
+        import ctypes  # noqa: PLC0415
+    except ImportError:
+        return None
+
+    # ctypes.CDLL(None) internally calls dlopen(NULL), and as the dlopen
+    # manpage says, "If filename is NULL, then the returned handle is for the
+    # main program". This way we can let the linker do the work to figure out
+    # which libc our process is actually using.
+    #
+    # We must also handle the special case where the executable is not a
+    # dynamically linked executable. This can occur when using musl libc,
+    # for example. In this situation, dlopen() will error, leading to an
+    # OSError. Interestingly, at least in the case of musl, there is no
+    # errno set on the OSError. The single string argument used to construct
+    # OSError comes from libc itself and is therefore not portable to
+    # hard code here. In any case, failure to call dlopen() means we
+    # can proceed, so we bail on our attempt.
+    try:
+        process_namespace = ctypes.CDLL(None)
+    except OSError:
+        return None
+
+    try:
+        gnu_get_libc_version = process_namespace.gnu_get_libc_version
+    except AttributeError:
+        # Symbol doesn't exist -> therefore, we are not linked to
+        # glibc.
+        return None
+
+    # Call gnu_get_libc_version, which returns a string like "2.5"
+    gnu_get_libc_version.restype = ctypes.c_char_p
+    version_str: str = gnu_get_libc_version()
+    # py2 / py3 compatibility:
+    if not isinstance(version_str, str):
+        version_str = version_str.decode("ascii")
+
+    return version_str
+
+
+def _glibc_version_string() -> str | None:
+    """Returns glibc version string, or None if not using glibc."""
+    return _glibc_version_string_confstr() or _glibc_version_string_ctypes()
+
+
+def _parse_glibc_version(version_str: str) -> _GLibCVersion:
+    """Parse glibc version.
+
+    We use a regexp instead of str.split because we want to discard any
+    random junk that might come after the minor version -- this might happen
+    in patched/forked versions of glibc (e.g. Linaro's version of glibc
+    uses version strings like "2.20-2014.11"). See gh-3588.
+    """
+    m = re.match(r"(?P<major>[0-9]+)\.(?P<minor>[0-9]+)", version_str)
+    if not m:
+        warnings.warn(
+            f"Expected glibc version with 2 components major.minor, got: {version_str}",
+            RuntimeWarning,
+            stacklevel=2,
+        )
+        return _GLibCVersion(-1, -1)
+    return _GLibCVersion(int(m.group("major")), int(m.group("minor")))
+
+
+@functools.lru_cache
+def _get_glibc_version() -> _GLibCVersion:
+    version_str = _glibc_version_string()
+    if version_str is None:
+        return _GLibCVersion(-1, -1)
+    return _parse_glibc_version(version_str)
+
+
+# From PEP 513, PEP 600
+def _is_compatible(arch: str, version: _GLibCVersion) -> bool:
+    sys_glibc = _get_glibc_version()
+    if sys_glibc < version:
+        return False
+    # Check for presence of _manylinux module.
+    try:
+        import _manylinux  # noqa: PLC0415
+    except ImportError:
+        return True
+    if hasattr(_manylinux, "manylinux_compatible"):
+        result = _manylinux.manylinux_compatible(version[0], version[1], arch)
+        if result is not None:
+            return bool(result)
+        return True
+    if version == _GLibCVersion(2, 5) and hasattr(_manylinux, "manylinux1_compatible"):
+        return bool(_manylinux.manylinux1_compatible)
+    if version == _GLibCVersion(2, 12) and hasattr(
+        _manylinux, "manylinux2010_compatible"
+    ):
+        return bool(_manylinux.manylinux2010_compatible)
+    if version == _GLibCVersion(2, 17) and hasattr(
+        _manylinux, "manylinux2014_compatible"
+    ):
+        return bool(_manylinux.manylinux2014_compatible)
+    return True
+
+
+_LEGACY_MANYLINUX_MAP: dict[_GLibCVersion, str] = {
+    # CentOS 7 w/ glibc 2.17 (PEP 599)
+    _GLibCVersion(2, 17): "manylinux2014",
+    # CentOS 6 w/ glibc 2.12 (PEP 571)
+    _GLibCVersion(2, 12): "manylinux2010",
+    # CentOS 5 w/ glibc 2.5 (PEP 513)
+    _GLibCVersion(2, 5): "manylinux1",
+}
+
+
+def platform_tags(archs: Sequence[str]) -> Iterator[str]:
+    """Generate manylinux tags compatible to the current platform.
+
+    :param archs: Sequence of compatible architectures.
+        The first one shall be the closest to the actual architecture and be the part of
+        platform tag after the ``linux_`` prefix, e.g. ``x86_64``.
+        The ``linux_`` prefix is assumed as a prerequisite for the current platform to
+        be manylinux-compatible.
+
+    :returns: An iterator of compatible manylinux tags.
+    """
+    if not _have_compatible_abi(sys.executable, archs):
+        return
+    # Oldest glibc to be supported regardless of architecture is (2, 17).
+    too_old_glibc2 = _GLibCVersion(2, 16)
+    if set(archs) & {"x86_64", "i686"}:
+        # On x86/i686 also oldest glibc to be supported is (2, 5).
+        too_old_glibc2 = _GLibCVersion(2, 4)
+    current_glibc = _GLibCVersion(*_get_glibc_version())
+    glibc_max_list = [current_glibc]
+    # We can assume compatibility across glibc major versions.
+    # https://sourceware.org/bugzilla/show_bug.cgi?id=24636
+    #
+    # Build a list of maximum glibc versions so that we can
+    # output the canonical list of all glibc from current_glibc
+    # down to too_old_glibc2, including all intermediary versions.
+    for glibc_major in range(current_glibc.major - 1, 1, -1):
+        glibc_minor = _LAST_GLIBC_MINOR[glibc_major]
+        glibc_max_list.append(_GLibCVersion(glibc_major, glibc_minor))
+    for arch in archs:
+        for glibc_max in glibc_max_list:
+            if glibc_max.major == too_old_glibc2.major:
+                min_minor = too_old_glibc2.minor
+            else:
+                # For other glibc major versions oldest supported is (x, 0).
+                min_minor = -1
+            for glibc_minor in range(glibc_max.minor, min_minor, -1):
+                glibc_version = _GLibCVersion(glibc_max.major, glibc_minor)
+                if _is_compatible(arch, glibc_version):
+                    yield "manylinux_{}_{}_{}".format(*glibc_version, arch)
+
+                    # Handle the legacy manylinux1, manylinux2010, manylinux2014 tags.
+                    if legacy_tag := _LEGACY_MANYLINUX_MAP.get(glibc_version):
+                        yield f"{legacy_tag}_{arch}"

.venv_haddock/lib/python3.12/site-packages/packaging/_parser.py

@@ -0,0 +1,365 @@
+"""Handwritten parser of dependency specifiers.
+
+The docstring for each __parse_* function contains EBNF-inspired grammar representing
+the implementation.
+"""
+
+from __future__ import annotations
+
+import ast
+from typing import List, Literal, NamedTuple, Sequence, Tuple, Union
+
+from ._tokenizer import DEFAULT_RULES, Tokenizer
+
+
+class Node:
+    __slots__ = ("value",)
+
+    def __init__(self, value: str) -> None:
+        self.value = value
+
+    def __str__(self) -> str:
+        return self.value
+
+    def __repr__(self) -> str:
+        return f"<{self.__class__.__name__}({self.value!r})>"
+
+    def serialize(self) -> str:
+        raise NotImplementedError
+
+
+class Variable(Node):
+    __slots__ = ()
+
+    def serialize(self) -> str:
+        return str(self)
+
+
+class Value(Node):
+    __slots__ = ()
+
+    def serialize(self) -> str:
+        return f'"{self}"'
+
+
+class Op(Node):
+    __slots__ = ()
+
+    def serialize(self) -> str:
+        return str(self)
+
+
+MarkerLogical = Literal["and", "or"]
+MarkerVar = Union[Variable, Value]
+MarkerItem = Tuple[MarkerVar, Op, MarkerVar]
+MarkerAtom = Union[MarkerItem, Sequence["MarkerAtom"]]
+MarkerList = List[Union["MarkerList", MarkerAtom, MarkerLogical]]
+
+
+class ParsedRequirement(NamedTuple):
+    name: str
+    url: str
+    extras: list[str]
+    specifier: str
+    marker: MarkerList | None
+
+
+# --------------------------------------------------------------------------------------
+# Recursive descent parser for dependency specifier
+# --------------------------------------------------------------------------------------
+def parse_requirement(source: str) -> ParsedRequirement:
+    return _parse_requirement(Tokenizer(source, rules=DEFAULT_RULES))
+
+
+def _parse_requirement(tokenizer: Tokenizer) -> ParsedRequirement:
+    """
+    requirement = WS? IDENTIFIER WS? extras WS? requirement_details
+    """
+    tokenizer.consume("WS")
+
+    name_token = tokenizer.expect(
+        "IDENTIFIER", expected="package name at the start of dependency specifier"
+    )
+    name = name_token.text
+    tokenizer.consume("WS")
+
+    extras = _parse_extras(tokenizer)
+    tokenizer.consume("WS")
+
+    url, specifier, marker = _parse_requirement_details(tokenizer)
+    tokenizer.expect("END", expected="end of dependency specifier")
+
+    return ParsedRequirement(name, url, extras, specifier, marker)
+
+
+def _parse_requirement_details(
+    tokenizer: Tokenizer,
+) -> tuple[str, str, MarkerList | None]:
+    """
+    requirement_details = AT URL (WS requirement_marker?)?
+                        | specifier WS? (requirement_marker)?
+    """
+
+    specifier = ""
+    url = ""
+    marker = None
+
+    if tokenizer.check("AT"):
+        tokenizer.read()
+        tokenizer.consume("WS")
+
+        url_start = tokenizer.position
+        url = tokenizer.expect("URL", expected="URL after @").text
+        if tokenizer.check("END", peek=True):
+            return (url, specifier, marker)
+
+        tokenizer.expect("WS", expected="whitespace after URL")
+
+        # The input might end after whitespace.
+        if tokenizer.check("END", peek=True):
+            return (url, specifier, marker)
+
+        marker = _parse_requirement_marker(
+            tokenizer,
+            span_start=url_start,
+            expected="semicolon (after URL and whitespace)",
+        )
+    else:
+        specifier_start = tokenizer.position
+        specifier = _parse_specifier(tokenizer)
+        tokenizer.consume("WS")
+
+        if tokenizer.check("END", peek=True):
+            return (url, specifier, marker)
+
+        marker = _parse_requirement_marker(
+            tokenizer,
+            span_start=specifier_start,
+            expected=(
+                "comma (within version specifier), semicolon (after version specifier)"
+                if specifier
+                else "semicolon (after name with no version specifier)"
+            ),
+        )
+
+    return (url, specifier, marker)
+
+
+def _parse_requirement_marker(
+    tokenizer: Tokenizer, *, span_start: int, expected: str
+) -> MarkerList:
+    """
+    requirement_marker = SEMICOLON marker WS?
+    """
+
+    if not tokenizer.check("SEMICOLON"):
+        tokenizer.raise_syntax_error(
+            f"Expected {expected} or end",
+            span_start=span_start,
+            span_end=None,
+        )
+    tokenizer.read()
+
+    marker = _parse_marker(tokenizer)
+    tokenizer.consume("WS")
+
+    return marker
+
+
+def _parse_extras(tokenizer: Tokenizer) -> list[str]:
+    """
+    extras = (LEFT_BRACKET wsp* extras_list? wsp* RIGHT_BRACKET)?
+    """
+    if not tokenizer.check("LEFT_BRACKET", peek=True):
+        return []
+
+    with tokenizer.enclosing_tokens(
+        "LEFT_BRACKET",
+        "RIGHT_BRACKET",
+        around="extras",
+    ):
+        tokenizer.consume("WS")
+        extras = _parse_extras_list(tokenizer)
+        tokenizer.consume("WS")
+
+    return extras
+
+
+def _parse_extras_list(tokenizer: Tokenizer) -> list[str]:
+    """
+    extras_list = identifier (wsp* ',' wsp* identifier)*
+    """
+    extras: list[str] = []
+
+    if not tokenizer.check("IDENTIFIER"):
+        return extras
+
+    extras.append(tokenizer.read().text)
+
+    while True:
+        tokenizer.consume("WS")
+        if tokenizer.check("IDENTIFIER", peek=True):
+            tokenizer.raise_syntax_error("Expected comma between extra names")
+        elif not tokenizer.check("COMMA"):
+            break
+
+        tokenizer.read()
+        tokenizer.consume("WS")
+
+        extra_token = tokenizer.expect("IDENTIFIER", expected="extra name after comma")
+        extras.append(extra_token.text)
+
+    return extras
+
+
+def _parse_specifier(tokenizer: Tokenizer) -> str:
+    """
+    specifier = LEFT_PARENTHESIS WS? version_many WS? RIGHT_PARENTHESIS
+              | WS? version_many WS?
+    """
+    with tokenizer.enclosing_tokens(
+        "LEFT_PARENTHESIS",
+        "RIGHT_PARENTHESIS",
+        around="version specifier",
+    ):
+        tokenizer.consume("WS")
+        parsed_specifiers = _parse_version_many(tokenizer)
+        tokenizer.consume("WS")
+
+    return parsed_specifiers
+
+
+def _parse_version_many(tokenizer: Tokenizer) -> str:
+    """
+    version_many = (SPECIFIER (WS? COMMA WS? SPECIFIER)*)?
+    """
+    parsed_specifiers = ""
+    while tokenizer.check("SPECIFIER"):
+        span_start = tokenizer.position
+        parsed_specifiers += tokenizer.read().text
+        if tokenizer.check("VERSION_PREFIX_TRAIL", peek=True):
+            tokenizer.raise_syntax_error(
+                ".* suffix can only be used with `==` or `!=` operators",
+                span_start=span_start,
+                span_end=tokenizer.position + 1,
+            )
+        if tokenizer.check("VERSION_LOCAL_LABEL_TRAIL", peek=True):
+            tokenizer.raise_syntax_error(
+                "Local version label can only be used with `==` or `!=` operators",
+                span_start=span_start,
+                span_end=tokenizer.position,
+            )
+        tokenizer.consume("WS")
+        if not tokenizer.check("COMMA"):
+            break
+        parsed_specifiers += tokenizer.read().text
+        tokenizer.consume("WS")
+
+    return parsed_specifiers
+
+
+# --------------------------------------------------------------------------------------
+# Recursive descent parser for marker expression
+# --------------------------------------------------------------------------------------
+def parse_marker(source: str) -> MarkerList:
+    return _parse_full_marker(Tokenizer(source, rules=DEFAULT_RULES))
+
+
+def _parse_full_marker(tokenizer: Tokenizer) -> MarkerList:
+    retval = _parse_marker(tokenizer)
+    tokenizer.expect("END", expected="end of marker expression")
+    return retval
+
+
+def _parse_marker(tokenizer: Tokenizer) -> MarkerList:
+    """
+    marker = marker_atom (BOOLOP marker_atom)+
+    """
+    expression = [_parse_marker_atom(tokenizer)]
+    while tokenizer.check("BOOLOP"):
+        token = tokenizer.read()
+        expr_right = _parse_marker_atom(tokenizer)
+        expression.extend((token.text, expr_right))
+    return expression
+
+
+def _parse_marker_atom(tokenizer: Tokenizer) -> MarkerAtom:
+    """
+    marker_atom = WS? LEFT_PARENTHESIS WS? marker WS? RIGHT_PARENTHESIS WS?
+                | WS? marker_item WS?
+    """
+
+    tokenizer.consume("WS")
+    if tokenizer.check("LEFT_PARENTHESIS", peek=True):
+        with tokenizer.enclosing_tokens(
+            "LEFT_PARENTHESIS",
+            "RIGHT_PARENTHESIS",
+            around="marker expression",
+        ):
+            tokenizer.consume("WS")
+            marker: MarkerAtom = _parse_marker(tokenizer)
+            tokenizer.consume("WS")
+    else:
+        marker = _parse_marker_item(tokenizer)
+    tokenizer.consume("WS")
+    return marker
+
+
+def _parse_marker_item(tokenizer: Tokenizer) -> MarkerItem:
+    """
+    marker_item = WS? marker_var WS? marker_op WS? marker_var WS?
+    """
+    tokenizer.consume("WS")
+    marker_var_left = _parse_marker_var(tokenizer)
+    tokenizer.consume("WS")
+    marker_op = _parse_marker_op(tokenizer)
+    tokenizer.consume("WS")
+    marker_var_right = _parse_marker_var(tokenizer)
+    tokenizer.consume("WS")
+    return (marker_var_left, marker_op, marker_var_right)
+
+
+def _parse_marker_var(tokenizer: Tokenizer) -> MarkerVar:  # noqa: RET503
+    """
+    marker_var = VARIABLE | QUOTED_STRING
+    """
+    if tokenizer.check("VARIABLE"):
+        return process_env_var(tokenizer.read().text.replace(".", "_"))
+    elif tokenizer.check("QUOTED_STRING"):
+        return process_python_str(tokenizer.read().text)
+    else:
+        tokenizer.raise_syntax_error(
+            message="Expected a marker variable or quoted string"
+        )
+
+
+def process_env_var(env_var: str) -> Variable:
+    if env_var in ("platform_python_implementation", "python_implementation"):
+        return Variable("platform_python_implementation")
+    else:
+        return Variable(env_var)
+
+
+def process_python_str(python_str: str) -> Value:
+    value = ast.literal_eval(python_str)
+    return Value(str(value))
+
+
+def _parse_marker_op(tokenizer: Tokenizer) -> Op:
+    """
+    marker_op = IN | NOT IN | OP
+    """
+    if tokenizer.check("IN"):
+        tokenizer.read()
+        return Op("in")
+    elif tokenizer.check("NOT"):
+        tokenizer.read()
+        tokenizer.expect("WS", expected="whitespace after 'not'")
+        tokenizer.expect("IN", expected="'in' after 'not'")
+        return Op("not in")
+    elif tokenizer.check("OP"):
+        return Op(tokenizer.read().text)
+    else:
+        return tokenizer.raise_syntax_error(
+            "Expected marker operator, one of <=, <, !=, ==, >=, >, ~=, ===, in, not in"
+        )