Add files using upload-large-folder tool

.gitattributes

@@ -85,3 +85,4 @@ lib/python3.10/site-packages/av/error.cpython-310-x86_64-linux-gnu.so filter=lfs
 lib/python3.10/site-packages/av/dictionary.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 lib/python3.10/site-packages/av/container/core.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
 lib/python3.10/site-packages/av/container/pyio.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text
+lib/python3.10/site-packages/av/container/input.cpython-310-x86_64-linux-gnu.so filter=lfs diff=lfs merge=lfs -text

lib/python3.10/site-packages/av/container/input.cpython-310-x86_64-linux-gnu.so

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d76c55337da2ca9a297456b0de0eacf4cce96faf4447eb4b6ccabab56b077a3d
+size 864209

lib/python3.10/site-packages/babel/localtime/__init__.py

@@ -0,0 +1,43 @@
+"""
+    babel.localtime
+    ~~~~~~~~~~~~~~~
+
+    Babel specific fork of tzlocal to determine the local timezone
+    of the system.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+
+import datetime
+import sys
+
+if sys.platform == 'win32':
+    from babel.localtime._win32 import _get_localzone
+else:
+    from babel.localtime._unix import _get_localzone
+
+
+# TODO(3.0): the offset constants are not part of the public API
+#            and should be removed
+from babel.localtime._fallback import (
+    DSTDIFF,  # noqa: F401
+    DSTOFFSET,  # noqa: F401
+    STDOFFSET,  # noqa: F401
+    ZERO,  # noqa: F401
+    _FallbackLocalTimezone,
+)
+
+
+def get_localzone() -> datetime.tzinfo:
+    """Returns the current underlying local timezone object.
+    Generally this function does not need to be used, it's a
+    better idea to use the :data:`LOCALTZ` singleton instead.
+    """
+    return _get_localzone()
+
+
+try:
+    LOCALTZ = get_localzone()
+except LookupError:
+    LOCALTZ = _FallbackLocalTimezone()

lib/python3.10/site-packages/babel/localtime/_fallback.py

@@ -0,0 +1,44 @@
+"""
+    babel.localtime._fallback
+    ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    Emulated fallback local timezone when all else fails.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+
+import datetime
+import time
+
+STDOFFSET = datetime.timedelta(seconds=-time.timezone)
+DSTOFFSET = datetime.timedelta(seconds=-time.altzone) if time.daylight else STDOFFSET
+
+DSTDIFF = DSTOFFSET - STDOFFSET
+ZERO = datetime.timedelta(0)
+
+
+class _FallbackLocalTimezone(datetime.tzinfo):
+
+    def utcoffset(self, dt: datetime.datetime) -> datetime.timedelta:
+        if self._isdst(dt):
+            return DSTOFFSET
+        else:
+            return STDOFFSET
+
+    def dst(self, dt: datetime.datetime) -> datetime.timedelta:
+        if self._isdst(dt):
+            return DSTDIFF
+        else:
+            return ZERO
+
+    def tzname(self, dt: datetime.datetime) -> str:
+        return time.tzname[self._isdst(dt)]
+
+    def _isdst(self, dt: datetime.datetime) -> bool:
+        tt = (dt.year, dt.month, dt.day,
+              dt.hour, dt.minute, dt.second,
+              dt.weekday(), 0, -1)
+        stamp = time.mktime(tt)
+        tt = time.localtime(stamp)
+        return tt.tm_isdst > 0

lib/python3.10/site-packages/babel/localtime/_helpers.py

@@ -0,0 +1,57 @@
+try:
+    import pytz
+except ModuleNotFoundError:
+    pytz = None
+
+try:
+    import zoneinfo
+except ModuleNotFoundError:
+    zoneinfo = None
+
+
+def _get_tzinfo(tzenv: str):
+    """Get the tzinfo from `zoneinfo` or `pytz`
+
+    :param tzenv: timezone in the form of Continent/City
+    :return: tzinfo object or None if not found
+    """
+    if pytz:
+        try:
+            return pytz.timezone(tzenv)
+        except pytz.UnknownTimeZoneError:
+            pass
+    else:
+        try:
+            return zoneinfo.ZoneInfo(tzenv)
+        except ValueError as ve:
+            # This is somewhat hacky, but since _validate_tzfile_path() doesn't
+            # raise a specific error type, we'll need to check the message to be
+            # one we know to be from that function.
+            # If so, we pretend it meant that the TZ didn't exist, for the benefit
+            # of `babel.localtime` catching the `LookupError` raised by
+            # `_get_tzinfo_or_raise()`.
+            # See https://github.com/python-babel/babel/issues/1092
+            if str(ve).startswith("ZoneInfo keys "):
+                return None
+        except zoneinfo.ZoneInfoNotFoundError:
+            pass
+
+    return None
+
+
+def _get_tzinfo_or_raise(tzenv: str):
+    tzinfo = _get_tzinfo(tzenv)
+    if tzinfo is None:
+        raise LookupError(
+            f"Can not find timezone {tzenv}. \n"
+            "Timezone names are generally in the form `Continent/City`.",
+        )
+    return tzinfo
+
+
+def _get_tzinfo_from_file(tzfilename: str):
+    with open(tzfilename, 'rb') as tzfile:
+        if pytz:
+            return pytz.tzfile.build_tzinfo('local', tzfile)
+        else:
+            return zoneinfo.ZoneInfo.from_file(tzfile)

lib/python3.10/site-packages/babel/localtime/_unix.py

@@ -0,0 +1,104 @@
+import datetime
+import os
+import re
+
+from babel.localtime._helpers import (
+    _get_tzinfo,
+    _get_tzinfo_from_file,
+    _get_tzinfo_or_raise,
+)
+
+
+def _tz_from_env(tzenv: str) -> datetime.tzinfo:
+    if tzenv[0] == ':':
+        tzenv = tzenv[1:]
+
+    # TZ specifies a file
+    if os.path.exists(tzenv):
+        return _get_tzinfo_from_file(tzenv)
+
+    # TZ specifies a zoneinfo zone.
+    return _get_tzinfo_or_raise(tzenv)
+
+
+def _get_localzone(_root: str = '/') -> datetime.tzinfo:
+    """Tries to find the local timezone configuration.
+    This method prefers finding the timezone name and passing that to
+    zoneinfo or pytz, over passing in the localtime file, as in the later
+    case the zoneinfo name is unknown.
+    The parameter _root makes the function look for files like /etc/localtime
+    beneath the _root directory. This is primarily used by the tests.
+    In normal usage you call the function without parameters.
+    """
+
+    tzenv = os.environ.get('TZ')
+    if tzenv:
+        return _tz_from_env(tzenv)
+
+    # This is actually a pretty reliable way to test for the local time
+    # zone on operating systems like OS X.  On OS X especially this is the
+    # only one that actually works.
+    try:
+        link_dst = os.readlink('/etc/localtime')
+    except OSError:
+        pass
+    else:
+        pos = link_dst.find('/zoneinfo/')
+        if pos >= 0:
+            # On occasion, the `/etc/localtime` symlink has a double slash, e.g.
+            # "/usr/share/zoneinfo//UTC", which would make `zoneinfo.ZoneInfo`
+            # complain (no absolute paths allowed), and we'd end up returning
+            # `None` (as a fix for #1092).
+            # Instead, let's just "fix" the double slash symlink by stripping
+            # leading slashes before passing the assumed zone name forward.
+            zone_name = link_dst[pos + 10:].lstrip("/")
+            tzinfo = _get_tzinfo(zone_name)
+            if tzinfo is not None:
+                return tzinfo
+
+    # Now look for distribution specific configuration files
+    # that contain the timezone name.
+    tzpath = os.path.join(_root, 'etc/timezone')
+    if os.path.exists(tzpath):
+        with open(tzpath, 'rb') as tzfile:
+            data = tzfile.read()
+
+            # Issue #3 in tzlocal was that /etc/timezone was a zoneinfo file.
+            # That's a misconfiguration, but we need to handle it gracefully:
+            if data[:5] != b'TZif2':
+                etctz = data.strip().decode()
+                # Get rid of host definitions and comments:
+                if ' ' in etctz:
+                    etctz, dummy = etctz.split(' ', 1)
+                if '#' in etctz:
+                    etctz, dummy = etctz.split('#', 1)
+
+                return _get_tzinfo_or_raise(etctz.replace(' ', '_'))
+
+    # CentOS has a ZONE setting in /etc/sysconfig/clock,
+    # OpenSUSE has a TIMEZONE setting in /etc/sysconfig/clock and
+    # Gentoo has a TIMEZONE setting in /etc/conf.d/clock
+    # We look through these files for a timezone:
+    timezone_re = re.compile(r'\s*(TIME)?ZONE\s*=\s*"(?P<etctz>.+)"')
+
+    for filename in ('etc/sysconfig/clock', 'etc/conf.d/clock'):
+        tzpath = os.path.join(_root, filename)
+        if not os.path.exists(tzpath):
+            continue
+        with open(tzpath) as tzfile:
+            for line in tzfile:
+                match = timezone_re.match(line)
+                if match is not None:
+                    # We found a timezone
+                    etctz = match.group("etctz")
+                    return _get_tzinfo_or_raise(etctz.replace(' ', '_'))
+
+    # No explicit setting existed. Use localtime
+    for filename in ('etc/localtime', 'usr/local/etc/localtime'):
+        tzpath = os.path.join(_root, filename)
+
+        if not os.path.exists(tzpath):
+            continue
+        return _get_tzinfo_from_file(tzpath)
+
+    raise LookupError('Can not find any timezone configuration')

lib/python3.10/site-packages/babel/localtime/_win32.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+try:
+    import winreg
+except ImportError:
+    winreg = None
+
+import datetime
+from typing import Any, Dict, cast
+
+from babel.core import get_global
+from babel.localtime._helpers import _get_tzinfo_or_raise
+
+# When building the cldr data on windows this module gets imported.
+# Because at that point there is no global.dat yet this call will
+# fail.  We want to catch it down in that case then and just assume
+# the mapping was empty.
+try:
+    tz_names: dict[str, str] = cast(Dict[str, str], get_global('windows_zone_mapping'))
+except RuntimeError:
+    tz_names = {}
+
+
+def valuestodict(key) -> dict[str, Any]:
+    """Convert a registry key's values to a dictionary."""
+    dict = {}
+    size = winreg.QueryInfoKey(key)[1]
+    for i in range(size):
+        data = winreg.EnumValue(key, i)
+        dict[data[0]] = data[1]
+    return dict
+
+
+def get_localzone_name() -> str:
+    # Windows is special. It has unique time zone names (in several
+    # meanings of the word) available, but unfortunately, they can be
+    # translated to the language of the operating system, so we need to
+    # do a backwards lookup, by going through all time zones and see which
+    # one matches.
+    handle = winreg.ConnectRegistry(None, winreg.HKEY_LOCAL_MACHINE)
+
+    TZLOCALKEYNAME = r'SYSTEM\CurrentControlSet\Control\TimeZoneInformation'
+    localtz = winreg.OpenKey(handle, TZLOCALKEYNAME)
+    keyvalues = valuestodict(localtz)
+    localtz.Close()
+    if 'TimeZoneKeyName' in keyvalues:
+        # Windows 7 (and Vista?)
+
+        # For some reason this returns a string with loads of NUL bytes at
+        # least on some systems. I don't know if this is a bug somewhere, I
+        # just work around it.
+        tzkeyname = keyvalues['TimeZoneKeyName'].split('\x00', 1)[0]
+    else:
+        # Windows 2000 or XP
+
+        # This is the localized name:
+        tzwin = keyvalues['StandardName']
+
+        # Open the list of timezones to look up the real name:
+        TZKEYNAME = r'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time Zones'
+        tzkey = winreg.OpenKey(handle, TZKEYNAME)
+
+        # Now, match this value to Time Zone information
+        tzkeyname = None
+        for i in range(winreg.QueryInfoKey(tzkey)[0]):
+            subkey = winreg.EnumKey(tzkey, i)
+            sub = winreg.OpenKey(tzkey, subkey)
+            data = valuestodict(sub)
+            sub.Close()
+            if data.get('Std', None) == tzwin:
+                tzkeyname = subkey
+                break
+
+        tzkey.Close()
+        handle.Close()
+
+    if tzkeyname is None:
+        raise LookupError('Can not find Windows timezone configuration')
+
+    timezone = tz_names.get(tzkeyname)
+    if timezone is None:
+        # Nope, that didn't work. Try adding 'Standard Time',
+        # it seems to work a lot of times:
+        timezone = tz_names.get(f"{tzkeyname} Standard Time")
+
+    # Return what we have.
+    if timezone is None:
+        raise LookupError(f"Can not find timezone {tzkeyname}")
+
+    return timezone
+
+
+def _get_localzone() -> datetime.tzinfo:
+    if winreg is None:
+        raise LookupError(
+            'Runtime support not available')
+
+    return _get_tzinfo_or_raise(get_localzone_name())

lib/python3.10/site-packages/babel/messages/__init__.py

@@ -0,0 +1,21 @@
+"""
+    babel.messages
+    ~~~~~~~~~~~~~~
+
+    Support for ``gettext`` message catalogs.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from babel.messages.catalog import (
+    Catalog,
+    Message,
+    TranslationError,
+)
+
+__all__ = [
+    "Catalog",
+    "Message",
+    "TranslationError",
+]

lib/python3.10/site-packages/babel/messages/_compat.py

@@ -0,0 +1,34 @@
+import sys
+from functools import partial
+
+
+def find_entrypoints(group_name: str):
+    """
+    Find entrypoints of a given group using either `importlib.metadata` or the
+    older `pkg_resources` mechanism.
+
+    Yields tuples of the entrypoint name and a callable function that will
+    load the actual entrypoint.
+    """
+    if sys.version_info >= (3, 10):
+        # "Changed in version 3.10: importlib.metadata is no longer provisional."
+        try:
+            from importlib.metadata import entry_points
+        except ImportError:
+            pass
+        else:
+            eps = entry_points(group=group_name)
+            # Only do this if this implementation of `importlib.metadata` is
+            # modern enough to not return a dict.
+            if not isinstance(eps, dict):
+                for entry_point in eps:
+                    yield (entry_point.name, entry_point.load)
+                return
+
+    try:
+        from pkg_resources import working_set
+    except ImportError:
+        pass
+    else:
+        for entry_point in working_set.iter_entry_points(group_name):
+            yield (entry_point.name, partial(entry_point.load, require=True))

lib/python3.10/site-packages/babel/messages/catalog.py

@@ -0,0 +1,1000 @@
+"""
+    babel.messages.catalog
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Data structures for message catalogs.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from __future__ import annotations
+
+import datetime
+import re
+from collections.abc import Iterable, Iterator
+from copy import copy
+from difflib import SequenceMatcher
+from email import message_from_string
+from heapq import nlargest
+from string import Formatter
+from typing import TYPE_CHECKING
+
+from babel import __version__ as VERSION
+from babel.core import Locale, UnknownLocaleError
+from babel.dates import format_datetime
+from babel.messages.plurals import get_plural
+from babel.util import LOCALTZ, FixedOffsetTimezone, _cmp, distinct
+
+if TYPE_CHECKING:
+    from typing_extensions import TypeAlias
+
+    _MessageID: TypeAlias = str | tuple[str, ...] | list[str]
+
+__all__ = [
+    'DEFAULT_HEADER',
+    'PYTHON_FORMAT',
+    'Catalog',
+    'Message',
+    'TranslationError',
+]
+
+
+def get_close_matches(word, possibilities, n=3, cutoff=0.6):
+    """A modified version of ``difflib.get_close_matches``.
+
+    It just passes ``autojunk=False`` to the ``SequenceMatcher``, to work
+    around https://github.com/python/cpython/issues/90825.
+    """
+    if not n > 0:  # pragma: no cover
+        raise ValueError(f"n must be > 0: {n!r}")
+    if not 0.0 <= cutoff <= 1.0:  # pragma: no cover
+        raise ValueError(f"cutoff must be in [0.0, 1.0]: {cutoff!r}")
+    result = []
+    s = SequenceMatcher(autojunk=False)  # only line changed from difflib.py
+    s.set_seq2(word)
+    for x in possibilities:
+        s.set_seq1(x)
+        if s.real_quick_ratio() >= cutoff and \
+           s.quick_ratio() >= cutoff and \
+           s.ratio() >= cutoff:
+            result.append((s.ratio(), x))
+
+    # Move the best scorers to head of list
+    result = nlargest(n, result)
+    # Strip scores for the best n matches
+    return [x for score, x in result]
+
+
+PYTHON_FORMAT = re.compile(r'''
+    \%
+        (?:\(([\w]*)\))?
+        (
+            [-#0\ +]?(?:\*|[\d]+)?
+            (?:\.(?:\*|[\d]+))?
+            [hlL]?
+        )
+        ([diouxXeEfFgGcrs%])
+''', re.VERBOSE)
+
+
+def _has_python_brace_format(string: str) -> bool:
+    if "{" not in string:
+        return False
+    fmt = Formatter()
+    try:
+        # `fmt.parse` returns 3-or-4-tuples of the form
+        # `(literal_text, field_name, format_spec, conversion)`;
+        # if `field_name` is set, this smells like brace format
+        field_name_seen = False
+        for t in fmt.parse(string):
+            if t[1] is not None:
+                field_name_seen = True
+                # We cannot break here, as we need to consume the whole string
+                # to ensure that it is a valid format string.
+    except ValueError:
+        return False
+    return field_name_seen
+
+
+def _parse_datetime_header(value: str) -> datetime.datetime:
+    match = re.match(r'^(?P<datetime>.*?)(?P<tzoffset>[+-]\d{4})?$', value)
+
+    dt = datetime.datetime.strptime(match.group('datetime'), '%Y-%m-%d %H:%M')
+
+    # Separate the offset into a sign component, hours, and # minutes
+    tzoffset = match.group('tzoffset')
+    if tzoffset is not None:
+        plus_minus_s, rest = tzoffset[0], tzoffset[1:]
+        hours_offset_s, mins_offset_s = rest[:2], rest[2:]
+
+        # Make them all integers
+        plus_minus = int(f"{plus_minus_s}1")
+        hours_offset = int(hours_offset_s)
+        mins_offset = int(mins_offset_s)
+
+        # Calculate net offset
+        net_mins_offset = hours_offset * 60
+        net_mins_offset += mins_offset
+        net_mins_offset *= plus_minus
+
+        # Create an offset object
+        tzoffset = FixedOffsetTimezone(net_mins_offset)
+
+        # Store the offset in a datetime object
+        dt = dt.replace(tzinfo=tzoffset)
+
+    return dt
+
+
+class Message:
+    """Representation of a single message in a catalog."""
+
+    def __init__(
+        self,
+        id: _MessageID,
+        string: _MessageID | None = '',
+        locations: Iterable[tuple[str, int]] = (),
+        flags: Iterable[str] = (),
+        auto_comments: Iterable[str] = (),
+        user_comments: Iterable[str] = (),
+        previous_id: _MessageID = (),
+        lineno: int | None = None,
+        context: str | None = None,
+    ) -> None:
+        """Create the message object.
+
+        :param id: the message ID, or a ``(singular, plural)`` tuple for
+                   pluralizable messages
+        :param string: the translated message string, or a
+                       ``(singular, plural)`` tuple for pluralizable messages
+        :param locations: a sequence of ``(filename, lineno)`` tuples
+        :param flags: a set or sequence of flags
+        :param auto_comments: a sequence of automatic comments for the message
+        :param user_comments: a sequence of user comments for the message
+        :param previous_id: the previous message ID, or a ``(singular, plural)``
+                            tuple for pluralizable messages
+        :param lineno: the line number on which the msgid line was found in the
+                       PO file, if any
+        :param context: the message context
+        """
+        self.id = id
+        if not string and self.pluralizable:
+            string = ('', '')
+        self.string = string
+        self.locations = list(distinct(locations))
+        self.flags = set(flags)
+        if id and self.python_format:
+            self.flags.add('python-format')
+        else:
+            self.flags.discard('python-format')
+        if id and self.python_brace_format:
+            self.flags.add('python-brace-format')
+        else:
+            self.flags.discard('python-brace-format')
+        self.auto_comments = list(distinct(auto_comments))
+        self.user_comments = list(distinct(user_comments))
+        if isinstance(previous_id, str):
+            self.previous_id = [previous_id]
+        else:
+            self.previous_id = list(previous_id)
+        self.lineno = lineno
+        self.context = context
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__} {self.id!r} (flags: {list(self.flags)!r})>"
+
+    def __cmp__(self, other: object) -> int:
+        """Compare Messages, taking into account plural ids"""
+        def values_to_compare(obj):
+            if isinstance(obj, Message) and obj.pluralizable:
+                return obj.id[0], obj.context or ''
+            return obj.id, obj.context or ''
+        return _cmp(values_to_compare(self), values_to_compare(other))
+
+    def __gt__(self, other: object) -> bool:
+        return self.__cmp__(other) > 0
+
+    def __lt__(self, other: object) -> bool:
+        return self.__cmp__(other) < 0
+
+    def __ge__(self, other: object) -> bool:
+        return self.__cmp__(other) >= 0
+
+    def __le__(self, other: object) -> bool:
+        return self.__cmp__(other) <= 0
+
+    def __eq__(self, other: object) -> bool:
+        return self.__cmp__(other) == 0
+
+    def __ne__(self, other: object) -> bool:
+        return self.__cmp__(other) != 0
+
+    def is_identical(self, other: Message) -> bool:
+        """Checks whether messages are identical, taking into account all
+        properties.
+        """
+        assert isinstance(other, Message)
+        return self.__dict__ == other.__dict__
+
+    def clone(self) -> Message:
+        return Message(*map(copy, (self.id, self.string, self.locations,
+                                   self.flags, self.auto_comments,
+                                   self.user_comments, self.previous_id,
+                                   self.lineno, self.context)))
+
+    def check(self, catalog: Catalog | None = None) -> list[TranslationError]:
+        """Run various validation checks on the message.  Some validations
+        are only performed if the catalog is provided.  This method returns
+        a sequence of `TranslationError` objects.
+
+        :rtype: ``iterator``
+        :param catalog: A catalog instance that is passed to the checkers
+        :see: `Catalog.check` for a way to perform checks for all messages
+              in a catalog.
+        """
+        from babel.messages.checkers import checkers
+        errors: list[TranslationError] = []
+        for checker in checkers:
+            try:
+                checker(catalog, self)
+            except TranslationError as e:
+                errors.append(e)
+        return errors
+
+    @property
+    def fuzzy(self) -> bool:
+        """Whether the translation is fuzzy.
+
+        >>> Message('foo').fuzzy
+        False
+        >>> msg = Message('foo', 'foo', flags=['fuzzy'])
+        >>> msg.fuzzy
+        True
+        >>> msg
+        <Message 'foo' (flags: ['fuzzy'])>
+
+        :type:  `bool`"""
+        return 'fuzzy' in self.flags
+
+    @property
+    def pluralizable(self) -> bool:
+        """Whether the message is plurizable.
+
+        >>> Message('foo').pluralizable
+        False
+        >>> Message(('foo', 'bar')).pluralizable
+        True
+
+        :type:  `bool`"""
+        return isinstance(self.id, (list, tuple))
+
+    @property
+    def python_format(self) -> bool:
+        """Whether the message contains Python-style parameters.
+
+        >>> Message('foo %(name)s bar').python_format
+        True
+        >>> Message(('foo %(name)s', 'foo %(name)s')).python_format
+        True
+
+        :type:  `bool`"""
+        ids = self.id
+        if not isinstance(ids, (list, tuple)):
+            ids = [ids]
+        return any(PYTHON_FORMAT.search(id) for id in ids)
+
+    @property
+    def python_brace_format(self) -> bool:
+        """Whether the message contains Python f-string parameters.
+
+        >>> Message('Hello, {name}!').python_brace_format
+        True
+        >>> Message(('One apple', '{count} apples')).python_brace_format
+        True
+
+        :type:  `bool`"""
+        ids = self.id
+        if not isinstance(ids, (list, tuple)):
+            ids = [ids]
+        return any(_has_python_brace_format(id) for id in ids)
+
+
+class TranslationError(Exception):
+    """Exception thrown by translation checkers when invalid message
+    translations are encountered."""
+
+
+DEFAULT_HEADER = """\
+# Translations template for PROJECT.
+# Copyright (C) YEAR ORGANIZATION
+# This file is distributed under the same license as the PROJECT project.
+# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
+#"""
+
+
+def parse_separated_header(value: str) -> dict[str, str]:
+    # Adapted from https://peps.python.org/pep-0594/#cgi
+    from email.message import Message
+    m = Message()
+    m['content-type'] = value
+    return dict(m.get_params())
+
+
+def _force_text(s: str | bytes, encoding: str = 'utf-8', errors: str = 'strict') -> str:
+    if isinstance(s, str):
+        return s
+    if isinstance(s, bytes):
+        return s.decode(encoding, errors)
+    return str(s)
+
+
+class Catalog:
+    """Representation of a message catalog."""
+
+    def __init__(
+        self,
+        locale: Locale | str | None = None,
+        domain: str | None = None,
+        header_comment: str | None = DEFAULT_HEADER,
+        project: str | None = None,
+        version: str | None = None,
+        copyright_holder: str | None = None,
+        msgid_bugs_address: str | None = None,
+        creation_date: datetime.datetime | str | None = None,
+        revision_date: datetime.datetime | datetime.time | float | str | None = None,
+        last_translator: str | None = None,
+        language_team: str | None = None,
+        charset: str | None = None,
+        fuzzy: bool = True,
+    ) -> None:
+        """Initialize the catalog object.
+
+        :param locale: the locale identifier or `Locale` object, or `None`
+                       if the catalog is not bound to a locale (which basically
+                       means it's a template)
+        :param domain: the message domain
+        :param header_comment: the header comment as string, or `None` for the
+                               default header
+        :param project: the project's name
+        :param version: the project's version
+        :param copyright_holder: the copyright holder of the catalog
+        :param msgid_bugs_address: the email address or URL to submit bug
+                                   reports to
+        :param creation_date: the date the catalog was created
+        :param revision_date: the date the catalog was revised
+        :param last_translator: the name and email of the last translator
+        :param language_team: the name and email of the language team
+        :param charset: the encoding to use in the output (defaults to utf-8)
+        :param fuzzy: the fuzzy bit on the catalog header
+        """
+        self.domain = domain
+        self.locale = locale
+        self._header_comment = header_comment
+        self._messages: dict[str | tuple[str, str], Message] = {}
+
+        self.project = project or 'PROJECT'
+        self.version = version or 'VERSION'
+        self.copyright_holder = copyright_holder or 'ORGANIZATION'
+        self.msgid_bugs_address = msgid_bugs_address or 'EMAIL@ADDRESS'
+
+        self.last_translator = last_translator or 'FULL NAME <EMAIL@ADDRESS>'
+        """Name and email address of the last translator."""
+        self.language_team = language_team or 'LANGUAGE <[email protected]>'
+        """Name and email address of the language team."""
+
+        self.charset = charset or 'utf-8'
+
+        if creation_date is None:
+            creation_date = datetime.datetime.now(LOCALTZ)
+        elif isinstance(creation_date, datetime.datetime) and not creation_date.tzinfo:
+            creation_date = creation_date.replace(tzinfo=LOCALTZ)
+        self.creation_date = creation_date
+        if revision_date is None:
+            revision_date = 'YEAR-MO-DA HO:MI+ZONE'
+        elif isinstance(revision_date, datetime.datetime) and not revision_date.tzinfo:
+            revision_date = revision_date.replace(tzinfo=LOCALTZ)
+        self.revision_date = revision_date
+        self.fuzzy = fuzzy
+
+        # Dictionary of obsolete messages
+        self.obsolete: dict[str | tuple[str, str], Message] = {}
+        self._num_plurals = None
+        self._plural_expr = None
+
+    def _set_locale(self, locale: Locale | str | None) -> None:
+        if locale is None:
+            self._locale_identifier = None
+            self._locale = None
+            return
+
+        if isinstance(locale, Locale):
+            self._locale_identifier = str(locale)
+            self._locale = locale
+            return
+
+        if isinstance(locale, str):
+            self._locale_identifier = str(locale)
+            try:
+                self._locale = Locale.parse(locale)
+            except UnknownLocaleError:
+                self._locale = None
+            return
+
+        raise TypeError(f"`locale` must be a Locale, a locale identifier string, or None; got {locale!r}")
+
+    def _get_locale(self) -> Locale | None:
+        return self._locale
+
+    def _get_locale_identifier(self) -> str | None:
+        return self._locale_identifier
+
+    locale = property(_get_locale, _set_locale)
+    locale_identifier = property(_get_locale_identifier)
+
+    def _get_header_comment(self) -> str:
+        comment = self._header_comment
+        year = datetime.datetime.now(LOCALTZ).strftime('%Y')
+        if hasattr(self.revision_date, 'strftime'):
+            year = self.revision_date.strftime('%Y')
+        comment = comment.replace('PROJECT', self.project) \
+                         .replace('VERSION', self.version) \
+                         .replace('YEAR', year) \
+                         .replace('ORGANIZATION', self.copyright_holder)
+        locale_name = (self.locale.english_name if self.locale else self.locale_identifier)
+        if locale_name:
+            comment = comment.replace("Translations template", f"{locale_name} translations")
+        return comment
+
+    def _set_header_comment(self, string: str | None) -> None:
+        self._header_comment = string
+
+    header_comment = property(_get_header_comment, _set_header_comment, doc="""\
+    The header comment for the catalog.
+
+    >>> catalog = Catalog(project='Foobar', version='1.0',
+    ...                   copyright_holder='Foo Company')
+    >>> print(catalog.header_comment) #doctest: +ELLIPSIS
+    # Translations template for Foobar.
+    # Copyright (C) ... Foo Company
+    # This file is distributed under the same license as the Foobar project.
+    # FIRST AUTHOR <EMAIL@ADDRESS>, ....
+    #
+
+    The header can also be set from a string. Any known upper-case variables
+    will be replaced when the header is retrieved again:
+
+    >>> catalog = Catalog(project='Foobar', version='1.0',
+    ...                   copyright_holder='Foo Company')
+    >>> catalog.header_comment = '''\\
+    ... # The POT for my really cool PROJECT project.
+    ... # Copyright (C) 1990-2003 ORGANIZATION
+    ... # This file is distributed under the same license as the PROJECT
+    ... # project.
+    ... #'''
+    >>> print(catalog.header_comment)
+    # The POT for my really cool Foobar project.
+    # Copyright (C) 1990-2003 Foo Company
+    # This file is distributed under the same license as the Foobar
+    # project.
+    #
+
+    :type: `unicode`
+    """)
+
+    def _get_mime_headers(self) -> list[tuple[str, str]]:
+        if isinstance(self.revision_date, (datetime.datetime, datetime.time, int, float)):
+            revision_date = format_datetime(self.revision_date, 'yyyy-MM-dd HH:mmZ', locale='en')
+        else:
+            revision_date = self.revision_date
+
+        language_team = self.language_team
+        if self.locale_identifier and 'LANGUAGE' in language_team:
+            language_team = language_team.replace('LANGUAGE', str(self.locale_identifier))
+
+        headers: list[tuple[str, str]] = [
+            ("Project-Id-Version", f"{self.project} {self.version}"),
+            ('Report-Msgid-Bugs-To', self.msgid_bugs_address),
+            ('POT-Creation-Date', format_datetime(self.creation_date, 'yyyy-MM-dd HH:mmZ', locale='en')),
+            ('PO-Revision-Date', revision_date),
+            ('Last-Translator', self.last_translator),
+        ]
+        if self.locale_identifier:
+            headers.append(('Language', str(self.locale_identifier)))
+        headers.append(('Language-Team', language_team))
+        if self.locale is not None:
+            headers.append(('Plural-Forms', self.plural_forms))
+        headers += [
+            ('MIME-Version', '1.0'),
+            ("Content-Type", f"text/plain; charset={self.charset}"),
+            ('Content-Transfer-Encoding', '8bit'),
+            ("Generated-By", f"Babel {VERSION}\n"),
+        ]
+        return headers
+
+    def _set_mime_headers(self, headers: Iterable[tuple[str, str]]) -> None:
+        for name, value in headers:
+            name = _force_text(name.lower(), encoding=self.charset)
+            value = _force_text(value, encoding=self.charset)
+            if name == 'project-id-version':
+                parts = value.split(' ')
+                self.project = ' '.join(parts[:-1])
+                self.version = parts[-1]
+            elif name == 'report-msgid-bugs-to':
+                self.msgid_bugs_address = value
+            elif name == 'last-translator':
+                self.last_translator = value
+            elif name == 'language':
+                value = value.replace('-', '_')
+                # The `or None` makes sure that the locale is set to None
+                # if the header's value is an empty string, which is what
+                # some tools generate (instead of eliding the empty Language
+                # header altogether).
+                self._set_locale(value or None)
+            elif name == 'language-team':
+                self.language_team = value
+            elif name == 'content-type':
+                params = parse_separated_header(value)
+                if 'charset' in params:
+                    self.charset = params['charset'].lower()
+            elif name == 'plural-forms':
+                params = parse_separated_header(f" ;{value}")
+                self._num_plurals = int(params.get('nplurals', 2))
+                self._plural_expr = params.get('plural', '(n != 1)')
+            elif name == 'pot-creation-date':
+                self.creation_date = _parse_datetime_header(value)
+            elif name == 'po-revision-date':
+                # Keep the value if it's not the default one
+                if 'YEAR' not in value:
+                    self.revision_date = _parse_datetime_header(value)
+
+    mime_headers = property(_get_mime_headers, _set_mime_headers, doc="""\
+    The MIME headers of the catalog, used for the special ``msgid ""`` entry.
+
+    The behavior of this property changes slightly depending on whether a locale
+    is set or not, the latter indicating that the catalog is actually a template
+    for actual translations.
+
+    Here's an example of the output for such a catalog template:
+
+    >>> from babel.dates import UTC
+    >>> from datetime import datetime
+    >>> created = datetime(1990, 4, 1, 15, 30, tzinfo=UTC)
+    >>> catalog = Catalog(project='Foobar', version='1.0',
+    ...                   creation_date=created)
+    >>> for name, value in catalog.mime_headers:
+    ...     print('%s: %s' % (name, value))
+    Project-Id-Version: Foobar 1.0
+    Report-Msgid-Bugs-To: EMAIL@ADDRESS
+    POT-Creation-Date: 1990-04-01 15:30+0000
+    PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE
+    Last-Translator: FULL NAME <EMAIL@ADDRESS>
+    Language-Team: LANGUAGE <[email protected]>
+    MIME-Version: 1.0
+    Content-Type: text/plain; charset=utf-8
+    Content-Transfer-Encoding: 8bit
+    Generated-By: Babel ...
+
+    And here's an example of the output when the locale is set:
+
+    >>> revised = datetime(1990, 8, 3, 12, 0, tzinfo=UTC)
+    >>> catalog = Catalog(locale='de_DE', project='Foobar', version='1.0',
+    ...                   creation_date=created, revision_date=revised,
+    ...                   last_translator='John Doe <[email protected]>',
+    ...                   language_team='de_DE <[email protected]>')
+    >>> for name, value in catalog.mime_headers:
+    ...     print('%s: %s' % (name, value))
+    Project-Id-Version: Foobar 1.0
+    Report-Msgid-Bugs-To: EMAIL@ADDRESS
+    POT-Creation-Date: 1990-04-01 15:30+0000
+    PO-Revision-Date: 1990-08-03 12:00+0000
+    Last-Translator: John Doe <[email protected]>
+    Language: de_DE
+    Language-Team: de_DE <[email protected]>
+    Plural-Forms: nplurals=2; plural=(n != 1);
+    MIME-Version: 1.0
+    Content-Type: text/plain; charset=utf-8
+    Content-Transfer-Encoding: 8bit
+    Generated-By: Babel ...
+
+    :type: `list`
+    """)
+
+    @property
+    def num_plurals(self) -> int:
+        """The number of plurals used by the catalog or locale.
+
+        >>> Catalog(locale='en').num_plurals
+        2
+        >>> Catalog(locale='ga').num_plurals
+        5
+
+        :type: `int`"""
+        if self._num_plurals is None:
+            num = 2
+            if self.locale:
+                num = get_plural(self.locale)[0]
+            self._num_plurals = num
+        return self._num_plurals
+
+    @property
+    def plural_expr(self) -> str:
+        """The plural expression used by the catalog or locale.
+
+        >>> Catalog(locale='en').plural_expr
+        '(n != 1)'
+        >>> Catalog(locale='ga').plural_expr
+        '(n==1 ? 0 : n==2 ? 1 : n>=3 && n<=6 ? 2 : n>=7 && n<=10 ? 3 : 4)'
+        >>> Catalog(locale='ding').plural_expr  # unknown locale
+        '(n != 1)'
+
+        :type: `str`"""
+        if self._plural_expr is None:
+            expr = '(n != 1)'
+            if self.locale:
+                expr = get_plural(self.locale)[1]
+            self._plural_expr = expr
+        return self._plural_expr
+
+    @property
+    def plural_forms(self) -> str:
+        """Return the plural forms declaration for the locale.
+
+        >>> Catalog(locale='en').plural_forms
+        'nplurals=2; plural=(n != 1);'
+        >>> Catalog(locale='pt_BR').plural_forms
+        'nplurals=2; plural=(n > 1);'
+
+        :type: `str`"""
+        return f"nplurals={self.num_plurals}; plural={self.plural_expr};"
+
+    def __contains__(self, id: _MessageID) -> bool:
+        """Return whether the catalog has a message with the specified ID."""
+        return self._key_for(id) in self._messages
+
+    def __len__(self) -> int:
+        """The number of messages in the catalog.
+
+        This does not include the special ``msgid ""`` entry."""
+        return len(self._messages)
+
+    def __iter__(self) -> Iterator[Message]:
+        """Iterates through all the entries in the catalog, in the order they
+        were added, yielding a `Message` object for every entry.
+
+        :rtype: ``iterator``"""
+        buf = []
+        for name, value in self.mime_headers:
+            buf.append(f"{name}: {value}")
+        flags = set()
+        if self.fuzzy:
+            flags |= {'fuzzy'}
+        yield Message('', '\n'.join(buf), flags=flags)
+        for key in self._messages:
+            yield self._messages[key]
+
+    def __repr__(self) -> str:
+        locale = ''
+        if self.locale:
+            locale = f" {self.locale}"
+        return f"<{type(self).__name__} {self.domain!r}{locale}>"
+
+    def __delitem__(self, id: _MessageID) -> None:
+        """Delete the message with the specified ID."""
+        self.delete(id)
+
+    def __getitem__(self, id: _MessageID) -> Message:
+        """Return the message with the specified ID.
+
+        :param id: the message ID
+        """
+        return self.get(id)
+
+    def __setitem__(self, id: _MessageID, message: Message) -> None:
+        """Add or update the message with the specified ID.
+
+        >>> catalog = Catalog()
+        >>> catalog[u'foo'] = Message(u'foo')
+        >>> catalog[u'foo']
+        <Message u'foo' (flags: [])>
+
+        If a message with that ID is already in the catalog, it is updated
+        to include the locations and flags of the new message.
+
+        >>> catalog = Catalog()
+        >>> catalog[u'foo'] = Message(u'foo', locations=[('main.py', 1)])
+        >>> catalog[u'foo'].locations
+        [('main.py', 1)]
+        >>> catalog[u'foo'] = Message(u'foo', locations=[('utils.py', 5)])
+        >>> catalog[u'foo'].locations
+        [('main.py', 1), ('utils.py', 5)]
+
+        :param id: the message ID
+        :param message: the `Message` object
+        """
+        assert isinstance(message, Message), 'expected a Message object'
+        key = self._key_for(id, message.context)
+        current = self._messages.get(key)
+        if current:
+            if message.pluralizable and not current.pluralizable:
+                # The new message adds pluralization
+                current.id = message.id
+                current.string = message.string
+            current.locations = list(distinct(current.locations +
+                                              message.locations))
+            current.auto_comments = list(distinct(current.auto_comments +
+                                                  message.auto_comments))
+            current.user_comments = list(distinct(current.user_comments +
+                                                  message.user_comments))
+            current.flags |= message.flags
+        elif id == '':
+            # special treatment for the header message
+            self.mime_headers = message_from_string(message.string).items()
+            self.header_comment = "\n".join([f"# {c}".rstrip() for c in message.user_comments])
+            self.fuzzy = message.fuzzy
+        else:
+            if isinstance(id, (list, tuple)):
+                assert isinstance(message.string, (list, tuple)), \
+                    f"Expected sequence but got {type(message.string)}"
+            self._messages[key] = message
+
+    def add(
+        self,
+        id: _MessageID,
+        string: _MessageID | None = None,
+        locations: Iterable[tuple[str, int]] = (),
+        flags: Iterable[str] = (),
+        auto_comments: Iterable[str] = (),
+        user_comments: Iterable[str] = (),
+        previous_id: _MessageID = (),
+        lineno: int | None = None,
+        context: str | None = None,
+    ) -> Message:
+        """Add or update the message with the specified ID.
+
+        >>> catalog = Catalog()
+        >>> catalog.add(u'foo')
+        <Message ...>
+        >>> catalog[u'foo']
+        <Message u'foo' (flags: [])>
+
+        This method simply constructs a `Message` object with the given
+        arguments and invokes `__setitem__` with that object.
+
+        :param id: the message ID, or a ``(singular, plural)`` tuple for
+                   pluralizable messages
+        :param string: the translated message string, or a
+                       ``(singular, plural)`` tuple for pluralizable messages
+        :param locations: a sequence of ``(filename, lineno)`` tuples
+        :param flags: a set or sequence of flags
+        :param auto_comments: a sequence of automatic comments
+        :param user_comments: a sequence of user comments
+        :param previous_id: the previous message ID, or a ``(singular, plural)``
+                            tuple for pluralizable messages
+        :param lineno: the line number on which the msgid line was found in the
+                       PO file, if any
+        :param context: the message context
+        """
+        message = Message(id, string, list(locations), flags, auto_comments,
+                          user_comments, previous_id, lineno=lineno,
+                          context=context)
+        self[id] = message
+        return message
+
+    def check(self) -> Iterable[tuple[Message, list[TranslationError]]]:
+        """Run various validation checks on the translations in the catalog.
+
+        For every message which fails validation, this method yield a
+        ``(message, errors)`` tuple, where ``message`` is the `Message` object
+        and ``errors`` is a sequence of `TranslationError` objects.
+
+        :rtype: ``generator`` of ``(message, errors)``
+        """
+        for message in self._messages.values():
+            errors = message.check(catalog=self)
+            if errors:
+                yield message, errors
+
+    def get(self, id: _MessageID, context: str | None = None) -> Message | None:
+        """Return the message with the specified ID and context.
+
+        :param id: the message ID
+        :param context: the message context, or ``None`` for no context
+        """
+        return self._messages.get(self._key_for(id, context))
+
+    def delete(self, id: _MessageID, context: str | None = None) -> None:
+        """Delete the message with the specified ID and context.
+
+        :param id: the message ID
+        :param context: the message context, or ``None`` for no context
+        """
+        key = self._key_for(id, context)
+        if key in self._messages:
+            del self._messages[key]
+
+    def update(
+        self,
+        template: Catalog,
+        no_fuzzy_matching: bool = False,
+        update_header_comment: bool = False,
+        keep_user_comments: bool = True,
+        update_creation_date: bool = True,
+    ) -> None:
+        """Update the catalog based on the given template catalog.
+
+        >>> from babel.messages import Catalog
+        >>> template = Catalog()
+        >>> template.add('green', locations=[('main.py', 99)])
+        <Message ...>
+        >>> template.add('blue', locations=[('main.py', 100)])
+        <Message ...>
+        >>> template.add(('salad', 'salads'), locations=[('util.py', 42)])
+        <Message ...>
+        >>> catalog = Catalog(locale='de_DE')
+        >>> catalog.add('blue', u'blau', locations=[('main.py', 98)])
+        <Message ...>
+        >>> catalog.add('head', u'Kopf', locations=[('util.py', 33)])
+        <Message ...>
+        >>> catalog.add(('salad', 'salads'), (u'Salat', u'Salate'),
+        ...             locations=[('util.py', 38)])
+        <Message ...>
+
+        >>> catalog.update(template)
+        >>> len(catalog)
+        3
+
+        >>> msg1 = catalog['green']
+        >>> msg1.string
+        >>> msg1.locations
+        [('main.py', 99)]
+
+        >>> msg2 = catalog['blue']
+        >>> msg2.string
+        u'blau'
+        >>> msg2.locations
+        [('main.py', 100)]
+
+        >>> msg3 = catalog['salad']
+        >>> msg3.string
+        (u'Salat', u'Salate')
+        >>> msg3.locations
+        [('util.py', 42)]
+
+        Messages that are in the catalog but not in the template are removed
+        from the main collection, but can still be accessed via the `obsolete`
+        member:
+
+        >>> 'head' in catalog
+        False
+        >>> list(catalog.obsolete.values())
+        [<Message 'head' (flags: [])>]
+
+        :param template: the reference catalog, usually read from a POT file
+        :param no_fuzzy_matching: whether to use fuzzy matching of message IDs
+        :param update_header_comment: whether to copy the header comment from the template
+        :param keep_user_comments: whether to keep user comments from the old catalog
+        :param update_creation_date: whether to copy the creation date from the template
+        """
+        messages = self._messages
+        remaining = messages.copy()
+        self._messages = {}
+
+        # Prepare for fuzzy matching
+        fuzzy_candidates = {}
+        if not no_fuzzy_matching:
+            for msgid in messages:
+                if msgid and messages[msgid].string:
+                    key = self._key_for(msgid)
+                    ctxt = messages[msgid].context
+                    fuzzy_candidates[self._to_fuzzy_match_key(key)] = (key, ctxt)
+        fuzzy_matches = set()
+
+        def _merge(message: Message, oldkey: tuple[str, str] | str, newkey: tuple[str, str] | str) -> None:
+            message = message.clone()
+            fuzzy = False
+            if oldkey != newkey:
+                fuzzy = True
+                fuzzy_matches.add(oldkey)
+                oldmsg = messages.get(oldkey)
+                assert oldmsg is not None
+                if isinstance(oldmsg.id, str):
+                    message.previous_id = [oldmsg.id]
+                else:
+                    message.previous_id = list(oldmsg.id)
+            else:
+                oldmsg = remaining.pop(oldkey, None)
+                assert oldmsg is not None
+            message.string = oldmsg.string
+
+            if keep_user_comments:
+                message.user_comments = list(distinct(oldmsg.user_comments))
+
+            if isinstance(message.id, (list, tuple)):
+                if not isinstance(message.string, (list, tuple)):
+                    fuzzy = True
+                    message.string = tuple(
+                        [message.string] + ([''] * (len(message.id) - 1)),
+                    )
+                elif len(message.string) != self.num_plurals:
+                    fuzzy = True
+                    message.string = tuple(message.string[:len(oldmsg.string)])
+            elif isinstance(message.string, (list, tuple)):
+                fuzzy = True
+                message.string = message.string[0]
+            message.flags |= oldmsg.flags
+            if fuzzy:
+                message.flags |= {'fuzzy'}
+            self[message.id] = message
+
+        for message in template:
+            if message.id:
+                key = self._key_for(message.id, message.context)
+                if key in messages:
+                    _merge(message, key, key)
+                else:
+                    if not no_fuzzy_matching:
+                        # do some fuzzy matching with difflib
+                        matches = get_close_matches(
+                            self._to_fuzzy_match_key(key),
+                            fuzzy_candidates.keys(),
+                            1,
+                        )
+                        if matches:
+                            modified_key = matches[0]
+                            newkey, newctxt = fuzzy_candidates[modified_key]
+                            if newctxt is not None:
+                                newkey = newkey, newctxt
+                            _merge(message, newkey, key)
+                            continue
+
+                    self[message.id] = message
+
+        for msgid in remaining:
+            if no_fuzzy_matching or msgid not in fuzzy_matches:
+                self.obsolete[msgid] = remaining[msgid]
+
+        if update_header_comment:
+            # Allow the updated catalog's header to be rewritten based on the
+            # template's header
+            self.header_comment = template.header_comment
+
+        # Make updated catalog's POT-Creation-Date equal to the template
+        # used to update the catalog
+        if update_creation_date:
+            self.creation_date = template.creation_date
+
+    def _to_fuzzy_match_key(self, key: tuple[str, str] | str) -> str:
+        """Converts a message key to a string suitable for fuzzy matching."""
+        if isinstance(key, tuple):
+            matchkey = key[0]  # just the msgid, no context
+        else:
+            matchkey = key
+        return matchkey.lower().strip()
+
+    def _key_for(self, id: _MessageID, context: str | None = None) -> tuple[str, str] | str:
+        """The key for a message is just the singular ID even for pluralizable
+        messages, but is a ``(msgid, msgctxt)`` tuple for context-specific
+        messages.
+        """
+        key = id
+        if isinstance(key, (list, tuple)):
+            key = id[0]
+        if context is not None:
+            key = (key, context)
+        return key
+
+    def is_identical(self, other: Catalog) -> bool:
+        """Checks if catalogs are identical, taking into account messages and
+        headers.
+        """
+        assert isinstance(other, Catalog)
+        for key in self._messages.keys() | other._messages.keys():
+            message_1 = self.get(key)
+            message_2 = other.get(key)
+            if (
+                message_1 is None
+                or message_2 is None
+                or not message_1.is_identical(message_2)
+            ):
+                return False
+        return dict(self.mime_headers) == dict(other.mime_headers)

lib/python3.10/site-packages/babel/messages/checkers.py

@@ -0,0 +1,168 @@
+"""
+    babel.messages.checkers
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    Various routines that help with validation of translations.
+
+    :since: version 0.9
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from __future__ import annotations
+
+from collections.abc import Callable
+
+from babel.messages.catalog import PYTHON_FORMAT, Catalog, Message, TranslationError
+
+#: list of format chars that are compatible to each other
+_string_format_compatibilities = [
+    {'i', 'd', 'u'},
+    {'x', 'X'},
+    {'f', 'F', 'g', 'G'},
+]
+
+
+def num_plurals(catalog: Catalog | None, message: Message) -> None:
+    """Verify the number of plurals in the translation."""
+    if not message.pluralizable:
+        if not isinstance(message.string, str):
+            raise TranslationError("Found plural forms for non-pluralizable "
+                                   "message")
+        return
+
+    # skip further tests if no catalog is provided.
+    elif catalog is None:
+        return
+
+    msgstrs = message.string
+    if not isinstance(msgstrs, (list, tuple)):
+        msgstrs = (msgstrs,)
+    if len(msgstrs) != catalog.num_plurals:
+        raise TranslationError("Wrong number of plural forms (expected %d)" %
+                               catalog.num_plurals)
+
+
+def python_format(catalog: Catalog | None, message: Message) -> None:
+    """Verify the format string placeholders in the translation."""
+    if 'python-format' not in message.flags:
+        return
+    msgids = message.id
+    if not isinstance(msgids, (list, tuple)):
+        msgids = (msgids,)
+    msgstrs = message.string
+    if not isinstance(msgstrs, (list, tuple)):
+        msgstrs = (msgstrs,)
+
+    for msgid, msgstr in zip(msgids, msgstrs):
+        if msgstr:
+            _validate_format(msgid, msgstr)
+
+
+def _validate_format(format: str, alternative: str) -> None:
+    """Test format string `alternative` against `format`.  `format` can be the
+    msgid of a message and `alternative` one of the `msgstr`\\s.  The two
+    arguments are not interchangeable as `alternative` may contain less
+    placeholders if `format` uses named placeholders.
+
+    If the string formatting of `alternative` is compatible to `format` the
+    function returns `None`, otherwise a `TranslationError` is raised.
+
+    Examples for compatible format strings:
+
+    >>> _validate_format('Hello %s!', 'Hallo %s!')
+    >>> _validate_format('Hello %i!', 'Hallo %d!')
+
+    Example for an incompatible format strings:
+
+    >>> _validate_format('Hello %(name)s!', 'Hallo %s!')
+    Traceback (most recent call last):
+      ...
+    TranslationError: the format strings are of different kinds
+
+    This function is used by the `python_format` checker.
+
+    :param format: The original format string
+    :param alternative: The alternative format string that should be checked
+                        against format
+    :raises TranslationError: on formatting errors
+    """
+
+    def _parse(string: str) -> list[tuple[str, str]]:
+        result: list[tuple[str, str]] = []
+        for match in PYTHON_FORMAT.finditer(string):
+            name, format, typechar = match.groups()
+            if typechar == '%' and name is None:
+                continue
+            result.append((name, str(typechar)))
+        return result
+
+    def _compatible(a: str, b: str) -> bool:
+        if a == b:
+            return True
+        for set in _string_format_compatibilities:
+            if a in set and b in set:
+                return True
+        return False
+
+    def _check_positional(results: list[tuple[str, str]]) -> bool:
+        positional = None
+        for name, _char in results:
+            if positional is None:
+                positional = name is None
+            else:
+                if (name is None) != positional:
+                    raise TranslationError('format string mixes positional '
+                                           'and named placeholders')
+        return bool(positional)
+
+    a, b = map(_parse, (format, alternative))
+
+    if not a:
+        return
+
+    # now check if both strings are positional or named
+    a_positional, b_positional = map(_check_positional, (a, b))
+    if a_positional and not b_positional and not b:
+        raise TranslationError('placeholders are incompatible')
+    elif a_positional != b_positional:
+        raise TranslationError('the format strings are of different kinds')
+
+    # if we are operating on positional strings both must have the
+    # same number of format chars and those must be compatible
+    if a_positional:
+        if len(a) != len(b):
+            raise TranslationError('positional format placeholders are '
+                                   'unbalanced')
+        for idx, ((_, first), (_, second)) in enumerate(zip(a, b)):
+            if not _compatible(first, second):
+                raise TranslationError('incompatible format for placeholder '
+                                       '%d: %r and %r are not compatible' %
+                                       (idx + 1, first, second))
+
+    # otherwise the second string must not have names the first one
+    # doesn't have and the types of those included must be compatible
+    else:
+        type_map = dict(a)
+        for name, typechar in b:
+            if name not in type_map:
+                raise TranslationError(f'unknown named placeholder {name!r}')
+            elif not _compatible(typechar, type_map[name]):
+                raise TranslationError(
+                    f'incompatible format for placeholder {name!r}: '
+                    f'{typechar!r} and {type_map[name]!r} are not compatible',
+                )
+
+
+def _find_checkers() -> list[Callable[[Catalog | None, Message], object]]:
+    from babel.messages._compat import find_entrypoints
+    checkers: list[Callable[[Catalog | None, Message], object]] = []
+    checkers.extend(load() for (name, load) in find_entrypoints('babel.checkers'))
+    if len(checkers) == 0:
+        # if entrypoints are not available or no usable egg-info was found
+        # (see #230), just resort to hard-coded checkers
+        return [num_plurals, python_format]
+    return checkers
+
+
+checkers: list[Callable[[Catalog | None, Message], object]] = _find_checkers()

lib/python3.10/site-packages/babel/messages/extract.py

@@ -0,0 +1,852 @@
+"""
+    babel.messages.extract
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Basic infrastructure for extracting localizable messages from source files.
+
+    This module defines an extensible system for collecting localizable message
+    strings from a variety of sources. A native extractor for Python source
+    files is builtin, extractors for other sources can be added using very
+    simple plugins.
+
+    The main entry points into the extraction functionality are the functions
+    `extract_from_dir` and `extract_from_file`.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from __future__ import annotations
+
+import ast
+import io
+import os
+import sys
+import tokenize
+from collections.abc import (
+    Callable,
+    Collection,
+    Generator,
+    Iterable,
+    Mapping,
+    MutableSequence,
+)
+from functools import lru_cache
+from os.path import relpath
+from textwrap import dedent
+from tokenize import COMMENT, NAME, NL, OP, STRING, generate_tokens
+from typing import TYPE_CHECKING, Any, TypedDict
+
+from babel.messages._compat import find_entrypoints
+from babel.util import parse_encoding, parse_future_flags, pathmatch
+
+if TYPE_CHECKING:
+    from typing import IO, Final, Protocol
+
+    from _typeshed import SupportsItems, SupportsRead, SupportsReadline
+    from typing_extensions import TypeAlias
+
+    class _PyOptions(TypedDict, total=False):
+        encoding: str
+
+    class _JSOptions(TypedDict, total=False):
+        encoding: str
+        jsx: bool
+        template_string: bool
+        parse_template_string: bool
+
+    class _FileObj(SupportsRead[bytes], SupportsReadline[bytes], Protocol):
+        def seek(self, __offset: int, __whence: int = ...) -> int: ...
+        def tell(self) -> int: ...
+
+    _SimpleKeyword: TypeAlias = tuple[int | tuple[int, int] | tuple[int, str], ...] | None
+    _Keyword: TypeAlias = dict[int | None, _SimpleKeyword] | _SimpleKeyword
+
+    # 5-tuple of (filename, lineno, messages, comments, context)
+    _FileExtractionResult: TypeAlias = tuple[str, int, str | tuple[str, ...], list[str], str | None]
+
+    # 4-tuple of (lineno, message, comments, context)
+    _ExtractionResult: TypeAlias = tuple[int, str | tuple[str, ...], list[str], str | None]
+
+    # Required arguments: fileobj, keywords, comment_tags, options
+    # Return value: Iterable of (lineno, message, comments, context)
+    _CallableExtractionMethod: TypeAlias = Callable[
+        [_FileObj | IO[bytes], Mapping[str, _Keyword], Collection[str], Mapping[str, Any]],
+        Iterable[_ExtractionResult],
+    ]
+
+    _ExtractionMethod: TypeAlias = _CallableExtractionMethod | str
+
+GROUP_NAME: Final[str] = 'babel.extractors'
+
+DEFAULT_KEYWORDS: dict[str, _Keyword] = {
+    '_': None,
+    'gettext': None,
+    'ngettext': (1, 2),
+    'ugettext': None,
+    'ungettext': (1, 2),
+    'dgettext': (2,),
+    'dngettext': (2, 3),
+    'N_': None,
+    'pgettext': ((1, 'c'), 2),
+    'npgettext': ((1, 'c'), 2, 3),
+}
+
+DEFAULT_MAPPING: list[tuple[str, str]] = [('**.py', 'python')]
+
+# New tokens in Python 3.12, or None on older versions
+FSTRING_START = getattr(tokenize, "FSTRING_START", None)
+FSTRING_MIDDLE = getattr(tokenize, "FSTRING_MIDDLE", None)
+FSTRING_END = getattr(tokenize, "FSTRING_END", None)
+
+
+def _strip_comment_tags(comments: MutableSequence[str], tags: Iterable[str]):
+    """Helper function for `extract` that strips comment tags from strings
+    in a list of comment lines.  This functions operates in-place.
+    """
+    def _strip(line: str):
+        for tag in tags:
+            if line.startswith(tag):
+                return line[len(tag):].strip()
+        return line
+    comments[:] = map(_strip, comments)
+
+
+def default_directory_filter(dirpath: str | os.PathLike[str]) -> bool:
+    subdir = os.path.basename(dirpath)
+    # Legacy default behavior: ignore dot and underscore directories
+    return not (subdir.startswith('.') or subdir.startswith('_'))
+
+
+def extract_from_dir(
+    dirname: str | os.PathLike[str] | None = None,
+    method_map: Iterable[tuple[str, str]] = DEFAULT_MAPPING,
+    options_map: SupportsItems[str, dict[str, Any]] | None = None,
+    keywords: Mapping[str, _Keyword] = DEFAULT_KEYWORDS,
+    comment_tags: Collection[str] = (),
+    callback: Callable[[str, str, dict[str, Any]], object] | None = None,
+    strip_comment_tags: bool = False,
+    directory_filter: Callable[[str], bool] | None = None,
+) -> Generator[_FileExtractionResult, None, None]:
+    """Extract messages from any source files found in the given directory.
+
+    This function generates tuples of the form ``(filename, lineno, message,
+    comments, context)``.
+
+    Which extraction method is used per file is determined by the `method_map`
+    parameter, which maps extended glob patterns to extraction method names.
+    For example, the following is the default mapping:
+
+    >>> method_map = [
+    ...     ('**.py', 'python')
+    ... ]
+
+    This basically says that files with the filename extension ".py" at any
+    level inside the directory should be processed by the "python" extraction
+    method. Files that don't match any of the mapping patterns are ignored. See
+    the documentation of the `pathmatch` function for details on the pattern
+    syntax.
+
+    The following extended mapping would also use the "genshi" extraction
+    method on any file in "templates" subdirectory:
+
+    >>> method_map = [
+    ...     ('**/templates/**.*', 'genshi'),
+    ...     ('**.py', 'python')
+    ... ]
+
+    The dictionary provided by the optional `options_map` parameter augments
+    these mappings. It uses extended glob patterns as keys, and the values are
+    dictionaries mapping options names to option values (both strings).
+
+    The glob patterns of the `options_map` do not necessarily need to be the
+    same as those used in the method mapping. For example, while all files in
+    the ``templates`` folders in an application may be Genshi applications, the
+    options for those files may differ based on extension:
+
+    >>> options_map = {
+    ...     '**/templates/**.txt': {
+    ...         'template_class': 'genshi.template:TextTemplate',
+    ...         'encoding': 'latin-1'
+    ...     },
+    ...     '**/templates/**.html': {
+    ...         'include_attrs': ''
+    ...     }
+    ... }
+
+    :param dirname: the path to the directory to extract messages from.  If
+                    not given the current working directory is used.
+    :param method_map: a list of ``(pattern, method)`` tuples that maps of
+                       extraction method names to extended glob patterns
+    :param options_map: a dictionary of additional options (optional)
+    :param keywords: a dictionary mapping keywords (i.e. names of functions
+                     that should be recognized as translation functions) to
+                     tuples that specify which of their arguments contain
+                     localizable strings
+    :param comment_tags: a list of tags of translator comments to search for
+                         and include in the results
+    :param callback: a function that is called for every file that message are
+                     extracted from, just before the extraction itself is
+                     performed; the function is passed the filename, the name
+                     of the extraction method and and the options dictionary as
+                     positional arguments, in that order
+    :param strip_comment_tags: a flag that if set to `True` causes all comment
+                               tags to be removed from the collected comments.
+    :param directory_filter: a callback to determine whether a directory should
+                             be recursed into. Receives the full directory path;
+                             should return True if the directory is valid.
+    :see: `pathmatch`
+    """
+    if dirname is None:
+        dirname = os.getcwd()
+    if options_map is None:
+        options_map = {}
+    if directory_filter is None:
+        directory_filter = default_directory_filter
+
+    absname = os.path.abspath(dirname)
+    for root, dirnames, filenames in os.walk(absname):
+        dirnames[:] = [
+            subdir for subdir in dirnames
+            if directory_filter(os.path.join(root, subdir))
+        ]
+        dirnames.sort()
+        filenames.sort()
+        for filename in filenames:
+            filepath = os.path.join(root, filename).replace(os.sep, '/')
+
+            yield from check_and_call_extract_file(
+                filepath,
+                method_map,
+                options_map,
+                callback,
+                keywords,
+                comment_tags,
+                strip_comment_tags,
+                dirpath=absname,
+            )
+
+
+def check_and_call_extract_file(
+    filepath: str | os.PathLike[str],
+    method_map: Iterable[tuple[str, str]],
+    options_map: SupportsItems[str, dict[str, Any]],
+    callback: Callable[[str, str, dict[str, Any]], object] | None,
+    keywords: Mapping[str, _Keyword],
+    comment_tags: Collection[str],
+    strip_comment_tags: bool,
+    dirpath: str | os.PathLike[str] | None = None,
+) -> Generator[_FileExtractionResult, None, None]:
+    """Checks if the given file matches an extraction method mapping, and if so, calls extract_from_file.
+
+    Note that the extraction method mappings are based relative to dirpath.
+    So, given an absolute path to a file `filepath`, we want to check using
+    just the relative path from `dirpath` to `filepath`.
+
+    Yields 5-tuples (filename, lineno, messages, comments, context).
+
+    :param filepath: An absolute path to a file that exists.
+    :param method_map: a list of ``(pattern, method)`` tuples that maps of
+                       extraction method names to extended glob patterns
+    :param options_map: a dictionary of additional options (optional)
+    :param callback: a function that is called for every file that message are
+                     extracted from, just before the extraction itself is
+                     performed; the function is passed the filename, the name
+                     of the extraction method and and the options dictionary as
+                     positional arguments, in that order
+    :param keywords: a dictionary mapping keywords (i.e. names of functions
+                     that should be recognized as translation functions) to
+                     tuples that specify which of their arguments contain
+                     localizable strings
+    :param comment_tags: a list of tags of translator comments to search for
+                         and include in the results
+    :param strip_comment_tags: a flag that if set to `True` causes all comment
+                               tags to be removed from the collected comments.
+    :param dirpath: the path to the directory to extract messages from.
+    :return: iterable of 5-tuples (filename, lineno, messages, comments, context)
+    :rtype: Iterable[tuple[str, int, str|tuple[str], list[str], str|None]
+    """
+    # filename is the relative path from dirpath to the actual file
+    filename = relpath(filepath, dirpath)
+
+    for pattern, method in method_map:
+        if not pathmatch(pattern, filename):
+            continue
+
+        options = {}
+        for opattern, odict in options_map.items():
+            if pathmatch(opattern, filename):
+                options = odict
+                break
+        if callback:
+            callback(filename, method, options)
+        for message_tuple in extract_from_file(
+            method, filepath,
+            keywords=keywords,
+            comment_tags=comment_tags,
+            options=options,
+            strip_comment_tags=strip_comment_tags,
+        ):
+            yield (filename, *message_tuple)
+
+        break
+
+
+def extract_from_file(
+    method: _ExtractionMethod,
+    filename: str | os.PathLike[str],
+    keywords: Mapping[str, _Keyword] = DEFAULT_KEYWORDS,
+    comment_tags: Collection[str] = (),
+    options: Mapping[str, Any] | None = None,
+    strip_comment_tags: bool = False,
+) -> list[_ExtractionResult]:
+    """Extract messages from a specific file.
+
+    This function returns a list of tuples of the form ``(lineno, message, comments, context)``.
+
+    :param filename: the path to the file to extract messages from
+    :param method: a string specifying the extraction method (.e.g. "python")
+    :param keywords: a dictionary mapping keywords (i.e. names of functions
+                     that should be recognized as translation functions) to
+                     tuples that specify which of their arguments contain
+                     localizable strings
+    :param comment_tags: a list of translator tags to search for and include
+                         in the results
+    :param strip_comment_tags: a flag that if set to `True` causes all comment
+                               tags to be removed from the collected comments.
+    :param options: a dictionary of additional options (optional)
+    :returns: list of tuples of the form ``(lineno, message, comments, context)``
+    :rtype: list[tuple[int, str|tuple[str], list[str], str|None]
+    """
+    if method == 'ignore':
+        return []
+
+    with open(filename, 'rb') as fileobj:
+        return list(extract(method, fileobj, keywords, comment_tags,
+                            options, strip_comment_tags))
+
+
+def _match_messages_against_spec(
+    lineno: int,
+    messages: list[str | None],
+    comments: list[str],
+    fileobj: _FileObj,
+    spec: tuple[int | tuple[int, str], ...],
+):
+    translatable = []
+    context = None
+
+    # last_index is 1 based like the keyword spec
+    last_index = len(messages)
+    for index in spec:
+        if isinstance(index, tuple):  # (n, 'c')
+            context = messages[index[0] - 1]
+            continue
+        if last_index < index:
+            # Not enough arguments
+            return
+        message = messages[index - 1]
+        if message is None:
+            return
+        translatable.append(message)
+
+    # keyword spec indexes are 1 based, therefore '-1'
+    if isinstance(spec[0], tuple):
+        # context-aware *gettext method
+        first_msg_index = spec[1] - 1
+    else:
+        first_msg_index = spec[0] - 1
+    # An empty string msgid isn't valid, emit a warning
+    if not messages[first_msg_index]:
+        filename = (getattr(fileobj, "name", None) or "(unknown)")
+        sys.stderr.write(
+            f"{filename}:{lineno}: warning: Empty msgid.  It is reserved by GNU gettext: gettext(\"\") "
+            f"returns the header entry with meta information, not the empty string.\n",
+        )
+        return
+
+    translatable = tuple(translatable)
+    if len(translatable) == 1:
+        translatable = translatable[0]
+
+    return lineno, translatable, comments, context
+
+
+@lru_cache(maxsize=None)
+def _find_extractor(name: str):
+    for ep_name, load in find_entrypoints(GROUP_NAME):
+        if ep_name == name:
+            return load()
+    return None
+
+
+def extract(
+    method: _ExtractionMethod,
+    fileobj: _FileObj,
+    keywords: Mapping[str, _Keyword] = DEFAULT_KEYWORDS,
+    comment_tags: Collection[str] = (),
+    options: Mapping[str, Any] | None = None,
+    strip_comment_tags: bool = False,
+) -> Generator[_ExtractionResult, None, None]:
+    """Extract messages from the given file-like object using the specified
+    extraction method.
+
+    This function returns tuples of the form ``(lineno, message, comments, context)``.
+
+    The implementation dispatches the actual extraction to plugins, based on the
+    value of the ``method`` parameter.
+
+    >>> source = b'''# foo module
+    ... def run(argv):
+    ...    print(_('Hello, world!'))
+    ... '''
+
+    >>> from io import BytesIO
+    >>> for message in extract('python', BytesIO(source)):
+    ...     print(message)
+    (3, u'Hello, world!', [], None)
+
+    :param method: an extraction method (a callable), or
+                   a string specifying the extraction method (.e.g. "python");
+                   if this is a simple name, the extraction function will be
+                   looked up by entry point; if it is an explicit reference
+                   to a function (of the form ``package.module:funcname`` or
+                   ``package.module.funcname``), the corresponding function
+                   will be imported and used
+    :param fileobj: the file-like object the messages should be extracted from
+    :param keywords: a dictionary mapping keywords (i.e. names of functions
+                     that should be recognized as translation functions) to
+                     tuples that specify which of their arguments contain
+                     localizable strings
+    :param comment_tags: a list of translator tags to search for and include
+                         in the results
+    :param options: a dictionary of additional options (optional)
+    :param strip_comment_tags: a flag that if set to `True` causes all comment
+                               tags to be removed from the collected comments.
+    :raise ValueError: if the extraction method is not registered
+    :returns: iterable of tuples of the form ``(lineno, message, comments, context)``
+    :rtype: Iterable[tuple[int, str|tuple[str], list[str], str|None]
+    """
+    if callable(method):
+        func = method
+    elif ':' in method or '.' in method:
+        if ':' not in method:
+            lastdot = method.rfind('.')
+            module, attrname = method[:lastdot], method[lastdot + 1:]
+        else:
+            module, attrname = method.split(':', 1)
+        func = getattr(__import__(module, {}, {}, [attrname]), attrname)
+    else:
+        func = _find_extractor(method)
+        if func is None:
+            # if no named entry point was found,
+            # we resort to looking up a builtin extractor
+            func = _BUILTIN_EXTRACTORS.get(method)
+
+    if func is None:
+        raise ValueError(f"Unknown extraction method {method!r}")
+
+    results = func(fileobj, keywords.keys(), comment_tags,
+                   options=options or {})
+
+    for lineno, funcname, messages, comments in results:
+        if not isinstance(messages, (list, tuple)):
+            messages = [messages]
+        if not messages:
+            continue
+
+        specs = keywords[funcname] or None if funcname else None
+        # {None: x} may be collapsed into x for backwards compatibility.
+        if not isinstance(specs, dict):
+            specs = {None: specs}
+
+        if strip_comment_tags:
+            _strip_comment_tags(comments, comment_tags)
+
+        # None matches all arities.
+        for arity in (None, len(messages)):
+            try:
+                spec = specs[arity]
+            except KeyError:
+                continue
+            if spec is None:
+                spec = (1,)
+            result = _match_messages_against_spec(lineno, messages, comments, fileobj, spec)
+            if result is not None:
+                yield result
+
+
+def extract_nothing(
+    fileobj: _FileObj,
+    keywords: Mapping[str, _Keyword],
+    comment_tags: Collection[str],
+    options: Mapping[str, Any],
+) -> list[_ExtractionResult]:
+    """Pseudo extractor that does not actually extract anything, but simply
+    returns an empty list.
+    """
+    return []
+
+
+def extract_python(
+    fileobj: IO[bytes],
+    keywords: Mapping[str, _Keyword],
+    comment_tags: Collection[str],
+    options: _PyOptions,
+) -> Generator[_ExtractionResult, None, None]:
+    """Extract messages from Python source code.
+
+    It returns an iterator yielding tuples in the following form ``(lineno,
+    funcname, message, comments)``.
+
+    :param fileobj: the seekable, file-like object the messages should be
+                    extracted from
+    :param keywords: a list of keywords (i.e. function names) that should be
+                     recognized as translation functions
+    :param comment_tags: a list of translator tags to search for and include
+                         in the results
+    :param options: a dictionary of additional options (optional)
+    :rtype: ``iterator``
+    """
+    funcname = lineno = message_lineno = None
+    call_stack = -1
+    buf = []
+    messages = []
+    translator_comments = []
+    in_def = in_translator_comments = False
+    comment_tag = None
+
+    encoding = parse_encoding(fileobj) or options.get('encoding', 'UTF-8')
+    future_flags = parse_future_flags(fileobj, encoding)
+    next_line = lambda: fileobj.readline().decode(encoding)
+
+    tokens = generate_tokens(next_line)
+
+    # Current prefix of a Python 3.12 (PEP 701) f-string, or None if we're not
+    # currently parsing one.
+    current_fstring_start = None
+
+    for tok, value, (lineno, _), _, _ in tokens:
+        if call_stack == -1 and tok == NAME and value in ('def', 'class'):
+            in_def = True
+        elif tok == OP and value == '(':
+            if in_def:
+                # Avoid false positives for declarations such as:
+                # def gettext(arg='message'):
+                in_def = False
+                continue
+            if funcname:
+                call_stack += 1
+        elif in_def and tok == OP and value == ':':
+            # End of a class definition without parens
+            in_def = False
+            continue
+        elif call_stack == -1 and tok == COMMENT:
+            # Strip the comment token from the line
+            value = value[1:].strip()
+            if in_translator_comments and \
+                    translator_comments[-1][0] == lineno - 1:
+                # We're already inside a translator comment, continue appending
+                translator_comments.append((lineno, value))
+                continue
+            # If execution reaches this point, let's see if comment line
+            # starts with one of the comment tags
+            for comment_tag in comment_tags:
+                if value.startswith(comment_tag):
+                    in_translator_comments = True
+                    translator_comments.append((lineno, value))
+                    break
+        elif funcname and call_stack == 0:
+            nested = (tok == NAME and value in keywords)
+            if (tok == OP and value == ')') or nested:
+                if buf:
+                    messages.append(''.join(buf))
+                    del buf[:]
+                else:
+                    messages.append(None)
+
+                messages = tuple(messages) if len(messages) > 1 else messages[0]
+                # Comments don't apply unless they immediately
+                # precede the message
+                if translator_comments and \
+                        translator_comments[-1][0] < message_lineno - 1:
+                    translator_comments = []
+
+                yield (message_lineno, funcname, messages,
+                       [comment[1] for comment in translator_comments])
+
+                funcname = lineno = message_lineno = None
+                call_stack = -1
+                messages = []
+                translator_comments = []
+                in_translator_comments = False
+                if nested:
+                    funcname = value
+            elif tok == STRING:
+                val = _parse_python_string(value, encoding, future_flags)
+                if val is not None:
+                    if not message_lineno:
+                        message_lineno = lineno
+                    buf.append(val)
+
+            # Python 3.12+, see https://peps.python.org/pep-0701/#new-tokens
+            elif tok == FSTRING_START:
+                current_fstring_start = value
+                if not message_lineno:
+                    message_lineno = lineno
+            elif tok == FSTRING_MIDDLE:
+                if current_fstring_start is not None:
+                    current_fstring_start += value
+            elif tok == FSTRING_END:
+                if current_fstring_start is not None:
+                    fstring = current_fstring_start + value
+                    val = _parse_python_string(fstring, encoding, future_flags)
+                    if val is not None:
+                        buf.append(val)
+
+            elif tok == OP and value == ',':
+                if buf:
+                    messages.append(''.join(buf))
+                    del buf[:]
+                else:
+                    messages.append(None)
+                if translator_comments:
+                    # We have translator comments, and since we're on a
+                    # comma(,) user is allowed to break into a new line
+                    # Let's increase the last comment's lineno in order
+                    # for the comment to still be a valid one
+                    old_lineno, old_comment = translator_comments.pop()
+                    translator_comments.append((old_lineno + 1, old_comment))
+
+            elif tok != NL and not message_lineno:
+                message_lineno = lineno
+        elif call_stack > 0 and tok == OP and value == ')':
+            call_stack -= 1
+        elif funcname and call_stack == -1:
+            funcname = None
+        elif tok == NAME and value in keywords:
+            funcname = value
+
+        if current_fstring_start is not None and tok not in {FSTRING_START, FSTRING_MIDDLE}:
+            # In Python 3.12, tokens other than FSTRING_* mean the
+            # f-string is dynamic, so we don't wan't to extract it.
+            # And if it's FSTRING_END, we've already handled it above.
+            # Let's forget that we're in an f-string.
+            current_fstring_start = None
+
+
+def _parse_python_string(value: str, encoding: str, future_flags: int) -> str | None:
+    # Unwrap quotes in a safe manner, maintaining the string's encoding
+    # https://sourceforge.net/tracker/?func=detail&atid=355470&aid=617979&group_id=5470
+    code = compile(
+        f'# coding={str(encoding)}\n{value}',
+        '<string>',
+        'eval',
+        ast.PyCF_ONLY_AST | future_flags,
+    )
+    if isinstance(code, ast.Expression):
+        body = code.body
+        if isinstance(body, ast.Constant):
+            return body.value
+        if isinstance(body, ast.JoinedStr):  # f-string
+            if all(isinstance(node, ast.Constant) for node in body.values):
+                return ''.join(node.value for node in body.values)
+            # TODO: we could raise an error or warning when not all nodes are constants
+    return None
+
+
+def extract_javascript(
+    fileobj: _FileObj,
+    keywords: Mapping[str, _Keyword],
+    comment_tags: Collection[str],
+    options: _JSOptions,
+    lineno: int = 1,
+) -> Generator[_ExtractionResult, None, None]:
+    """Extract messages from JavaScript source code.
+
+    :param fileobj: the seekable, file-like object the messages should be
+                    extracted from
+    :param keywords: a list of keywords (i.e. function names) that should be
+                     recognized as translation functions
+    :param comment_tags: a list of translator tags to search for and include
+                         in the results
+    :param options: a dictionary of additional options (optional)
+                    Supported options are:
+                    * `jsx` -- set to false to disable JSX/E4X support.
+                    * `template_string` -- if `True`, supports gettext(`key`)
+                    * `parse_template_string` -- if `True` will parse the
+                                                 contents of javascript
+                                                 template strings.
+    :param lineno: line number offset (for parsing embedded fragments)
+    """
+    from babel.messages.jslexer import Token, tokenize, unquote_string
+    funcname = message_lineno = None
+    messages = []
+    last_argument = None
+    translator_comments = []
+    concatenate_next = False
+    encoding = options.get('encoding', 'utf-8')
+    last_token = None
+    call_stack = -1
+    dotted = any('.' in kw for kw in keywords)
+    for token in tokenize(
+        fileobj.read().decode(encoding),
+        jsx=options.get("jsx", True),
+        template_string=options.get("template_string", True),
+        dotted=dotted,
+        lineno=lineno,
+    ):
+        if (  # Turn keyword`foo` expressions into keyword("foo") calls:
+            funcname and  # have a keyword...
+            (last_token and last_token.type == 'name') and  # we've seen nothing after the keyword...
+            token.type == 'template_string'  # this is a template string
+        ):
+            message_lineno = token.lineno
+            messages = [unquote_string(token.value)]
+            call_stack = 0
+            token = Token('operator', ')', token.lineno)
+
+        if options.get('parse_template_string') and not funcname and token.type == 'template_string':
+            yield from parse_template_string(token.value, keywords, comment_tags, options, token.lineno)
+
+        elif token.type == 'operator' and token.value == '(':
+            if funcname:
+                message_lineno = token.lineno
+                call_stack += 1
+
+        elif call_stack == -1 and token.type == 'linecomment':
+            value = token.value[2:].strip()
+            if translator_comments and \
+               translator_comments[-1][0] == token.lineno - 1:
+                translator_comments.append((token.lineno, value))
+                continue
+
+            for comment_tag in comment_tags:
+                if value.startswith(comment_tag):
+                    translator_comments.append((token.lineno, value.strip()))
+                    break
+
+        elif token.type == 'multilinecomment':
+            # only one multi-line comment may precede a translation
+            translator_comments = []
+            value = token.value[2:-2].strip()
+            for comment_tag in comment_tags:
+                if value.startswith(comment_tag):
+                    lines = value.splitlines()
+                    if lines:
+                        lines[0] = lines[0].strip()
+                        lines[1:] = dedent('\n'.join(lines[1:])).splitlines()
+                        for offset, line in enumerate(lines):
+                            translator_comments.append((token.lineno + offset,
+                                                        line))
+                    break
+
+        elif funcname and call_stack == 0:
+            if token.type == 'operator' and token.value == ')':
+                if last_argument is not None:
+                    messages.append(last_argument)
+                if len(messages) > 1:
+                    messages = tuple(messages)
+                elif messages:
+                    messages = messages[0]
+                else:
+                    messages = None
+
+                # Comments don't apply unless they immediately precede the
+                # message
+                if translator_comments and \
+                   translator_comments[-1][0] < message_lineno - 1:
+                    translator_comments = []
+
+                if messages is not None:
+                    yield (message_lineno, funcname, messages,
+                           [comment[1] for comment in translator_comments])
+
+                funcname = message_lineno = last_argument = None
+                concatenate_next = False
+                translator_comments = []
+                messages = []
+                call_stack = -1
+
+            elif token.type in ('string', 'template_string'):
+                new_value = unquote_string(token.value)
+                if concatenate_next:
+                    last_argument = (last_argument or '') + new_value
+                    concatenate_next = False
+                else:
+                    last_argument = new_value
+
+            elif token.type == 'operator':
+                if token.value == ',':
+                    if last_argument is not None:
+                        messages.append(last_argument)
+                        last_argument = None
+                    else:
+                        messages.append(None)
+                    concatenate_next = False
+                elif token.value == '+':
+                    concatenate_next = True
+
+        elif call_stack > 0 and token.type == 'operator' \
+                and token.value == ')':
+            call_stack -= 1
+
+        elif funcname and call_stack == -1:
+            funcname = None
+
+        elif call_stack == -1 and token.type == 'name' and \
+            token.value in keywords and \
+            (last_token is None or last_token.type != 'name' or
+             last_token.value != 'function'):
+            funcname = token.value
+
+        last_token = token
+
+
+def parse_template_string(
+    template_string: str,
+    keywords: Mapping[str, _Keyword],
+    comment_tags: Collection[str],
+    options: _JSOptions,
+    lineno: int = 1,
+) -> Generator[_ExtractionResult, None, None]:
+    """Parse JavaScript template string.
+
+    :param template_string: the template string to be parsed
+    :param keywords: a list of keywords (i.e. function names) that should be
+                     recognized as translation functions
+    :param comment_tags: a list of translator tags to search for and include
+                         in the results
+    :param options: a dictionary of additional options (optional)
+    :param lineno: starting line number (optional)
+    """
+    from babel.messages.jslexer import line_re
+    prev_character = None
+    level = 0
+    inside_str = False
+    expression_contents = ''
+    for character in template_string[1:-1]:
+        if not inside_str and character in ('"', "'", '`'):
+            inside_str = character
+        elif inside_str == character and prev_character != r'\\':
+            inside_str = False
+        if level:
+            expression_contents += character
+        if not inside_str:
+            if character == '{' and prev_character == '$':
+                level += 1
+            elif level and character == '}':
+                level -= 1
+                if level == 0 and expression_contents:
+                    expression_contents = expression_contents[0:-1]
+                    fake_file_obj = io.BytesIO(expression_contents.encode())
+                    yield from extract_javascript(fake_file_obj, keywords, comment_tags, options, lineno)
+                    lineno += len(line_re.findall(expression_contents))
+                    expression_contents = ''
+        prev_character = character
+
+
+_BUILTIN_EXTRACTORS = {
+    'ignore': extract_nothing,
+    'python': extract_python,
+    'javascript': extract_javascript,
+}

lib/python3.10/site-packages/babel/messages/frontend.py

@@ -0,0 +1,1202 @@
+"""
+    babel.messages.frontend
+    ~~~~~~~~~~~~~~~~~~~~~~~
+
+    Frontends for the message extraction functionality.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+
+from __future__ import annotations
+
+import datetime
+import fnmatch
+import logging
+import optparse
+import os
+import re
+import shutil
+import sys
+import tempfile
+import warnings
+from configparser import RawConfigParser
+from io import StringIO
+from typing import BinaryIO, Iterable, Literal
+
+from babel import Locale, localedata
+from babel import __version__ as VERSION
+from babel.core import UnknownLocaleError
+from babel.messages.catalog import DEFAULT_HEADER, Catalog
+from babel.messages.extract import (
+    DEFAULT_KEYWORDS,
+    DEFAULT_MAPPING,
+    check_and_call_extract_file,
+    extract_from_dir,
+)
+from babel.messages.mofile import write_mo
+from babel.messages.pofile import read_po, write_po
+from babel.util import LOCALTZ
+
+log = logging.getLogger('babel')
+
+
+class BaseError(Exception):
+    pass
+
+
+class OptionError(BaseError):
+    pass
+
+
+class SetupError(BaseError):
+    pass
+
+
+class ConfigurationError(BaseError):
+    """
+    Raised for errors in configuration files.
+    """
+
+
+def listify_value(arg, split=None):
+    """
+    Make a list out of an argument.
+
+    Values from `distutils` argument parsing are always single strings;
+    values from `optparse` parsing may be lists of strings that may need
+    to be further split.
+
+    No matter the input, this function returns a flat list of whitespace-trimmed
+    strings, with `None` values filtered out.
+
+    >>> listify_value("foo bar")
+    ['foo', 'bar']
+    >>> listify_value(["foo bar"])
+    ['foo', 'bar']
+    >>> listify_value([["foo"], "bar"])
+    ['foo', 'bar']
+    >>> listify_value([["foo"], ["bar", None, "foo"]])
+    ['foo', 'bar', 'foo']
+    >>> listify_value("foo, bar, quux", ",")
+    ['foo', 'bar', 'quux']
+
+    :param arg: A string or a list of strings
+    :param split: The argument to pass to `str.split()`.
+    :return:
+    """
+    out = []
+
+    if not isinstance(arg, (list, tuple)):
+        arg = [arg]
+
+    for val in arg:
+        if val is None:
+            continue
+        if isinstance(val, (list, tuple)):
+            out.extend(listify_value(val, split=split))
+            continue
+        out.extend(s.strip() for s in str(val).split(split))
+    assert all(isinstance(val, str) for val in out)
+    return out
+
+
+class CommandMixin:
+    # This class is a small shim between Distutils commands and
+    # optparse option parsing in the frontend command line.
+
+    #: Option name to be input as `args` on the script command line.
+    as_args = None
+
+    #: Options which allow multiple values.
+    #: This is used by the `optparse` transmogrification code.
+    multiple_value_options = ()
+
+    #: Options which are booleans.
+    #: This is used by the `optparse` transmogrification code.
+    # (This is actually used by distutils code too, but is never
+    # declared in the base class.)
+    boolean_options = ()
+
+    #: Option aliases, to retain standalone command compatibility.
+    #: Distutils does not support option aliases, but optparse does.
+    #: This maps the distutils argument name to an iterable of aliases
+    #: that are usable with optparse.
+    option_aliases = {}
+
+    #: Choices for options that needed to be restricted to specific
+    #: list of choices.
+    option_choices = {}
+
+    #: Log object. To allow replacement in the script command line runner.
+    log = log
+
+    def __init__(self, dist=None):
+        # A less strict version of distutils' `__init__`.
+        self.distribution = dist
+        self.initialize_options()
+        self._dry_run = None
+        self.verbose = False
+        self.force = None
+        self.help = 0
+        self.finalized = 0
+
+    def initialize_options(self):
+        pass
+
+    def ensure_finalized(self):
+        if not self.finalized:
+            self.finalize_options()
+        self.finalized = 1
+
+    def finalize_options(self):
+        raise RuntimeError(
+            f"abstract method -- subclass {self.__class__} must override",
+        )
+
+
+class CompileCatalog(CommandMixin):
+    description = 'compile message catalogs to binary MO files'
+    user_options = [
+        ('domain=', 'D',
+         "domains of PO files (space separated list, default 'messages')"),
+        ('directory=', 'd',
+         'path to base directory containing the catalogs'),
+        ('input-file=', 'i',
+         'name of the input file'),
+        ('output-file=', 'o',
+         "name of the output file (default "
+         "'<output_dir>/<locale>/LC_MESSAGES/<domain>.mo')"),
+        ('locale=', 'l',
+         'locale of the catalog to compile'),
+        ('use-fuzzy', 'f',
+         'also include fuzzy translations'),
+        ('statistics', None,
+         'print statistics about translations'),
+    ]
+    boolean_options = ['use-fuzzy', 'statistics']
+
+    def initialize_options(self):
+        self.domain = 'messages'
+        self.directory = None
+        self.input_file = None
+        self.output_file = None
+        self.locale = None
+        self.use_fuzzy = False
+        self.statistics = False
+
+    def finalize_options(self):
+        self.domain = listify_value(self.domain)
+        if not self.input_file and not self.directory:
+            raise OptionError('you must specify either the input file or the base directory')
+        if not self.output_file and not self.directory:
+            raise OptionError('you must specify either the output file or the base directory')
+
+    def run(self):
+        n_errors = 0
+        for domain in self.domain:
+            for errors in self._run_domain(domain).values():
+                n_errors += len(errors)
+        if n_errors:
+            self.log.error('%d errors encountered.', n_errors)
+        return (1 if n_errors else 0)
+
+    def _run_domain(self, domain):
+        po_files = []
+        mo_files = []
+
+        if not self.input_file:
+            if self.locale:
+                po_files.append((self.locale,
+                                 os.path.join(self.directory, self.locale,
+                                              'LC_MESSAGES',
+                                              f"{domain}.po")))
+                mo_files.append(os.path.join(self.directory, self.locale,
+                                             'LC_MESSAGES',
+                                             f"{domain}.mo"))
+            else:
+                for locale in os.listdir(self.directory):
+                    po_file = os.path.join(self.directory, locale,
+                                           'LC_MESSAGES', f"{domain}.po")
+                    if os.path.exists(po_file):
+                        po_files.append((locale, po_file))
+                        mo_files.append(os.path.join(self.directory, locale,
+                                                     'LC_MESSAGES',
+                                                     f"{domain}.mo"))
+        else:
+            po_files.append((self.locale, self.input_file))
+            if self.output_file:
+                mo_files.append(self.output_file)
+            else:
+                mo_files.append(os.path.join(self.directory, self.locale,
+                                             'LC_MESSAGES',
+                                             f"{domain}.mo"))
+
+        if not po_files:
+            raise OptionError('no message catalogs found')
+
+        catalogs_and_errors = {}
+
+        for idx, (locale, po_file) in enumerate(po_files):
+            mo_file = mo_files[idx]
+            with open(po_file, 'rb') as infile:
+                catalog = read_po(infile, locale)
+
+            if self.statistics:
+                translated = 0
+                for message in list(catalog)[1:]:
+                    if message.string:
+                        translated += 1
+                percentage = 0
+                if len(catalog):
+                    percentage = translated * 100 // len(catalog)
+                self.log.info(
+                    '%d of %d messages (%d%%) translated in %s',
+                    translated, len(catalog), percentage, po_file,
+                )
+
+            if catalog.fuzzy and not self.use_fuzzy:
+                self.log.info('catalog %s is marked as fuzzy, skipping', po_file)
+                continue
+
+            catalogs_and_errors[catalog] = catalog_errors = list(catalog.check())
+            for message, errors in catalog_errors:
+                for error in errors:
+                    self.log.error(
+                        'error: %s:%d: %s', po_file, message.lineno, error,
+                    )
+
+            self.log.info('compiling catalog %s to %s', po_file, mo_file)
+
+            with open(mo_file, 'wb') as outfile:
+                write_mo(outfile, catalog, use_fuzzy=self.use_fuzzy)
+
+        return catalogs_and_errors
+
+
+def _make_directory_filter(ignore_patterns):
+    """
+    Build a directory_filter function based on a list of ignore patterns.
+    """
+
+    def cli_directory_filter(dirname):
+        basename = os.path.basename(dirname)
+        return not any(
+            fnmatch.fnmatch(basename, ignore_pattern)
+            for ignore_pattern
+            in ignore_patterns
+        )
+
+    return cli_directory_filter
+
+
+class ExtractMessages(CommandMixin):
+    description = 'extract localizable strings from the project code'
+    user_options = [
+        ('charset=', None,
+         'charset to use in the output file (default "utf-8")'),
+        ('keywords=', 'k',
+         'space-separated list of keywords to look for in addition to the '
+         'defaults (may be repeated multiple times)'),
+        ('no-default-keywords', None,
+         'do not include the default keywords'),
+        ('mapping-file=', 'F',
+         'path to the mapping configuration file'),
+        ('no-location', None,
+         'do not include location comments with filename and line number'),
+        ('add-location=', None,
+         'location lines format. If it is not given or "full", it generates '
+         'the lines with both file name and line number. If it is "file", '
+         'the line number part is omitted. If it is "never", it completely '
+         'suppresses the lines (same as --no-location).'),
+        ('omit-header', None,
+         'do not include msgid "" entry in header'),
+        ('output-file=', 'o',
+         'name of the output file'),
+        ('width=', 'w',
+         'set output line width (default 76)'),
+        ('no-wrap', None,
+         'do not break long message lines, longer than the output line width, '
+         'into several lines'),
+        ('sort-output', None,
+         'generate sorted output (default False)'),
+        ('sort-by-file', None,
+         'sort output by file location (default False)'),
+        ('msgid-bugs-address=', None,
+         'set report address for msgid'),
+        ('copyright-holder=', None,
+         'set copyright holder in output'),
+        ('project=', None,
+         'set project name in output'),
+        ('version=', None,
+         'set project version in output'),
+        ('add-comments=', 'c',
+         'place comment block with TAG (or those preceding keyword lines) in '
+         'output file. Separate multiple TAGs with commas(,)'),  # TODO: Support repetition of this argument
+        ('strip-comments', 's',
+         'strip the comment TAGs from the comments.'),
+        ('input-paths=', None,
+         'files or directories that should be scanned for messages. Separate multiple '
+         'files or directories with commas(,)'),  # TODO: Support repetition of this argument
+        ('input-dirs=', None,  # TODO (3.x): Remove me.
+         'alias for input-paths (does allow files as well as directories).'),
+        ('ignore-dirs=', None,
+         'Patterns for directories to ignore when scanning for messages. '
+         'Separate multiple patterns with spaces (default ".* ._")'),
+        ('header-comment=', None,
+         'header comment for the catalog'),
+        ('last-translator=', None,
+         'set the name and email of the last translator in output'),
+    ]
+    boolean_options = [
+        'no-default-keywords', 'no-location', 'omit-header', 'no-wrap',
+        'sort-output', 'sort-by-file', 'strip-comments',
+    ]
+    as_args = 'input-paths'
+    multiple_value_options = (
+        'add-comments',
+        'keywords',
+        'ignore-dirs',
+    )
+    option_aliases = {
+        'keywords': ('--keyword',),
+        'mapping-file': ('--mapping',),
+        'output-file': ('--output',),
+        'strip-comments': ('--strip-comment-tags',),
+        'last-translator': ('--last-translator',),
+    }
+    option_choices = {
+        'add-location': ('full', 'file', 'never'),
+    }
+
+    def initialize_options(self):
+        self.charset = 'utf-8'
+        self.keywords = None
+        self.no_default_keywords = False
+        self.mapping_file = None
+        self.no_location = False
+        self.add_location = None
+        self.omit_header = False
+        self.output_file = None
+        self.input_dirs = None
+        self.input_paths = None
+        self.width = None
+        self.no_wrap = False
+        self.sort_output = False
+        self.sort_by_file = False
+        self.msgid_bugs_address = None
+        self.copyright_holder = None
+        self.project = None
+        self.version = None
+        self.add_comments = None
+        self.strip_comments = False
+        self.include_lineno = True
+        self.ignore_dirs = None
+        self.header_comment = None
+        self.last_translator = None
+
+    def finalize_options(self):
+        if self.input_dirs:
+            if not self.input_paths:
+                self.input_paths = self.input_dirs
+            else:
+                raise OptionError(
+                    'input-dirs and input-paths are mutually exclusive',
+                )
+
+        keywords = {} if self.no_default_keywords else DEFAULT_KEYWORDS.copy()
+
+        keywords.update(parse_keywords(listify_value(self.keywords)))
+
+        self.keywords = keywords
+
+        if not self.keywords:
+            raise OptionError(
+                'you must specify new keywords if you disable the default ones',
+            )
+
+        if not self.output_file:
+            raise OptionError('no output file specified')
+        if self.no_wrap and self.width:
+            raise OptionError(
+                "'--no-wrap' and '--width' are mutually exclusive",
+            )
+        if not self.no_wrap and not self.width:
+            self.width = 76
+        elif self.width is not None:
+            self.width = int(self.width)
+
+        if self.sort_output and self.sort_by_file:
+            raise OptionError(
+                "'--sort-output' and '--sort-by-file' are mutually exclusive",
+            )
+
+        if self.input_paths:
+            if isinstance(self.input_paths, str):
+                self.input_paths = re.split(r',\s*', self.input_paths)
+        elif self.distribution is not None:
+            self.input_paths = dict.fromkeys([
+                k.split('.', 1)[0]
+                for k in (self.distribution.packages or ())
+            ]).keys()
+        else:
+            self.input_paths = []
+
+        if not self.input_paths:
+            raise OptionError("no input files or directories specified")
+
+        for path in self.input_paths:
+            if not os.path.exists(path):
+                raise OptionError(f"Input path: {path} does not exist")
+
+        self.add_comments = listify_value(self.add_comments or (), ",")
+
+        if self.distribution:
+            if not self.project:
+                self.project = self.distribution.get_name()
+            if not self.version:
+                self.version = self.distribution.get_version()
+
+        if self.add_location == 'never':
+            self.no_location = True
+        elif self.add_location == 'file':
+            self.include_lineno = False
+
+        ignore_dirs = listify_value(self.ignore_dirs)
+        if ignore_dirs:
+            self.directory_filter = _make_directory_filter(ignore_dirs)
+        else:
+            self.directory_filter = None
+
+    def _build_callback(self, path: str):
+        def callback(filename: str, method: str, options: dict):
+            if method == 'ignore':
+                return
+
+            # If we explicitly provide a full filepath, just use that.
+            # Otherwise, path will be the directory path and filename
+            # is the relative path from that dir to the file.
+            # So we can join those to get the full filepath.
+            if os.path.isfile(path):
+                filepath = path
+            else:
+                filepath = os.path.normpath(os.path.join(path, filename))
+
+            optstr = ''
+            if options:
+                opt_values = ", ".join(f'{k}="{v}"' for k, v in options.items())
+                optstr = f" ({opt_values})"
+            self.log.info('extracting messages from %s%s', filepath, optstr)
+
+        return callback
+
+    def run(self):
+        mappings = self._get_mappings()
+        with open(self.output_file, 'wb') as outfile:
+            catalog = Catalog(project=self.project,
+                              version=self.version,
+                              msgid_bugs_address=self.msgid_bugs_address,
+                              copyright_holder=self.copyright_holder,
+                              charset=self.charset,
+                              header_comment=(self.header_comment or DEFAULT_HEADER),
+                              last_translator=self.last_translator)
+
+            for path, method_map, options_map in mappings:
+                callback = self._build_callback(path)
+                if os.path.isfile(path):
+                    current_dir = os.getcwd()
+                    extracted = check_and_call_extract_file(
+                        path, method_map, options_map,
+                        callback, self.keywords, self.add_comments,
+                        self.strip_comments, current_dir,
+                    )
+                else:
+                    extracted = extract_from_dir(
+                        path, method_map, options_map,
+                        keywords=self.keywords,
+                        comment_tags=self.add_comments,
+                        callback=callback,
+                        strip_comment_tags=self.strip_comments,
+                        directory_filter=self.directory_filter,
+                    )
+                for filename, lineno, message, comments, context in extracted:
+                    if os.path.isfile(path):
+                        filepath = filename  # already normalized
+                    else:
+                        filepath = os.path.normpath(os.path.join(path, filename))
+
+                    catalog.add(message, None, [(filepath, lineno)],
+                                auto_comments=comments, context=context)
+
+            self.log.info('writing PO template file to %s', self.output_file)
+            write_po(outfile, catalog, width=self.width,
+                     no_location=self.no_location,
+                     omit_header=self.omit_header,
+                     sort_output=self.sort_output,
+                     sort_by_file=self.sort_by_file,
+                     include_lineno=self.include_lineno)
+
+    def _get_mappings(self):
+        mappings = []
+
+        if self.mapping_file:
+            if self.mapping_file.endswith(".toml"):
+                with open(self.mapping_file, "rb") as fileobj:
+                    file_style = (
+                        "pyproject.toml"
+                        if os.path.basename(self.mapping_file) == "pyproject.toml"
+                        else "standalone"
+                    )
+                    method_map, options_map = _parse_mapping_toml(
+                        fileobj,
+                        filename=self.mapping_file,
+                        style=file_style,
+                    )
+            else:
+                with open(self.mapping_file) as fileobj:
+                    method_map, options_map = parse_mapping_cfg(fileobj, filename=self.mapping_file)
+            for path in self.input_paths:
+                mappings.append((path, method_map, options_map))
+
+        elif getattr(self.distribution, 'message_extractors', None):
+            message_extractors = self.distribution.message_extractors
+            for path, mapping in message_extractors.items():
+                if isinstance(mapping, str):
+                    method_map, options_map = parse_mapping_cfg(StringIO(mapping))
+                else:
+                    method_map, options_map = [], {}
+                    for pattern, method, options in mapping:
+                        method_map.append((pattern, method))
+                        options_map[pattern] = options or {}
+                mappings.append((path, method_map, options_map))
+
+        else:
+            for path in self.input_paths:
+                mappings.append((path, DEFAULT_MAPPING, {}))
+
+        return mappings
+
+
+class InitCatalog(CommandMixin):
+    description = 'create a new catalog based on a POT file'
+    user_options = [
+        ('domain=', 'D',
+         "domain of PO file (default 'messages')"),
+        ('input-file=', 'i',
+         'name of the input file'),
+        ('output-dir=', 'd',
+         'path to output directory'),
+        ('output-file=', 'o',
+         "name of the output file (default "
+         "'<output_dir>/<locale>/LC_MESSAGES/<domain>.po')"),
+        ('locale=', 'l',
+         'locale for the new localized catalog'),
+        ('width=', 'w',
+         'set output line width (default 76)'),
+        ('no-wrap', None,
+         'do not break long message lines, longer than the output line width, '
+         'into several lines'),
+    ]
+    boolean_options = ['no-wrap']
+
+    def initialize_options(self):
+        self.output_dir = None
+        self.output_file = None
+        self.input_file = None
+        self.locale = None
+        self.domain = 'messages'
+        self.no_wrap = False
+        self.width = None
+
+    def finalize_options(self):
+        if not self.input_file:
+            raise OptionError('you must specify the input file')
+
+        if not self.locale:
+            raise OptionError('you must provide a locale for the new catalog')
+        try:
+            self._locale = Locale.parse(self.locale)
+        except UnknownLocaleError as e:
+            raise OptionError(e) from e
+
+        if not self.output_file and not self.output_dir:
+            raise OptionError('you must specify the output directory')
+        if not self.output_file:
+            self.output_file = os.path.join(self.output_dir, self.locale,
+                                            'LC_MESSAGES', f"{self.domain}.po")
+
+        if not os.path.exists(os.path.dirname(self.output_file)):
+            os.makedirs(os.path.dirname(self.output_file))
+        if self.no_wrap and self.width:
+            raise OptionError("'--no-wrap' and '--width' are mutually exclusive")
+        if not self.no_wrap and not self.width:
+            self.width = 76
+        elif self.width is not None:
+            self.width = int(self.width)
+
+    def run(self):
+        self.log.info(
+            'creating catalog %s based on %s', self.output_file, self.input_file,
+        )
+
+        with open(self.input_file, 'rb') as infile:
+            # Although reading from the catalog template, read_po must be fed
+            # the locale in order to correctly calculate plurals
+            catalog = read_po(infile, locale=self.locale)
+
+        catalog.locale = self._locale
+        catalog.revision_date = datetime.datetime.now(LOCALTZ)
+        catalog.fuzzy = False
+
+        with open(self.output_file, 'wb') as outfile:
+            write_po(outfile, catalog, width=self.width)
+
+
+class UpdateCatalog(CommandMixin):
+    description = 'update message catalogs from a POT file'
+    user_options = [
+        ('domain=', 'D',
+         "domain of PO file (default 'messages')"),
+        ('input-file=', 'i',
+         'name of the input file'),
+        ('output-dir=', 'd',
+         'path to base directory containing the catalogs'),
+        ('output-file=', 'o',
+         "name of the output file (default "
+         "'<output_dir>/<locale>/LC_MESSAGES/<domain>.po')"),
+        ('omit-header', None,
+         "do not include msgid "" entry in header"),
+        ('locale=', 'l',
+         'locale of the catalog to compile'),
+        ('width=', 'w',
+         'set output line width (default 76)'),
+        ('no-wrap', None,
+         'do not break long message lines, longer than the output line width, '
+         'into several lines'),
+        ('ignore-obsolete=', None,
+         'whether to omit obsolete messages from the output'),
+        ('init-missing=', None,
+         'if any output files are missing, initialize them first'),
+        ('no-fuzzy-matching', 'N',
+         'do not use fuzzy matching'),
+        ('update-header-comment', None,
+         'update target header comment'),
+        ('previous', None,
+         'keep previous msgids of translated messages'),
+        ('check=', None,
+         'don\'t update the catalog, just return the status. Return code 0 '
+         'means nothing would change. Return code 1 means that the catalog '
+         'would be updated'),
+        ('ignore-pot-creation-date=', None,
+         'ignore changes to POT-Creation-Date when updating or checking'),
+    ]
+    boolean_options = [
+        'omit-header', 'no-wrap', 'ignore-obsolete', 'init-missing',
+        'no-fuzzy-matching', 'previous', 'update-header-comment',
+        'check', 'ignore-pot-creation-date',
+    ]
+
+    def initialize_options(self):
+        self.domain = 'messages'
+        self.input_file = None
+        self.output_dir = None
+        self.output_file = None
+        self.omit_header = False
+        self.locale = None
+        self.width = None
+        self.no_wrap = False
+        self.ignore_obsolete = False
+        self.init_missing = False
+        self.no_fuzzy_matching = False
+        self.update_header_comment = False
+        self.previous = False
+        self.check = False
+        self.ignore_pot_creation_date = False
+
+    def finalize_options(self):
+        if not self.input_file:
+            raise OptionError('you must specify the input file')
+        if not self.output_file and not self.output_dir:
+            raise OptionError('you must specify the output file or directory')
+        if self.output_file and not self.locale:
+            raise OptionError('you must specify the locale')
+
+        if self.init_missing:
+            if not self.locale:
+                raise OptionError(
+                    'you must specify the locale for '
+                    'the init-missing option to work',
+                )
+
+            try:
+                self._locale = Locale.parse(self.locale)
+            except UnknownLocaleError as e:
+                raise OptionError(e) from e
+        else:
+            self._locale = None
+
+        if self.no_wrap and self.width:
+            raise OptionError("'--no-wrap' and '--width' are mutually exclusive")
+        if not self.no_wrap and not self.width:
+            self.width = 76
+        elif self.width is not None:
+            self.width = int(self.width)
+        if self.no_fuzzy_matching and self.previous:
+            self.previous = False
+
+    def run(self):
+        check_status = {}
+        po_files = []
+        if not self.output_file:
+            if self.locale:
+                po_files.append((self.locale,
+                                 os.path.join(self.output_dir, self.locale,
+                                              'LC_MESSAGES',
+                                              f"{self.domain}.po")))
+            else:
+                for locale in os.listdir(self.output_dir):
+                    po_file = os.path.join(self.output_dir, locale,
+                                           'LC_MESSAGES',
+                                           f"{self.domain}.po")
+                    if os.path.exists(po_file):
+                        po_files.append((locale, po_file))
+        else:
+            po_files.append((self.locale, self.output_file))
+
+        if not po_files:
+            raise OptionError('no message catalogs found')
+
+        domain = self.domain
+        if not domain:
+            domain = os.path.splitext(os.path.basename(self.input_file))[0]
+
+        with open(self.input_file, 'rb') as infile:
+            template = read_po(infile)
+
+        for locale, filename in po_files:
+            if self.init_missing and not os.path.exists(filename):
+                if self.check:
+                    check_status[filename] = False
+                    continue
+                self.log.info(
+                    'creating catalog %s based on %s', filename, self.input_file,
+                )
+
+                with open(self.input_file, 'rb') as infile:
+                    # Although reading from the catalog template, read_po must
+                    # be fed the locale in order to correctly calculate plurals
+                    catalog = read_po(infile, locale=self.locale)
+
+                catalog.locale = self._locale
+                catalog.revision_date = datetime.datetime.now(LOCALTZ)
+                catalog.fuzzy = False
+
+                with open(filename, 'wb') as outfile:
+                    write_po(outfile, catalog)
+
+            self.log.info('updating catalog %s based on %s', filename, self.input_file)
+            with open(filename, 'rb') as infile:
+                catalog = read_po(infile, locale=locale, domain=domain)
+
+            catalog.update(
+                template, self.no_fuzzy_matching,
+                update_header_comment=self.update_header_comment,
+                update_creation_date=not self.ignore_pot_creation_date,
+            )
+
+            tmpname = os.path.join(os.path.dirname(filename),
+                                   tempfile.gettempprefix() +
+                                   os.path.basename(filename))
+            try:
+                with open(tmpname, 'wb') as tmpfile:
+                    write_po(tmpfile, catalog,
+                             omit_header=self.omit_header,
+                             ignore_obsolete=self.ignore_obsolete,
+                             include_previous=self.previous, width=self.width)
+            except Exception:
+                os.remove(tmpname)
+                raise
+
+            if self.check:
+                with open(filename, "rb") as origfile:
+                    original_catalog = read_po(origfile)
+                with open(tmpname, "rb") as newfile:
+                    updated_catalog = read_po(newfile)
+                updated_catalog.revision_date = original_catalog.revision_date
+                check_status[filename] = updated_catalog.is_identical(original_catalog)
+                os.remove(tmpname)
+                continue
+
+            try:
+                os.rename(tmpname, filename)
+            except OSError:
+                # We're probably on Windows, which doesn't support atomic
+                # renames, at least not through Python
+                # If the error is in fact due to a permissions problem, that
+                # same error is going to be raised from one of the following
+                # operations
+                os.remove(filename)
+                shutil.copy(tmpname, filename)
+                os.remove(tmpname)
+
+        if self.check:
+            for filename, up_to_date in check_status.items():
+                if up_to_date:
+                    self.log.info('Catalog %s is up to date.', filename)
+                else:
+                    self.log.warning('Catalog %s is out of date.', filename)
+            if not all(check_status.values()):
+                raise BaseError("Some catalogs are out of date.")
+            else:
+                self.log.info("All the catalogs are up-to-date.")
+            return
+
+
+class CommandLineInterface:
+    """Command-line interface.
+
+    This class provides a simple command-line interface to the message
+    extraction and PO file generation functionality.
+    """
+
+    usage = '%%prog %s [options] %s'
+    version = f'%prog {VERSION}'
+    commands = {
+        'compile': 'compile message catalogs to MO files',
+        'extract': 'extract messages from source files and generate a POT file',
+        'init': 'create new message catalogs from a POT file',
+        'update': 'update existing message catalogs from a POT file',
+    }
+
+    command_classes = {
+        'compile': CompileCatalog,
+        'extract': ExtractMessages,
+        'init': InitCatalog,
+        'update': UpdateCatalog,
+    }
+
+    log = None  # Replaced on instance level
+
+    def run(self, argv=None):
+        """Main entry point of the command-line interface.
+
+        :param argv: list of arguments passed on the command-line
+        """
+
+        if argv is None:
+            argv = sys.argv
+
+        self.parser = optparse.OptionParser(usage=self.usage % ('command', '[args]'),
+                                            version=self.version)
+        self.parser.disable_interspersed_args()
+        self.parser.print_help = self._help
+        self.parser.add_option('--list-locales', dest='list_locales',
+                               action='store_true',
+                               help="print all known locales and exit")
+        self.parser.add_option('-v', '--verbose', action='store_const',
+                               dest='loglevel', const=logging.DEBUG,
+                               help='print as much as possible')
+        self.parser.add_option('-q', '--quiet', action='store_const',
+                               dest='loglevel', const=logging.ERROR,
+                               help='print as little as possible')
+        self.parser.set_defaults(list_locales=False, loglevel=logging.INFO)
+
+        options, args = self.parser.parse_args(argv[1:])
+
+        self._configure_logging(options.loglevel)
+        if options.list_locales:
+            identifiers = localedata.locale_identifiers()
+            id_width = max(len(identifier) for identifier in identifiers) + 1
+            for identifier in sorted(identifiers):
+                locale = Locale.parse(identifier)
+                print(f"{identifier:<{id_width}} {locale.english_name}")
+            return 0
+
+        if not args:
+            self.parser.error('no valid command or option passed. '
+                              'Try the -h/--help option for more information.')
+
+        cmdname = args[0]
+        if cmdname not in self.commands:
+            self.parser.error(f'unknown command "{cmdname}"')
+
+        cmdinst = self._configure_command(cmdname, args[1:])
+        return cmdinst.run()
+
+    def _configure_logging(self, loglevel):
+        self.log = log
+        self.log.setLevel(loglevel)
+        # Don't add a new handler for every instance initialization (#227), this
+        # would cause duplicated output when the CommandLineInterface as an
+        # normal Python class.
+        if self.log.handlers:
+            handler = self.log.handlers[0]
+        else:
+            handler = logging.StreamHandler()
+            self.log.addHandler(handler)
+        handler.setLevel(loglevel)
+        formatter = logging.Formatter('%(message)s')
+        handler.setFormatter(formatter)
+
+    def _help(self):
+        print(self.parser.format_help())
+        print("commands:")
+        cmd_width = max(8, max(len(command) for command in self.commands) + 1)
+        for name, description in sorted(self.commands.items()):
+            print(f"  {name:<{cmd_width}} {description}")
+
+    def _configure_command(self, cmdname, argv):
+        """
+        :type cmdname: str
+        :type argv: list[str]
+        """
+        cmdclass = self.command_classes[cmdname]
+        cmdinst = cmdclass()
+        if self.log:
+            cmdinst.log = self.log  # Use our logger, not distutils'.
+        assert isinstance(cmdinst, CommandMixin)
+        cmdinst.initialize_options()
+
+        parser = optparse.OptionParser(
+            usage=self.usage % (cmdname, ''),
+            description=self.commands[cmdname],
+        )
+        as_args: str | None = getattr(cmdclass, "as_args", None)
+        for long, short, help in cmdclass.user_options:
+            name = long.strip("=")
+            default = getattr(cmdinst, name.replace("-", "_"))
+            strs = [f"--{name}"]
+            if short:
+                strs.append(f"-{short}")
+            strs.extend(cmdclass.option_aliases.get(name, ()))
+            choices = cmdclass.option_choices.get(name, None)
+            if name == as_args:
+                parser.usage += f"<{name}>"
+            elif name in cmdclass.boolean_options:
+                parser.add_option(*strs, action="store_true", help=help)
+            elif name in cmdclass.multiple_value_options:
+                parser.add_option(*strs, action="append", help=help, choices=choices)
+            else:
+                parser.add_option(*strs, help=help, default=default, choices=choices)
+        options, args = parser.parse_args(argv)
+
+        if as_args:
+            setattr(options, as_args.replace('-', '_'), args)
+
+        for key, value in vars(options).items():
+            setattr(cmdinst, key, value)
+
+        try:
+            cmdinst.ensure_finalized()
+        except OptionError as err:
+            parser.error(str(err))
+
+        return cmdinst
+
+
+def main():
+    return CommandLineInterface().run(sys.argv)
+
+
+def parse_mapping(fileobj, filename=None):
+    warnings.warn(
+        "parse_mapping is deprecated, use parse_mapping_cfg instead",
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    return parse_mapping_cfg(fileobj, filename)
+
+
+def parse_mapping_cfg(fileobj, filename=None):
+    """Parse an extraction method mapping from a file-like object.
+
+    :param fileobj: a readable file-like object containing the configuration
+                    text to parse
+    :param filename: the name of the file being parsed, for error messages
+    """
+    extractors = {}
+    method_map = []
+    options_map = {}
+
+    parser = RawConfigParser()
+    parser.read_file(fileobj, filename)
+
+    for section in parser.sections():
+        if section == 'extractors':
+            extractors = dict(parser.items(section))
+        else:
+            method, pattern = (part.strip() for part in section.split(':', 1))
+            method_map.append((pattern, method))
+            options_map[pattern] = dict(parser.items(section))
+
+    if extractors:
+        for idx, (pattern, method) in enumerate(method_map):
+            if method in extractors:
+                method = extractors[method]
+            method_map[idx] = (pattern, method)
+
+    return method_map, options_map
+
+
+def _parse_config_object(config: dict, *, filename="(unknown)"):
+    extractors = {}
+    method_map = []
+    options_map = {}
+
+    extractors_read = config.get("extractors", {})
+    if not isinstance(extractors_read, dict):
+        raise ConfigurationError(f"{filename}: extractors: Expected a dictionary, got {type(extractors_read)!r}")
+    for method, callable_spec in extractors_read.items():
+        if not isinstance(method, str):
+            # Impossible via TOML, but could happen with a custom object.
+            raise ConfigurationError(f"{filename}: extractors: Extraction method must be a string, got {method!r}")
+        if not isinstance(callable_spec, str):
+            raise ConfigurationError(f"{filename}: extractors: Callable specification must be a string, got {callable_spec!r}")
+        extractors[method] = callable_spec
+
+    if "mapping" in config:
+        raise ConfigurationError(f"{filename}: 'mapping' is not a valid key, did you mean 'mappings'?")
+
+    mappings_read = config.get("mappings", [])
+    if not isinstance(mappings_read, list):
+        raise ConfigurationError(f"{filename}: mappings: Expected a list, got {type(mappings_read)!r}")
+    for idx, entry in enumerate(mappings_read):
+        if not isinstance(entry, dict):
+            raise ConfigurationError(f"{filename}: mappings[{idx}]: Expected a dictionary, got {type(entry)!r}")
+        entry = entry.copy()
+
+        method = entry.pop("method", None)
+        if not isinstance(method, str):
+            raise ConfigurationError(f"{filename}: mappings[{idx}]: 'method' must be a string, got {method!r}")
+        method = extractors.get(method, method)  # Map the extractor name to the callable now
+
+        pattern = entry.pop("pattern", None)
+        if not isinstance(pattern, (list, str)):
+            raise ConfigurationError(f"{filename}: mappings[{idx}]: 'pattern' must be a list or a string, got {pattern!r}")
+        if not isinstance(pattern, list):
+            pattern = [pattern]
+
+        for pat in pattern:
+            if not isinstance(pat, str):
+                raise ConfigurationError(f"{filename}: mappings[{idx}]: 'pattern' elements must be strings, got {pat!r}")
+            method_map.append((pat, method))
+            options_map[pat] = entry
+
+    return method_map, options_map
+
+
+def _parse_mapping_toml(
+    fileobj: BinaryIO,
+    filename: str = "(unknown)",
+    style: Literal["standalone", "pyproject.toml"] = "standalone",
+):
+    """Parse an extraction method mapping from a binary file-like object.
+
+    .. warning: As of this version of Babel, this is a private API subject to changes.
+
+    :param fileobj: a readable binary file-like object containing the configuration TOML to parse
+    :param filename: the name of the file being parsed, for error messages
+    :param style: whether the file is in the style of a `pyproject.toml` file, i.e. whether to look for `tool.babel`.
+    """
+    try:
+        import tomllib
+    except ImportError:
+        try:
+            import tomli as tomllib
+        except ImportError as ie:  # pragma: no cover
+            raise ImportError("tomli or tomllib is required to parse TOML files") from ie
+
+    try:
+        parsed_data = tomllib.load(fileobj)
+    except tomllib.TOMLDecodeError as e:
+        raise ConfigurationError(f"{filename}: Error parsing TOML file: {e}") from e
+
+    if style == "pyproject.toml":
+        try:
+            babel_data = parsed_data["tool"]["babel"]
+        except (TypeError, KeyError) as e:
+            raise ConfigurationError(f"{filename}: No 'tool.babel' section found in file") from e
+    elif style == "standalone":
+        babel_data = parsed_data
+        if "babel" in babel_data:
+            raise ConfigurationError(f"{filename}: 'babel' should not be present in a stand-alone configuration file")
+    else:  # pragma: no cover
+        raise ValueError(f"Unknown TOML style {style!r}")
+
+    return _parse_config_object(babel_data, filename=filename)
+
+
+def _parse_spec(s: str) -> tuple[int | None, tuple[int | tuple[int, str], ...]]:
+    inds = []
+    number = None
+    for x in s.split(','):
+        if x[-1] == 't':
+            number = int(x[:-1])
+        elif x[-1] == 'c':
+            inds.append((int(x[:-1]), 'c'))
+        else:
+            inds.append(int(x))
+    return number, tuple(inds)
+
+
+def parse_keywords(strings: Iterable[str] = ()):
+    """Parse keywords specifications from the given list of strings.
+
+    >>> import pprint
+    >>> keywords = ['_', 'dgettext:2', 'dngettext:2,3', 'pgettext:1c,2',
+    ...             'polymorphic:1', 'polymorphic:2,2t', 'polymorphic:3c,3t']
+    >>> pprint.pprint(parse_keywords(keywords))
+    {'_': None,
+     'dgettext': (2,),
+     'dngettext': (2, 3),
+     'pgettext': ((1, 'c'), 2),
+     'polymorphic': {None: (1,), 2: (2,), 3: ((3, 'c'),)}}
+
+    The input keywords are in GNU Gettext style; see :doc:`cmdline` for details.
+
+    The output is a dictionary mapping keyword names to a dictionary of specifications.
+    Keys in this dictionary are numbers of arguments, where ``None`` means that all numbers
+    of arguments are matched, and a number means only calls with that number of arguments
+    are matched (which happens when using the "t" specifier). However, as a special
+    case for backwards compatibility, if the dictionary of specifications would
+    be ``{None: x}``, i.e., there is only one specification and it matches all argument
+    counts, then it is collapsed into just ``x``.
+
+    A specification is either a tuple or None. If a tuple, each element can be either a number
+    ``n``, meaning that the nth argument should be extracted as a message, or the tuple
+    ``(n, 'c')``, meaning that the nth argument should be extracted as context for the
+    messages. A ``None`` specification is equivalent to ``(1,)``, extracting the first
+    argument.
+    """
+    keywords = {}
+    for string in strings:
+        if ':' in string:
+            funcname, spec_str = string.split(':')
+            number, spec = _parse_spec(spec_str)
+        else:
+            funcname = string
+            number = None
+            spec = None
+        keywords.setdefault(funcname, {})[number] = spec
+
+    # For best backwards compatibility, collapse {None: x} into x.
+    for k, v in keywords.items():
+        if set(v) == {None}:
+            keywords[k] = v[None]
+
+    return keywords
+
+
+def __getattr__(name: str):
+    # Re-exports for backwards compatibility;
+    # `setuptools_frontend` is the canonical import location.
+    if name in {'check_message_extractors', 'compile_catalog', 'extract_messages', 'init_catalog', 'update_catalog'}:
+        from babel.messages import setuptools_frontend
+
+        return getattr(setuptools_frontend, name)
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+if __name__ == '__main__':
+    main()

lib/python3.10/site-packages/babel/messages/jslexer.py

@@ -0,0 +1,204 @@
+"""
+    babel.messages.jslexer
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    A simple JavaScript 1.5 lexer which is used for the JavaScript
+    extractor.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from __future__ import annotations
+
+import re
+from collections.abc import Generator
+from typing import NamedTuple
+
+operators: list[str] = sorted([
+    '+', '-', '*', '%', '!=', '==', '<', '>', '<=', '>=', '=',
+    '+=', '-=', '*=', '%=', '<<', '>>', '>>>', '<<=', '>>=',
+    '>>>=', '&', '&=', '|', '|=', '&&', '||', '^', '^=', '(', ')',
+    '[', ']', '{', '}', '!', '--', '++', '~', ',', ';', '.', ':',
+], key=len, reverse=True)
+
+escapes: dict[str, str] = {'b': '\b', 'f': '\f', 'n': '\n', 'r': '\r', 't': '\t'}
+
+name_re = re.compile(r'[\w$_][\w\d$_]*', re.UNICODE)
+dotted_name_re = re.compile(r'[\w$_][\w\d$_.]*[\w\d$_.]', re.UNICODE)
+division_re = re.compile(r'/=?')
+regex_re = re.compile(r'/(?:[^/\\]*(?:\\.[^/\\]*)*)/[a-zA-Z]*', re.DOTALL)
+line_re = re.compile(r'(\r\n|\n|\r)')
+line_join_re = re.compile(r'\\' + line_re.pattern)
+uni_escape_re = re.compile(r'[a-fA-F0-9]{1,4}')
+hex_escape_re = re.compile(r'[a-fA-F0-9]{1,2}')
+
+
+class Token(NamedTuple):
+    type: str
+    value: str
+    lineno: int
+
+
+_rules: list[tuple[str | None, re.Pattern[str]]] = [
+    (None, re.compile(r'\s+', re.UNICODE)),
+    (None, re.compile(r'<!--.*')),
+    ('linecomment', re.compile(r'//.*')),
+    ('multilinecomment', re.compile(r'/\*.*?\*/', re.UNICODE | re.DOTALL)),
+    ('dotted_name', dotted_name_re),
+    ('name', name_re),
+    ('number', re.compile(r'''(
+        (?:0|[1-9]\d*)
+        (\.\d+)?
+        ([eE][-+]?\d+)? |
+        (0x[a-fA-F0-9]+)
+    )''', re.VERBOSE)),
+    ('jsx_tag', re.compile(r'(?:</?[^>\s]+|/>)', re.I)),  # May be mangled in `get_rules`
+    ('operator', re.compile(r'(%s)' % '|'.join(map(re.escape, operators)))),
+    ('template_string', re.compile(r'''`(?:[^`\\]*(?:\\.[^`\\]*)*)`''', re.UNICODE)),
+    ('string', re.compile(r'''(
+        '(?:[^'\\]*(?:\\.[^'\\]*)*)'  |
+        "(?:[^"\\]*(?:\\.[^"\\]*)*)"
+    )''', re.VERBOSE | re.DOTALL)),
+]
+
+
+def get_rules(jsx: bool, dotted: bool, template_string: bool) -> list[tuple[str | None, re.Pattern[str]]]:
+    """
+    Get a tokenization rule list given the passed syntax options.
+
+    Internal to this module.
+    """
+    rules = []
+    for token_type, rule in _rules:
+        if not jsx and token_type and 'jsx' in token_type:
+            continue
+        if not template_string and token_type == 'template_string':
+            continue
+        if token_type == 'dotted_name':
+            if not dotted:
+                continue
+            token_type = 'name'
+        rules.append((token_type, rule))
+    return rules
+
+
+def indicates_division(token: Token) -> bool:
+    """A helper function that helps the tokenizer to decide if the current
+    token may be followed by a division operator.
+    """
+    if token.type == 'operator':
+        return token.value in (')', ']', '}', '++', '--')
+    return token.type in ('name', 'number', 'string', 'regexp')
+
+
+def unquote_string(string: str) -> str:
+    """Unquote a string with JavaScript rules.  The string has to start with
+    string delimiters (``'``, ``"`` or the back-tick/grave accent (for template strings).)
+    """
+    assert string and string[0] == string[-1] and string[0] in '"\'`', \
+        'string provided is not properly delimited'
+    string = line_join_re.sub('\\1', string[1:-1])
+    result: list[str] = []
+    add = result.append
+    pos = 0
+
+    while True:
+        # scan for the next escape
+        escape_pos = string.find('\\', pos)
+        if escape_pos < 0:
+            break
+        add(string[pos:escape_pos])
+
+        # check which character is escaped
+        next_char = string[escape_pos + 1]
+        if next_char in escapes:
+            add(escapes[next_char])
+
+        # unicode escapes.  trie to consume up to four characters of
+        # hexadecimal characters and try to interpret them as unicode
+        # character point.  If there is no such character point, put
+        # all the consumed characters into the string.
+        elif next_char in 'uU':
+            escaped = uni_escape_re.match(string, escape_pos + 2)
+            if escaped is not None:
+                escaped_value = escaped.group()
+                if len(escaped_value) == 4:
+                    try:
+                        add(chr(int(escaped_value, 16)))
+                    except ValueError:
+                        pass
+                    else:
+                        pos = escape_pos + 6
+                        continue
+                add(next_char + escaped_value)
+                pos = escaped.end()
+                continue
+            else:
+                add(next_char)
+
+        # hex escapes. conversion from 2-digits hex to char is infallible
+        elif next_char in 'xX':
+            escaped = hex_escape_re.match(string, escape_pos + 2)
+            if escaped is not None:
+                escaped_value = escaped.group()
+                add(chr(int(escaped_value, 16)))
+                pos = escape_pos + 2 + len(escaped_value)
+                continue
+            else:
+                add(next_char)
+
+        # bogus escape.  Just remove the backslash.
+        else:
+            add(next_char)
+        pos = escape_pos + 2
+
+    if pos < len(string):
+        add(string[pos:])
+
+    return ''.join(result)
+
+
+def tokenize(source: str, jsx: bool = True, dotted: bool = True, template_string: bool = True, lineno: int = 1) -> Generator[Token, None, None]:
+    """
+    Tokenize JavaScript/JSX source.  Returns a generator of tokens.
+
+    :param source: The JavaScript source to tokenize.
+    :param jsx: Enable (limited) JSX parsing.
+    :param dotted: Read dotted names as single name token.
+    :param template_string: Support ES6 template strings
+    :param lineno: starting line number (optional)
+    """
+    may_divide = False
+    pos = 0
+    end = len(source)
+    rules = get_rules(jsx=jsx, dotted=dotted, template_string=template_string)
+
+    while pos < end:
+        # handle regular rules first
+        for token_type, rule in rules:  # noqa: B007
+            match = rule.match(source, pos)
+            if match is not None:
+                break
+        # if we don't have a match we don't give up yet, but check for
+        # division operators or regular expression literals, based on
+        # the status of `may_divide` which is determined by the last
+        # processed non-whitespace token using `indicates_division`.
+        else:
+            if may_divide:
+                match = division_re.match(source, pos)
+                token_type = 'operator'
+            else:
+                match = regex_re.match(source, pos)
+                token_type = 'regexp'
+            if match is None:
+                # woops. invalid syntax. jump one char ahead and try again.
+                pos += 1
+                continue
+
+        token_value = match.group()
+        if token_type is not None:
+            token = Token(token_type, token_value, lineno)
+            may_divide = indicates_division(token)
+            yield token
+        lineno += len(line_re.findall(token_value))
+        pos = match.end()

lib/python3.10/site-packages/babel/messages/mofile.py

@@ -0,0 +1,210 @@
+"""
+    babel.messages.mofile
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Writing of files in the ``gettext`` MO (machine object) format.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from __future__ import annotations
+
+import array
+import struct
+from typing import TYPE_CHECKING
+
+from babel.messages.catalog import Catalog, Message
+
+if TYPE_CHECKING:
+    from _typeshed import SupportsRead, SupportsWrite
+
+LE_MAGIC: int = 0x950412de
+BE_MAGIC: int = 0xde120495
+
+
+def read_mo(fileobj: SupportsRead[bytes]) -> Catalog:
+    """Read a binary MO file from the given file-like object and return a
+    corresponding `Catalog` object.
+
+    :param fileobj: the file-like object to read the MO file from
+
+    :note: The implementation of this function is heavily based on the
+           ``GNUTranslations._parse`` method of the ``gettext`` module in the
+           standard library.
+    """
+    catalog = Catalog()
+    headers = {}
+
+    filename = getattr(fileobj, 'name', '')
+
+    buf = fileobj.read()
+    buflen = len(buf)
+    unpack = struct.unpack
+
+    # Parse the .mo file header, which consists of 5 little endian 32
+    # bit words.
+    magic = unpack('<I', buf[:4])[0]  # Are we big endian or little endian?
+    if magic == LE_MAGIC:
+        version, msgcount, origidx, transidx = unpack('<4I', buf[4:20])
+        ii = '<II'
+    elif magic == BE_MAGIC:
+        version, msgcount, origidx, transidx = unpack('>4I', buf[4:20])
+        ii = '>II'
+    else:
+        raise OSError(0, 'Bad magic number', filename)
+
+    # Now put all messages from the .mo file buffer into the catalog
+    # dictionary
+    for _i in range(msgcount):
+        mlen, moff = unpack(ii, buf[origidx:origidx + 8])
+        mend = moff + mlen
+        tlen, toff = unpack(ii, buf[transidx:transidx + 8])
+        tend = toff + tlen
+        if mend < buflen and tend < buflen:
+            msg = buf[moff:mend]
+            tmsg = buf[toff:tend]
+        else:
+            raise OSError(0, 'File is corrupt', filename)
+
+        # See if we're looking at GNU .mo conventions for metadata
+        if mlen == 0:
+            # Catalog description
+            lastkey = key = None
+            for item in tmsg.splitlines():
+                item = item.strip()
+                if not item:
+                    continue
+                if b':' in item:
+                    key, value = item.split(b':', 1)
+                    lastkey = key = key.strip().lower()
+                    headers[key] = value.strip()
+                elif lastkey:
+                    headers[lastkey] += b'\n' + item
+
+        if b'\x04' in msg:  # context
+            ctxt, msg = msg.split(b'\x04')
+        else:
+            ctxt = None
+
+        if b'\x00' in msg:  # plural forms
+            msg = msg.split(b'\x00')
+            tmsg = tmsg.split(b'\x00')
+            msg = [x.decode(catalog.charset) for x in msg]
+            tmsg = [x.decode(catalog.charset) for x in tmsg]
+        else:
+            msg = msg.decode(catalog.charset)
+            tmsg = tmsg.decode(catalog.charset)
+        catalog[msg] = Message(msg, tmsg, context=ctxt)
+
+        # advance to next entry in the seek tables
+        origidx += 8
+        transidx += 8
+
+    catalog.mime_headers = headers.items()
+    return catalog
+
+
+def write_mo(fileobj: SupportsWrite[bytes], catalog: Catalog, use_fuzzy: bool = False) -> None:
+    """Write a catalog to the specified file-like object using the GNU MO file
+    format.
+
+    >>> import sys
+    >>> from babel.messages import Catalog
+    >>> from gettext import GNUTranslations
+    >>> from io import BytesIO
+
+    >>> catalog = Catalog(locale='en_US')
+    >>> catalog.add('foo', 'Voh')
+    <Message ...>
+    >>> catalog.add((u'bar', u'baz'), (u'Bahr', u'Batz'))
+    <Message ...>
+    >>> catalog.add('fuz', 'Futz', flags=['fuzzy'])
+    <Message ...>
+    >>> catalog.add('Fizz', '')
+    <Message ...>
+    >>> catalog.add(('Fuzz', 'Fuzzes'), ('', ''))
+    <Message ...>
+    >>> buf = BytesIO()
+
+    >>> write_mo(buf, catalog)
+    >>> x = buf.seek(0)
+    >>> translations = GNUTranslations(fp=buf)
+    >>> if sys.version_info[0] >= 3:
+    ...     translations.ugettext = translations.gettext
+    ...     translations.ungettext = translations.ngettext
+    >>> translations.ugettext('foo')
+    u'Voh'
+    >>> translations.ungettext('bar', 'baz', 1)
+    u'Bahr'
+    >>> translations.ungettext('bar', 'baz', 2)
+    u'Batz'
+    >>> translations.ugettext('fuz')
+    u'fuz'
+    >>> translations.ugettext('Fizz')
+    u'Fizz'
+    >>> translations.ugettext('Fuzz')
+    u'Fuzz'
+    >>> translations.ugettext('Fuzzes')
+    u'Fuzzes'
+
+    :param fileobj: the file-like object to write to
+    :param catalog: the `Catalog` instance
+    :param use_fuzzy: whether translations marked as "fuzzy" should be included
+                      in the output
+    """
+    messages = list(catalog)
+    messages[1:] = [m for m in messages[1:]
+                    if m.string and (use_fuzzy or not m.fuzzy)]
+    messages.sort()
+
+    ids = strs = b''
+    offsets = []
+
+    for message in messages:
+        # For each string, we need size and file offset.  Each string is NUL
+        # terminated; the NUL does not count into the size.
+        if message.pluralizable:
+            msgid = b'\x00'.join([
+                msgid.encode(catalog.charset) for msgid in message.id
+            ])
+            msgstrs = []
+            for idx, string in enumerate(message.string):
+                if not string:
+                    msgstrs.append(message.id[min(int(idx), 1)])
+                else:
+                    msgstrs.append(string)
+            msgstr = b'\x00'.join([
+                msgstr.encode(catalog.charset) for msgstr in msgstrs
+            ])
+        else:
+            msgid = message.id.encode(catalog.charset)
+            msgstr = message.string.encode(catalog.charset)
+        if message.context:
+            msgid = b'\x04'.join([message.context.encode(catalog.charset),
+                                  msgid])
+        offsets.append((len(ids), len(msgid), len(strs), len(msgstr)))
+        ids += msgid + b'\x00'
+        strs += msgstr + b'\x00'
+
+    # The header is 7 32-bit unsigned integers.  We don't use hash tables, so
+    # the keys start right after the index tables.
+    keystart = 7 * 4 + 16 * len(messages)
+    valuestart = keystart + len(ids)
+
+    # The string table first has the list of keys, then the list of values.
+    # Each entry has first the size of the string, then the file offset.
+    koffsets = []
+    voffsets = []
+    for o1, l1, o2, l2 in offsets:
+        koffsets += [l1, o1 + keystart]
+        voffsets += [l2, o2 + valuestart]
+    offsets = koffsets + voffsets
+
+    fileobj.write(struct.pack('Iiiiiii',
+                              LE_MAGIC,                   # magic
+                              0,                          # version
+                              len(messages),              # number of entries
+                              7 * 4,                      # start of key index
+                              7 * 4 + len(messages) * 8,  # start of value index
+                              0, 0,                       # size and offset of hash table
+                              ) + array.array.tobytes(array.array("i", offsets)) + ids + strs)

lib/python3.10/site-packages/babel/messages/plurals.py

@@ -0,0 +1,266 @@
+"""
+    babel.messages.plurals
+    ~~~~~~~~~~~~~~~~~~~~~~
+
+    Plural form definitions.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from __future__ import annotations
+
+from babel.core import Locale, default_locale
+
+# XXX: remove this file, duplication with babel.plural
+
+
+LC_CTYPE: str | None = default_locale('LC_CTYPE')
+
+
+PLURALS: dict[str, tuple[int, str]] = {
+    # Afar
+    # 'aa': (),
+    # Abkhazian
+    # 'ab': (),
+    # Avestan
+    # 'ae': (),
+    # Afrikaans - From Pootle's PO's
+    'af': (2, '(n != 1)'),
+    # Akan
+    # 'ak': (),
+    # Amharic
+    # 'am': (),
+    # Aragonese
+    # 'an': (),
+    # Arabic - From Pootle's PO's
+    'ar': (6, '(n==0 ? 0 : n==1 ? 1 : n==2 ? 2 : n%100>=3 && n%100<=10 ? 3 : n%100>=0 && n%100<=2 ? 4 : 5)'),
+    # Assamese
+    # 'as': (),
+    # Avaric
+    # 'av': (),
+    # Aymara
+    # 'ay': (),
+    # Azerbaijani
+    # 'az': (),
+    # Bashkir
+    # 'ba': (),
+    # Belarusian
+    'be': (3, '(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)'),
+    # Bulgarian - From Pootle's PO's
+    'bg': (2, '(n != 1)'),
+    # Bihari
+    # 'bh': (),
+    # Bislama
+    # 'bi': (),
+    # Bambara
+    # 'bm': (),
+    # Bengali - From Pootle's PO's
+    'bn': (2, '(n != 1)'),
+    # Tibetan - as discussed in private with Andrew West
+    'bo': (1, '0'),
+    # Breton
+    'br': (
+        6,
+        '(n==1 ? 0 : n%10==1 && n%100!=11 && n%100!=71 && n%100!=91 ? 1 : n%10==2 && n%100!=12 && n%100!=72 && '
+        'n%100!=92 ? 2 : (n%10==3 || n%10==4 || n%10==9) && n%100!=13 && n%100!=14 && n%100!=19 && n%100!=73 && '
+        'n%100!=74 && n%100!=79 && n%100!=93 && n%100!=94 && n%100!=99 ? 3 : n%1000000==0 ? 4 : 5)',
+    ),
+    # Bosnian
+    'bs': (3, '(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)'),
+    # Catalan - From Pootle's PO's
+    'ca': (2, '(n != 1)'),
+    # Chechen
+    # 'ce': (),
+    # Chamorro
+    # 'ch': (),
+    # Corsican
+    # 'co': (),
+    # Cree
+    # 'cr': (),
+    # Czech
+    'cs': (3, '((n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2)'),
+    # Church Slavic
+    # 'cu': (),
+    # Chuvash
+    'cv': (1, '0'),
+    # Welsh
+    'cy': (5, '(n==1 ? 1 : n==2 ? 2 : n==3 ? 3 : n==6 ? 4 : 0)'),
+    # Danish
+    'da': (2, '(n != 1)'),
+    # German
+    'de': (2, '(n != 1)'),
+    # Divehi
+    # 'dv': (),
+    # Dzongkha
+    'dz': (1, '0'),
+    # Greek
+    'el': (2, '(n != 1)'),
+    # English
+    'en': (2, '(n != 1)'),
+    # Esperanto
+    'eo': (2, '(n != 1)'),
+    # Spanish
+    'es': (2, '(n != 1)'),
+    # Estonian
+    'et': (2, '(n != 1)'),
+    # Basque - From Pootle's PO's
+    'eu': (2, '(n != 1)'),
+    # Persian - From Pootle's PO's
+    'fa': (1, '0'),
+    # Finnish
+    'fi': (2, '(n != 1)'),
+    # French
+    'fr': (2, '(n > 1)'),
+    # Friulian - From Pootle's PO's
+    'fur': (2, '(n > 1)'),
+    # Irish
+    'ga': (5, '(n==1 ? 0 : n==2 ? 1 : n>=3 && n<=6 ? 2 : n>=7 && n<=10 ? 3 : 4)'),
+    # Galician - From Pootle's PO's
+    'gl': (2, '(n != 1)'),
+    # Hausa - From Pootle's PO's
+    'ha': (2, '(n != 1)'),
+    # Hebrew
+    'he': (2, '(n != 1)'),
+    # Hindi - From Pootle's PO's
+    'hi': (2, '(n != 1)'),
+    # Croatian
+    'hr': (3, '(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)'),
+    # Hungarian
+    'hu': (1, '0'),
+    # Armenian - From Pootle's PO's
+    'hy': (1, '0'),
+    # Icelandic - From Pootle's PO's
+    'is': (2, '(n%10==1 && n%100!=11 ? 0 : 1)'),
+    # Italian
+    'it': (2, '(n != 1)'),
+    # Japanese
+    'ja': (1, '0'),
+    # Georgian - From Pootle's PO's
+    'ka': (1, '0'),
+    # Kongo - From Pootle's PO's
+    'kg': (2, '(n != 1)'),
+    # Khmer - From Pootle's PO's
+    'km': (1, '0'),
+    # Korean
+    'ko': (1, '0'),
+    # Kurdish - From Pootle's PO's
+    'ku': (2, '(n != 1)'),
+    # Lao - Another member of the Tai language family, like Thai.
+    'lo': (1, '0'),
+    # Lithuanian
+    'lt': (3, '(n%10==1 && n%100!=11 ? 0 : n%10>=2 && (n%100<10 || n%100>=20) ? 1 : 2)'),
+    # Latvian
+    'lv': (3, '(n%10==1 && n%100!=11 ? 0 : n != 0 ? 1 : 2)'),
+    # Maltese - From Pootle's PO's
+    'mt': (4, '(n==1 ? 0 : n==0 || ( n%100>=1 && n%100<=10) ? 1 : (n%100>10 && n%100<20 ) ? 2 : 3)'),
+    # Norwegian Bokmål
+    'nb': (2, '(n != 1)'),
+    # Dutch
+    'nl': (2, '(n != 1)'),
+    # Norwegian Nynorsk
+    'nn': (2, '(n != 1)'),
+    # Norwegian
+    'no': (2, '(n != 1)'),
+    # Punjabi - From Pootle's PO's
+    'pa': (2, '(n != 1)'),
+    # Polish
+    'pl': (3, '(n==1 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)'),
+    # Portuguese
+    'pt': (2, '(n != 1)'),
+    # Brazilian
+    'pt_BR': (2, '(n > 1)'),
+    # Romanian - From Pootle's PO's
+    'ro': (3, '(n==1 ? 0 : (n==0 || (n%100 > 0 && n%100 < 20)) ? 1 : 2)'),
+    # Russian
+    'ru': (3, '(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)'),
+    # Slovak
+    'sk': (3, '((n==1) ? 0 : (n>=2 && n<=4) ? 1 : 2)'),
+    # Slovenian
+    'sl': (4, '(n%100==1 ? 0 : n%100==2 ? 1 : n%100==3 || n%100==4 ? 2 : 3)'),
+    # Serbian - From Pootle's PO's
+    'sr': (3, '(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)'),
+    # Southern Sotho - From Pootle's PO's
+    'st': (2, '(n != 1)'),
+    # Swedish
+    'sv': (2, '(n != 1)'),
+    # Thai
+    'th': (1, '0'),
+    # Turkish
+    'tr': (1, '0'),
+    # Ukrainian
+    'uk': (3, '(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2)'),
+    # Venda - From Pootle's PO's
+    've': (2, '(n != 1)'),
+    # Vietnamese - From Pootle's PO's
+    'vi': (1, '0'),
+    # Xhosa - From Pootle's PO's
+    'xh': (2, '(n != 1)'),
+    # Chinese - From Pootle's PO's (modified)
+    'zh': (1, '0'),
+}
+
+
+DEFAULT_PLURAL: tuple[int, str] = (2, '(n != 1)')
+
+
+class _PluralTuple(tuple):
+    """A tuple with plural information."""
+
+    __slots__ = ()
+
+    @property
+    def num_plurals(self) -> int:
+        """The number of plurals used by the locale."""
+        return self[0]
+
+    @property
+    def plural_expr(self) -> str:
+        """The plural expression used by the locale."""
+        return self[1]
+
+    @property
+    def plural_forms(self) -> str:
+        """The plural expression used by the catalog or locale."""
+        return f'nplurals={self[0]}; plural={self[1]};'
+
+    def __str__(self) -> str:
+        return self.plural_forms
+
+
+def get_plural(locale: Locale | str | None = None) -> _PluralTuple:
+    """A tuple with the information catalogs need to perform proper
+    pluralization.  The first item of the tuple is the number of plural
+    forms, the second the plural expression.
+
+    :param locale: the `Locale` object or locale identifier. Defaults to the system character type locale.
+
+    >>> get_plural(locale='en')
+    (2, '(n != 1)')
+    >>> get_plural(locale='ga')
+    (5, '(n==1 ? 0 : n==2 ? 1 : n>=3 && n<=6 ? 2 : n>=7 && n<=10 ? 3 : 4)')
+
+    The object returned is a special tuple with additional members:
+
+    >>> tup = get_plural("ja")
+    >>> tup.num_plurals
+    1
+    >>> tup.plural_expr
+    '0'
+    >>> tup.plural_forms
+    'nplurals=1; plural=0;'
+
+    Converting the tuple into a string prints the plural forms for a
+    gettext catalog:
+
+    >>> str(tup)
+    'nplurals=1; plural=0;'
+    """
+    locale = Locale.parse(locale or LC_CTYPE)
+    try:
+        tup = PLURALS[str(locale)]
+    except KeyError:
+        try:
+            tup = PLURALS[locale.language]
+        except KeyError:
+            tup = DEFAULT_PLURAL
+    return _PluralTuple(tup)

lib/python3.10/site-packages/babel/messages/pofile.py

@@ -0,0 +1,744 @@
+"""
+    babel.messages.pofile
+    ~~~~~~~~~~~~~~~~~~~~~
+
+    Reading and writing of files in the ``gettext`` PO (portable object)
+    format.
+
+    :copyright: (c) 2013-2025 by the Babel Team.
+    :license: BSD, see LICENSE for more details.
+"""
+from __future__ import annotations
+
+import os
+import re
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Literal
+
+from babel.core import Locale
+from babel.messages.catalog import Catalog, Message
+from babel.util import TextWrapper, _cmp
+
+if TYPE_CHECKING:
+    from typing import IO, AnyStr
+
+    from _typeshed import SupportsWrite
+
+
+def unescape(string: str) -> str:
+    r"""Reverse `escape` the given string.
+
+    >>> print(unescape('"Say:\\n  \\"hello, world!\\"\\n"'))
+    Say:
+      "hello, world!"
+    <BLANKLINE>
+
+    :param string: the string to unescape
+    """
+    def replace_escapes(match):
+        m = match.group(1)
+        if m == 'n':
+            return '\n'
+        elif m == 't':
+            return '\t'
+        elif m == 'r':
+            return '\r'
+        # m is \ or "
+        return m
+    return re.compile(r'\\([\\trn"])').sub(replace_escapes, string[1:-1])
+
+
+def denormalize(string: str) -> str:
+    r"""Reverse the normalization done by the `normalize` function.
+
+    >>> print(denormalize(r'''""
+    ... "Say:\n"
+    ... "  \"hello, world!\"\n"'''))
+    Say:
+      "hello, world!"
+    <BLANKLINE>
+
+    >>> print(denormalize(r'''""
+    ... "Say:\n"
+    ... "  \"Lorem ipsum dolor sit "
+    ... "amet, consectetur adipisicing"
+    ... " elit, \"\n"'''))
+    Say:
+      "Lorem ipsum dolor sit amet, consectetur adipisicing elit, "
+    <BLANKLINE>
+
+    :param string: the string to denormalize
+    """
+    if '\n' in string:
+        escaped_lines = string.splitlines()
+        if string.startswith('""'):
+            escaped_lines = escaped_lines[1:]
+        lines = map(unescape, escaped_lines)
+        return ''.join(lines)
+    else:
+        return unescape(string)
+
+
+def _extract_locations(line: str) -> list[str]:
+    """Extract locations from location comments.
+
+    Locations are extracted while properly handling First Strong
+    Isolate (U+2068) and Pop Directional Isolate (U+2069), used by
+    gettext to enclose filenames with spaces and tabs in their names.
+    """
+    if "\u2068" not in line and "\u2069" not in line:
+        return line.lstrip().split()
+
+    locations = []
+    location = ""
+    in_filename = False
+    for c in line:
+        if c == "\u2068":
+            if in_filename:
+                raise ValueError("location comment contains more First Strong Isolate "
+                                 "characters, than Pop Directional Isolate characters")
+            in_filename = True
+            continue
+        elif c == "\u2069":
+            if not in_filename:
+                raise ValueError("location comment contains more Pop Directional Isolate "
+                                 "characters, than First Strong Isolate characters")
+            in_filename = False
+            continue
+        elif c == " ":
+            if in_filename:
+                location += c
+            elif location:
+                locations.append(location)
+                location = ""
+        else:
+            location += c
+    else:
+        if location:
+            if in_filename:
+                raise ValueError("location comment contains more First Strong Isolate "
+                                 "characters, than Pop Directional Isolate characters")
+            locations.append(location)
+
+    return locations
+
+
+class PoFileError(Exception):
+    """Exception thrown by PoParser when an invalid po file is encountered."""
+
+    def __init__(self, message: str, catalog: Catalog, line: str, lineno: int) -> None:
+        super().__init__(f'{message} on {lineno}')
+        self.catalog = catalog
+        self.line = line
+        self.lineno = lineno
+
+
+class _NormalizedString:
+
+    def __init__(self, *args: str) -> None:
+        self._strs: list[str] = []
+        for arg in args:
+            self.append(arg)
+
+    def append(self, s: str) -> None:
+        self._strs.append(s.strip())
+
+    def denormalize(self) -> str:
+        return ''.join(map(unescape, self._strs))
+
+    def __bool__(self) -> bool:
+        return bool(self._strs)
+
+    def __repr__(self) -> str:
+        return os.linesep.join(self._strs)
+
+    def __cmp__(self, other: object) -> int:
+        if not other:
+            return 1
+
+        return _cmp(str(self), str(other))
+
+    def __gt__(self, other: object) -> bool:
+        return self.__cmp__(other) > 0
+
+    def __lt__(self, other: object) -> bool:
+        return self.__cmp__(other) < 0
+
+    def __ge__(self, other: object) -> bool:
+        return self.__cmp__(other) >= 0
+
+    def __le__(self, other: object) -> bool:
+        return self.__cmp__(other) <= 0
+
+    def __eq__(self, other: object) -> bool:
+        return self.__cmp__(other) == 0
+
+    def __ne__(self, other: object) -> bool:
+        return self.__cmp__(other) != 0
+
+
+class PoFileParser:
+    """Support class to  read messages from a ``gettext`` PO (portable object) file
+    and add them to a `Catalog`
+
+    See `read_po` for simple cases.
+    """
+
+    _keywords = [
+        'msgid',
+        'msgstr',
+        'msgctxt',
+        'msgid_plural',
+    ]
+
+    def __init__(self, catalog: Catalog, ignore_obsolete: bool = False, abort_invalid: bool = False) -> None:
+        self.catalog = catalog
+        self.ignore_obsolete = ignore_obsolete
+        self.counter = 0
+        self.offset = 0
+        self.abort_invalid = abort_invalid
+        self._reset_message_state()
+
+    def _reset_message_state(self) -> None:
+        self.messages = []
+        self.translations = []
+        self.locations = []
+        self.flags = []
+        self.user_comments = []
+        self.auto_comments = []
+        self.context = None
+        self.obsolete = False
+        self.in_msgid = False
+        self.in_msgstr = False
+        self.in_msgctxt = False
+
+    def _add_message(self) -> None:
+        """
+        Add a message to the catalog based on the current parser state and
+        clear the state ready to process the next message.
+        """
+        self.translations.sort()
+        if len(self.messages) > 1:
+            msgid = tuple(m.denormalize() for m in self.messages)
+        else:
+            msgid = self.messages[0].denormalize()
+        if isinstance(msgid, (list, tuple)):
+            string = ['' for _ in range(self.catalog.num_plurals)]
+            for idx, translation in self.translations:
+                if idx >= self.catalog.num_plurals:
+                    self._invalid_pofile("", self.offset, "msg has more translations than num_plurals of catalog")
+                    continue
+                string[idx] = translation.denormalize()
+            string = tuple(string)
+        else:
+            string = self.translations[0][1].denormalize()
+        msgctxt = self.context.denormalize() if self.context else None
+        message = Message(msgid, string, list(self.locations), set(self.flags),
+                          self.auto_comments, self.user_comments, lineno=self.offset + 1,
+                          context=msgctxt)
+        if self.obsolete:
+            if not self.ignore_obsolete:
+                self.catalog.obsolete[self.catalog._key_for(msgid, msgctxt)] = message
+        else:
+            self.catalog[msgid] = message
+        self.counter += 1
+        self._reset_message_state()
+
+    def _finish_current_message(self) -> None:
+        if self.messages:
+            if not self.translations:
+                self._invalid_pofile("", self.offset, f"missing msgstr for msgid '{self.messages[0].denormalize()}'")
+                self.translations.append([0, _NormalizedString("")])
+            self._add_message()
+
+    def _process_message_line(self, lineno, line, obsolete=False) -> None:
+        if line.startswith('"'):
+            self._process_string_continuation_line(line, lineno)
+        else:
+            self._process_keyword_line(lineno, line, obsolete)
+
+    def _process_keyword_line(self, lineno, line, obsolete=False) -> None:
+
+        for keyword in self._keywords:
+            try:
+                if line.startswith(keyword) and line[len(keyword)] in [' ', '[']:
+                    arg = line[len(keyword):]
+                    break
+            except IndexError:
+                self._invalid_pofile(line, lineno, "Keyword must be followed by a string")
+        else:
+            self._invalid_pofile(line, lineno, "Start of line didn't match any expected keyword.")
+            return
+
+        if keyword in ['msgid', 'msgctxt']:
+            self._finish_current_message()
+
+        self.obsolete = obsolete
+
+        # The line that has the msgid is stored as the offset of the msg
+        # should this be the msgctxt if it has one?
+        if keyword == 'msgid':
+            self.offset = lineno
+
+        if keyword in ['msgid', 'msgid_plural']:
+            self.in_msgctxt = False
+            self.in_msgid = True
+            self.messages.append(_NormalizedString(arg))
+
+        elif keyword == 'msgstr':
+            self.in_msgid = False
+            self.in_msgstr = True
+            if arg.startswith('['):
+                idx, msg = arg[1:].split(']', 1)
+                self.translations.append([int(idx), _NormalizedString(msg)])
+            else:
+                self.translations.append([0, _NormalizedString(arg)])
+
+        elif keyword == 'msgctxt':
+            self.in_msgctxt = True
+            self.context = _NormalizedString(arg)
+
+    def _process_string_continuation_line(self, line, lineno) -> None:
+        if self.in_msgid:
+            s = self.messages[-1]
+        elif self.in_msgstr:
+            s = self.translations[-1][1]
+        elif self.in_msgctxt:
+            s = self.context
+        else:
+            self._invalid_pofile(line, lineno, "Got line starting with \" but not in msgid, msgstr or msgctxt")
+            return
+        s.append(line)
+
+    def _process_comment(self, line) -> None:
+
+        self._finish_current_message()
+
+        if line[1:].startswith(':'):
+            for location in _extract_locations(line[2:]):
+                pos = location.rfind(':')
+                if pos >= 0:
+                    try:
+                        lineno = int(location[pos + 1:])
+                    except ValueError:
+                        continue
+                    self.locations.append((location[:pos], lineno))
+                else:
+                    self.locations.append((location, None))
+        elif line[1:].startswith(','):
+            for flag in line[2:].lstrip().split(','):
+                self.flags.append(flag.strip())
+        elif line[1:].startswith('.'):
+            # These are called auto-comments
+            comment = line[2:].strip()
+            if comment:  # Just check that we're not adding empty comments
+                self.auto_comments.append(comment)
+        else:
+            # These are called user comments
+            self.user_comments.append(line[1:].strip())
+
+    def parse(self, fileobj: IO[AnyStr] | Iterable[AnyStr]) -> None:
+        """
+        Reads from the file-like object `fileobj` and adds any po file
+        units found in it to the `Catalog` supplied to the constructor.
+        """
+
+        for lineno, line in enumerate(fileobj):
+            line = line.strip()
+            if not isinstance(line, str):
+                line = line.decode(self.catalog.charset)
+            if not line:
+                continue
+            if line.startswith('#'):
+                if line[1:].startswith('~'):
+                    self._process_message_line(lineno, line[2:].lstrip(), obsolete=True)
+                else:
+                    try:
+                        self._process_comment(line)
+                    except ValueError as exc:
+                        self._invalid_pofile(line, lineno, str(exc))
+            else:
+                self._process_message_line(lineno, line)
+
+        self._finish_current_message()
+
+        # No actual messages found, but there was some info in comments, from which
+        # we'll construct an empty header message
+        if not self.counter and (self.flags or self.user_comments or self.auto_comments):
+            self.messages.append(_NormalizedString('""'))
+            self.translations.append([0, _NormalizedString('""')])
+            self._add_message()
+
+    def _invalid_pofile(self, line, lineno, msg) -> None:
+        assert isinstance(line, str)
+        if self.abort_invalid:
+            raise PoFileError(msg, self.catalog, line, lineno)
+        print("WARNING:", msg)
+        print(f"WARNING: Problem on line {lineno + 1}: {line!r}")
+
+
+def read_po(
+    fileobj: IO[AnyStr] | Iterable[AnyStr],
+    locale: Locale | str | None = None,
+    domain: str | None = None,
+    ignore_obsolete: bool = False,
+    charset: str | None = None,
+    abort_invalid: bool = False,
+) -> Catalog:
+    """Read messages from a ``gettext`` PO (portable object) file from the given
+    file-like object (or an iterable of lines) and return a `Catalog`.
+
+    >>> from datetime import datetime
+    >>> from io import StringIO
+    >>> buf = StringIO('''
+    ... #: main.py:1
+    ... #, fuzzy, python-format
+    ... msgid "foo %(name)s"
+    ... msgstr "quux %(name)s"
+    ...
+    ... # A user comment
+    ... #. An auto comment
+    ... #: main.py:3
+    ... msgid "bar"
+    ... msgid_plural "baz"
+    ... msgstr[0] "bar"
+    ... msgstr[1] "baaz"
+    ... ''')
+    >>> catalog = read_po(buf)
+    >>> catalog.revision_date = datetime(2007, 4, 1)
+
+    >>> for message in catalog:
+    ...     if message.id:
+    ...         print((message.id, message.string))
+    ...         print(' ', (message.locations, sorted(list(message.flags))))
+    ...         print(' ', (message.user_comments, message.auto_comments))
+    (u'foo %(name)s', u'quux %(name)s')
+      ([(u'main.py', 1)], [u'fuzzy', u'python-format'])
+      ([], [])
+    ((u'bar', u'baz'), (u'bar', u'baaz'))
+      ([(u'main.py', 3)], [])
+      ([u'A user comment'], [u'An auto comment'])
+
+    .. versionadded:: 1.0
+       Added support for explicit charset argument.
+
+    :param fileobj: the file-like object (or iterable of lines) to read the PO file from
+    :param locale: the locale identifier or `Locale` object, or `None`
+                   if the catalog is not bound to a locale (which basically
+                   means it's a template)
+    :param domain: the message domain
+    :param ignore_obsolete: whether to ignore obsolete messages in the input
+    :param charset: the character set of the catalog.
+    :param abort_invalid: abort read if po file is invalid
+    """
+    catalog = Catalog(locale=locale, domain=domain, charset=charset)
+    parser = PoFileParser(catalog, ignore_obsolete, abort_invalid=abort_invalid)
+    parser.parse(fileobj)
+    return catalog
+
+
+WORD_SEP = re.compile('('
+                      r'\s+|'                                 # any whitespace
+                      r'[^\s\w]*\w+[a-zA-Z]-(?=\w+[a-zA-Z])|'  # hyphenated words
+                      r'(?<=[\w\!\"\'\&\.\,\?])-{2,}(?=\w)'   # em-dash
+                      ')')
+
+
+def escape(string: str) -> str:
+    r"""Escape the given string so that it can be included in double-quoted
+    strings in ``PO`` files.
+
+    >>> escape('''Say:
+    ...   "hello, world!"
+    ... ''')
+    '"Say:\\n  \\"hello, world!\\"\\n"'
+
+    :param string: the string to escape
+    """
+    return '"%s"' % string.replace('\\', '\\\\') \
+                          .replace('\t', '\\t') \
+                          .replace('\r', '\\r') \
+                          .replace('\n', '\\n') \
+                          .replace('\"', '\\"')
+
+
+def normalize(string: str, prefix: str = '', width: int = 76) -> str:
+    r"""Convert a string into a format that is appropriate for .po files.
+
+    >>> print(normalize('''Say:
+    ...   "hello, world!"
+    ... ''', width=None))
+    ""
+    "Say:\n"
+    "  \"hello, world!\"\n"
+
+    >>> print(normalize('''Say:
+    ...   "Lorem ipsum dolor sit amet, consectetur adipisicing elit, "
+    ... ''', width=32))
+    ""
+    "Say:\n"
+    "  \"Lorem ipsum dolor sit "
+    "amet, consectetur adipisicing"
+    " elit, \"\n"
+
+    :param string: the string to normalize
+    :param prefix: a string that should be prepended to every line
+    :param width: the maximum line width; use `None`, 0, or a negative number
+                  to completely disable line wrapping
+    """
+    if width and width > 0:
+        prefixlen = len(prefix)
+        lines = []
+        for line in string.splitlines(True):
+            if len(escape(line)) + prefixlen > width:
+                chunks = WORD_SEP.split(line)
+                chunks.reverse()
+                while chunks:
+                    buf = []
+                    size = 2
+                    while chunks:
+                        length = len(escape(chunks[-1])) - 2 + prefixlen
+                        if size + length < width:
+                            buf.append(chunks.pop())
+                            size += length
+                        else:
+                            if not buf:
+                                # handle long chunks by putting them on a
+                                # separate line
+                                buf.append(chunks.pop())
+                            break
+                    lines.append(''.join(buf))
+            else:
+                lines.append(line)
+    else:
+        lines = string.splitlines(True)
+
+    if len(lines) <= 1:
+        return escape(string)
+
+    # Remove empty trailing line
+    if lines and not lines[-1]:
+        del lines[-1]
+        lines[-1] += '\n'
+    return '""\n' + '\n'.join([(prefix + escape(line)) for line in lines])
+
+
+def _enclose_filename_if_necessary(filename: str) -> str:
+    """Enclose filenames which include white spaces or tabs.
+
+    Do the same as gettext and enclose filenames which contain white
+    spaces or tabs with First Strong Isolate (U+2068) and Pop
+    Directional Isolate (U+2069).
+    """
+    if " " not in filename and "\t" not in filename:
+        return filename
+
+    if not filename.startswith("\u2068"):
+        filename = "\u2068" + filename
+    if not filename.endswith("\u2069"):
+        filename += "\u2069"
+    return filename
+
+
+def write_po(
+    fileobj: SupportsWrite[bytes],
+    catalog: Catalog,
+    width: int = 76,
+    no_location: bool = False,
+    omit_header: bool = False,
+    sort_output: bool = False,
+    sort_by_file: bool = False,
+    ignore_obsolete: bool = False,
+    include_previous: bool = False,
+    include_lineno: bool = True,
+) -> None:
+    r"""Write a ``gettext`` PO (portable object) template file for a given
+    message catalog to the provided file-like object.
+
+    >>> catalog = Catalog()
+    >>> catalog.add(u'foo %(name)s', locations=[('main.py', 1)],
+    ...             flags=('fuzzy',))
+    <Message...>
+    >>> catalog.add((u'bar', u'baz'), locations=[('main.py', 3)])
+    <Message...>
+    >>> from io import BytesIO
+    >>> buf = BytesIO()
+    >>> write_po(buf, catalog, omit_header=True)
+    >>> print(buf.getvalue().decode("utf8"))
+    #: main.py:1
+    #, fuzzy, python-format
+    msgid "foo %(name)s"
+    msgstr ""
+    <BLANKLINE>
+    #: main.py:3
+    msgid "bar"
+    msgid_plural "baz"
+    msgstr[0] ""
+    msgstr[1] ""
+    <BLANKLINE>
+    <BLANKLINE>
+
+    :param fileobj: the file-like object to write to
+    :param catalog: the `Catalog` instance
+    :param width: the maximum line width for the generated output; use `None`,
+                  0, or a negative number to completely disable line wrapping
+    :param no_location: do not emit a location comment for every message
+    :param omit_header: do not include the ``msgid ""`` entry at the top of the
+                        output
+    :param sort_output: whether to sort the messages in the output by msgid
+    :param sort_by_file: whether to sort the messages in the output by their
+                         locations
+    :param ignore_obsolete: whether to ignore obsolete messages and not include
+                            them in the output; by default they are included as
+                            comments
+    :param include_previous: include the old msgid as a comment when
+                             updating the catalog
+    :param include_lineno: include line number in the location comment
+    """
+
+    sort_by = None
+    if sort_output:
+        sort_by = "message"
+    elif sort_by_file:
+        sort_by = "location"
+
+    for line in generate_po(
+        catalog,
+        ignore_obsolete=ignore_obsolete,
+        include_lineno=include_lineno,
+        include_previous=include_previous,
+        no_location=no_location,
+        omit_header=omit_header,
+        sort_by=sort_by,
+        width=width,
+    ):
+        if isinstance(line, str):
+            line = line.encode(catalog.charset, 'backslashreplace')
+        fileobj.write(line)
+
+
+def generate_po(
+    catalog: Catalog,
+    *,
+    ignore_obsolete: bool = False,
+    include_lineno: bool = True,
+    include_previous: bool = False,
+    no_location: bool = False,
+    omit_header: bool = False,
+    sort_by: Literal["message", "location"] | None = None,
+    width: int = 76,
+) -> Iterable[str]:
+    r"""Yield text strings representing a ``gettext`` PO (portable object) file.
+
+    See `write_po()` for a more detailed description.
+    """
+    # xgettext always wraps comments even if --no-wrap is passed;
+    # provide the same behaviour
+    comment_width = width if width and width > 0 else 76
+
+    comment_wrapper = TextWrapper(width=comment_width, break_long_words=False)
+    header_wrapper = TextWrapper(width=width, subsequent_indent="# ", break_long_words=False)
+
+    def _format_comment(comment, prefix=''):
+        for line in comment_wrapper.wrap(comment):
+            yield f"#{prefix} {line.strip()}\n"
+
+    def _format_message(message, prefix=''):
+        if isinstance(message.id, (list, tuple)):
+            if message.context:
+                yield f"{prefix}msgctxt {normalize(message.context, prefix=prefix, width=width)}\n"
+            yield f"{prefix}msgid {normalize(message.id[0], prefix=prefix, width=width)}\n"
+            yield f"{prefix}msgid_plural {normalize(message.id[1], prefix=prefix, width=width)}\n"
+
+            for idx in range(catalog.num_plurals):
+                try:
+                    string = message.string[idx]
+                except IndexError:
+                    string = ''
+                yield f"{prefix}msgstr[{idx:d}] {normalize(string, prefix=prefix, width=width)}\n"
+        else:
+            if message.context:
+                yield f"{prefix}msgctxt {normalize(message.context, prefix=prefix, width=width)}\n"
+            yield f"{prefix}msgid {normalize(message.id, prefix=prefix, width=width)}\n"
+            yield f"{prefix}msgstr {normalize(message.string or '', prefix=prefix, width=width)}\n"
+
+    for message in _sort_messages(catalog, sort_by=sort_by):
+        if not message.id:  # This is the header "message"
+            if omit_header:
+                continue
+            comment_header = catalog.header_comment
+            if width and width > 0:
+                lines = []
+                for line in comment_header.splitlines():
+                    lines += header_wrapper.wrap(line)
+                comment_header = '\n'.join(lines)
+            yield f"{comment_header}\n"
+
+        for comment in message.user_comments:
+            yield from _format_comment(comment)
+        for comment in message.auto_comments:
+            yield from _format_comment(comment, prefix='.')
+
+        if not no_location:
+            locs = []
+
+            # sort locations by filename and lineno.
+            # if there's no <int> as lineno, use `-1`.
+            # if no sorting possible, leave unsorted.
+            # (see issue #606)
+            try:
+                locations = sorted(message.locations,
+                                   key=lambda x: (x[0], isinstance(x[1], int) and x[1] or -1))
+            except TypeError:  # e.g. "TypeError: unorderable types: NoneType() < int()"
+                locations = message.locations
+
+            for filename, lineno in locations:
+                location = filename.replace(os.sep, '/')
+                location = _enclose_filename_if_necessary(location)
+                if lineno and include_lineno:
+                    location = f"{location}:{lineno:d}"
+                if location not in locs:
+                    locs.append(location)
+            yield from _format_comment(' '.join(locs), prefix=':')
+        if message.flags:
+            yield f"#{', '.join(['', *sorted(message.flags)])}\n"
+
+        if message.previous_id and include_previous:
+            yield from _format_comment(
+                f'msgid {normalize(message.previous_id[0], width=width)}',
+                prefix='|',
+            )
+            if len(message.previous_id) > 1:
+                norm_previous_id = normalize(message.previous_id[1], width=width)
+                yield from _format_comment(f'msgid_plural {norm_previous_id}', prefix='|')
+
+        yield from _format_message(message)
+        yield '\n'
+
+    if not ignore_obsolete:
+        for message in _sort_messages(
+            catalog.obsolete.values(),
+            sort_by=sort_by,
+        ):
+            for comment in message.user_comments:
+                yield from _format_comment(comment)
+            yield from _format_message(message, prefix='#~ ')
+            yield '\n'
+
+
+def _sort_messages(messages: Iterable[Message], sort_by: Literal["message", "location"] | None) -> list[Message]:
+    """
+    Sort the given message iterable by the given criteria.
+
+    Always returns a list.
+
+    :param messages: An iterable of Messages.
+    :param sort_by: Sort by which criteria? Options are `message` and `location`.
+    :return: list[Message]
+    """
+    messages = list(messages)
+    if sort_by == "message":
+        messages.sort()
+    elif sort_by == "location":
+        messages.sort(key=lambda m: m.locations)
+    return messages

lib/python3.10/site-packages/babel/messages/setuptools_frontend.py

@@ -0,0 +1,108 @@
+from __future__ import annotations
+
+from babel.messages import frontend
+
+try:
+    # See: https://setuptools.pypa.io/en/latest/deprecated/distutils-legacy.html
+    from setuptools import Command
+
+    try:
+        from setuptools.errors import BaseError, OptionError, SetupError
+    except ImportError:  # Error aliases only added in setuptools 59 (2021-11).
+        OptionError = SetupError = BaseError = Exception
+
+except ImportError:
+    from distutils.cmd import Command
+    from distutils.errors import DistutilsSetupError as SetupError
+
+
+def check_message_extractors(dist, name, value):
+    """Validate the ``message_extractors`` keyword argument to ``setup()``.
+
+    :param dist: the distutils/setuptools ``Distribution`` object
+    :param name: the name of the keyword argument (should always be
+                 "message_extractors")
+    :param value: the value of the keyword argument
+    :raise `DistutilsSetupError`: if the value is not valid
+    """
+    assert name == "message_extractors"
+    if not isinstance(value, dict):
+        raise SetupError(
+            'the value of the "message_extractors" parameter must be a dictionary',
+        )
+
+
+class compile_catalog(frontend.CompileCatalog, Command):
+    """Catalog compilation command for use in ``setup.py`` scripts.
+
+    If correctly installed, this command is available to Setuptools-using
+    setup scripts automatically. For projects using plain old ``distutils``,
+    the command needs to be registered explicitly in ``setup.py``::
+
+        from babel.messages.setuptools_frontend import compile_catalog
+
+        setup(
+            ...
+            cmdclass = {'compile_catalog': compile_catalog}
+        )
+
+    .. versionadded:: 0.9
+    """
+
+
+class extract_messages(frontend.ExtractMessages, Command):
+    """Message extraction command for use in ``setup.py`` scripts.
+
+    If correctly installed, this command is available to Setuptools-using
+    setup scripts automatically. For projects using plain old ``distutils``,
+    the command needs to be registered explicitly in ``setup.py``::
+
+        from babel.messages.setuptools_frontend import extract_messages
+
+        setup(
+            ...
+            cmdclass = {'extract_messages': extract_messages}
+        )
+    """
+
+
+class init_catalog(frontend.InitCatalog, Command):
+    """New catalog initialization command for use in ``setup.py`` scripts.
+
+    If correctly installed, this command is available to Setuptools-using
+    setup scripts automatically. For projects using plain old ``distutils``,
+    the command needs to be registered explicitly in ``setup.py``::
+
+        from babel.messages.setuptools_frontend import init_catalog
+
+        setup(
+            ...
+            cmdclass = {'init_catalog': init_catalog}
+        )
+    """
+
+
+class update_catalog(frontend.UpdateCatalog, Command):
+    """Catalog merging command for use in ``setup.py`` scripts.
+
+    If correctly installed, this command is available to Setuptools-using
+    setup scripts automatically. For projects using plain old ``distutils``,
+    the command needs to be registered explicitly in ``setup.py``::
+
+        from babel.messages.setuptools_frontend import update_catalog
+
+        setup(
+            ...
+            cmdclass = {'update_catalog': update_catalog}
+        )
+
+    .. versionadded:: 0.9
+    """
+
+
+COMMANDS = {
+    "compile_catalog": compile_catalog,
+    "extract_messages": extract_messages,
+    "init_catalog": init_catalog,
+    "update_catalog": update_catalog,
+}

lib/python3.10/site-packages/numba/__init__.py

@@ -0,0 +1,253 @@
+"""
+Expose top-level symbols that are safe for import *
+"""
+
+import platform
+import re
+import sys
+import warnings
+
+
+# ---------------------- WARNING WARNING WARNING ----------------------------
+# THIS MUST RUN FIRST, DO NOT MOVE... SEE DOCSTRING IN _ensure_critical_deps
+def _ensure_critical_deps():
+    """
+    Make sure the Python, NumPy and SciPy present are supported versions.
+    This has to be done _before_ importing anything from Numba such that
+    incompatible versions can be reported to the user. If this occurs _after_
+    importing things from Numba and there's an issue in e.g. a Numba c-ext, a
+    SystemError might have occurred which prevents reporting the likely cause of
+    the problem (incompatible versions of critical dependencies).
+    """
+    #NOTE THIS CODE SHOULD NOT IMPORT ANYTHING FROM NUMBA!
+
+    def extract_version(mod):
+        return tuple(map(int, mod.__version__.split('.')[:2]))
+
+    PYVERSION = sys.version_info[:2]
+
+    if PYVERSION < (3, 10):
+        msg = ("Numba needs Python 3.10 or greater. Got Python "
+               f"{PYVERSION[0]}.{PYVERSION[1]}.")
+        raise ImportError(msg)
+
+    import numpy as np
+    numpy_version = extract_version(np)
+
+    if numpy_version < (1, 24):
+        msg = (f"Numba needs NumPy 1.24 or greater. Got NumPy "
+               f"{numpy_version[0]}.{numpy_version[1]}.")
+        raise ImportError(msg)
+
+    if numpy_version > (2, 1):
+        msg = (f"Numba needs NumPy 2.1 or less. Got NumPy "
+               f"{numpy_version[0]}.{numpy_version[1]}.")
+        raise ImportError(msg)
+
+    try:
+        import scipy
+    except ImportError:
+        pass
+    else:
+        sp_version = extract_version(scipy)
+        if sp_version < (1, 0):
+            msg = ("Numba requires SciPy version 1.0 or greater. Got SciPy "
+                   f"{scipy.__version__}.")
+            raise ImportError(msg)
+
+
+_ensure_critical_deps()
+# END DO NOT MOVE
+# ---------------------- WARNING WARNING WARNING ----------------------------
+
+
+from ._version import get_versions
+from numba.misc.init_utils import generate_version_info
+
+__version__ = get_versions()['version']
+version_info = generate_version_info(__version__)
+del get_versions
+del generate_version_info
+
+
+from numba.core import config
+from numba.core import types, errors
+
+# Re-export typeof
+from numba.misc.special import (
+    typeof, prange, pndindex, gdb, gdb_breakpoint, gdb_init,
+    literally, literal_unroll,
+)
+
+# Re-export error classes
+from numba.core.errors import *
+
+# Re-export types itself
+import numba.core.types as types
+
+# Re-export all type names
+from numba.core.types import *
+
+# Re-export decorators
+from numba.core.decorators import (cfunc, jit, njit, stencil,
+                                   jit_module)
+
+# Re-export vectorize decorators and the thread layer querying function
+from numba.np.ufunc import (vectorize, guvectorize, threading_layer,
+                            get_num_threads, set_num_threads,
+                            set_parallel_chunksize, get_parallel_chunksize,
+                            get_thread_id)
+
+# Re-export Numpy helpers
+from numba.np.numpy_support import carray, farray, from_dtype
+
+# Re-export experimental
+from numba import experimental
+
+# Initialize withcontexts
+import numba.core.withcontexts
+from numba.core.withcontexts import objmode_context as objmode
+from numba.core.withcontexts import parallel_chunksize
+
+# Initialize target extensions
+import numba.core.target_extension
+
+# Initialize typed containers
+import numba.typed
+
+# Keep this for backward compatibility.
+def test(argv, **kwds):
+    # To speed up the import time, avoid importing `unittest` and other test
+    # dependencies unless the user is actually trying to run tests.
+    from numba.testing import _runtests as runtests
+    return runtests.main(argv, **kwds)
+
+__all__ = """
+    cfunc
+    from_dtype
+    guvectorize
+    jit
+    experimental
+    njit
+    stencil
+    jit_module
+    typeof
+    prange
+    gdb
+    gdb_breakpoint
+    gdb_init
+    vectorize
+    objmode
+    literal_unroll
+    get_num_threads
+    set_num_threads
+    set_parallel_chunksize
+    get_parallel_chunksize
+    parallel_chunksize
+    """.split() + types.__all__ + errors.__all__
+
+
+_min_llvmlite_version = (0, 44, 0)
+_min_llvm_version = (14, 0, 0)
+
+def _ensure_llvm():
+    """
+    Make sure llvmlite is operational.
+    """
+    import warnings
+    import llvmlite
+
+    # Only look at the the major, minor and bugfix version numbers.
+    # Ignore other stuffs
+    regex = re.compile(r'(\d+)\.(\d+).(\d+)')
+    m = regex.match(llvmlite.__version__)
+    if m:
+        ver = tuple(map(int, m.groups()))
+        if ver < _min_llvmlite_version:
+            msg = ("Numba requires at least version %d.%d.%d of llvmlite.\n"
+                   "Installed version is %s.\n"
+                   "Please update llvmlite." %
+                   (_min_llvmlite_version + (llvmlite.__version__,)))
+            raise ImportError(msg)
+    else:
+        # Not matching?
+        warnings.warn("llvmlite version format not recognized!")
+
+    from llvmlite.binding import llvm_version_info, check_jit_execution
+
+    if llvm_version_info < _min_llvm_version:
+        msg = ("Numba requires at least version %d.%d.%d of LLVM.\n"
+               "Installed llvmlite is built against version %d.%d.%d.\n"
+               "Please update llvmlite." %
+               (_min_llvm_version + llvm_version_info))
+        raise ImportError(msg)
+
+    check_jit_execution()
+
+
+def _try_enable_svml():
+    """
+    Tries to enable SVML if configuration permits use and the library is found.
+    """
+    if not config.DISABLE_INTEL_SVML:
+        try:
+            if sys.platform.startswith('linux'):
+                llvmlite.binding.load_library_permanently("libsvml.so")
+            elif sys.platform.startswith('darwin'):
+                llvmlite.binding.load_library_permanently("libsvml.dylib")
+            elif sys.platform.startswith('win'):
+                llvmlite.binding.load_library_permanently("svml_dispmd")
+            else:
+                return False
+            # The SVML library is loaded, therefore SVML *could* be supported.
+            # Now see if LLVM has been compiled with the SVML support patch.
+            # If llvmlite has the checking function `has_svml` and it returns
+            # True, then LLVM was compiled with SVML support and the the setup
+            # for SVML can proceed. We err on the side of caution and if the
+            # checking function is missing, regardless of that being fine for
+            # most 0.23.{0,1} llvmlite instances (i.e. conda or pip installed),
+            # we assume that SVML was not compiled in. llvmlite 0.23.2 is a
+            # bugfix release with the checking function present that will always
+            # produce correct behaviour. For context see: #3006.
+            try:
+                if not getattr(llvmlite.binding.targets, "has_svml")():
+                    # has detection function, but no svml compiled in, therefore
+                    # disable SVML
+                    return False
+            except AttributeError:
+                if platform.machine() == 'x86_64' and config.DEBUG:
+                    msg = ("SVML was found but llvmlite >= 0.23.2 is "
+                           "needed to support it.")
+                    warnings.warn(msg)
+                # does not have detection function, cannot detect reliably,
+                # disable SVML.
+                return False
+
+            # All is well, detection function present and reports SVML is
+            # compiled in, set the vector library to SVML.
+            llvmlite.binding.set_option('SVML', '-vector-library=SVML')
+            return True
+        except:
+            if platform.machine() == 'x86_64' and config.DEBUG:
+                warnings.warn("SVML was not found/could not be loaded.")
+    return False
+
+_ensure_llvm()
+
+# we know llvmlite is working as the above tests passed, import it now as SVML
+# needs to mutate runtime options (sets the `-vector-library`).
+import llvmlite
+
+"""
+Is set to True if Intel SVML is in use.
+"""
+config.USING_SVML = _try_enable_svml()
+
+
+# ---------------------- WARNING WARNING WARNING ----------------------------
+# The following imports occur below here (SVML init) because somewhere in their
+# import sequence they have a `@njit` wrapped function. This triggers too early
+# a bind to the underlying LLVM libraries which then irretrievably sets the LLVM
+# SVML state to "no SVML". See https://github.com/numba/numba/issues/4689 for
+# context.
+# ---------------------- WARNING WARNING WARNING ----------------------------

lib/python3.10/site-packages/numba/__main__.py

@@ -0,0 +1,6 @@
+"""Expose Numba command via ``python -m numba``."""
+import sys
+from numba.misc.numba_entry import main
+
+if __name__ == '__main__':
+    sys.exit(main())

lib/python3.10/site-packages/numba/_arraystruct.h

@@ -0,0 +1,21 @@
+#ifndef NUMBA_ARYSTRUCT_H_
+#define NUMBA_ARYSTRUCT_H_
+/*
+ * Fill in the *arystruct* with information from the Numpy array *obj*.
+ * *arystruct*'s layout is defined in numba.targets.arrayobj (look
+ * for the ArrayTemplate class).
+ */
+
+typedef struct {
+    void     *meminfo;  /* see _nrt_python.c and nrt.h in numba/core/runtime */
+    PyObject *parent;
+    npy_intp nitems;
+    npy_intp itemsize;
+    void *data;
+
+    npy_intp shape_and_strides[];
+} arystruct_t;
+
+
+#endif  /* NUMBA_ARYSTRUCT_H_ */
+

lib/python3.10/site-packages/numba/_devicearray.h

@@ -0,0 +1,25 @@
+#ifndef NUMBA_DEVICEARRAY_H_
+#define NUMBA_DEVICEARRAY_H_
+
+#ifdef __cplusplus
+    extern "C" {
+#endif
+
+/* These definitions should only be used by consumers of the Device Array API.
+ * Consumers access the API through the opaque pointer stored in
+ * _devicearray._DEVICEARRAY_API.  We don't want these definitions in
+ * _devicearray.cpp itself because they would conflict with the actual
+ * implementations there.
+ */
+#ifndef NUMBA_IN_DEVICEARRAY_CPP_
+
+    extern void **DeviceArray_API;
+    #define DeviceArrayType (*(PyTypeObject*)DeviceArray_API[0])
+
+#endif /* ndef NUMBA_IN_DEVICEARRAY_CPP */
+
+#ifdef __cplusplus
+    }
+#endif
+
+#endif  /* NUMBA_DEVICEARRAY_H_ */

lib/python3.10/site-packages/numba/_dynfunc.c

@@ -0,0 +1,534 @@
+/*
+ * Definition of Environment and Closure objects.
+ * This module is included by _dynfuncmod.c and by pycc-compiled modules.
+ */
+
+#include "_pymodule.h"
+
+#include <string.h>
+
+
+// if python version is 3.13
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 13)
+    #include "pythoncapi_compat.h"
+    #define _Py_IsFinalizing Py_IsFinalizing
+#endif
+/* NOTE: EnvironmentObject and ClosureObject must be kept in sync with
+ * the definitions in numba/targets/base.py (EnvBody and ClosureBody).
+ */
+
+/*
+ * EnvironmentObject hosts data needed for execution of compiled functions.
+ */
+typedef struct {
+    PyObject_HEAD
+    PyObject *globals;
+    /* Assorted "constants" that are needed at runtime to execute
+       the compiled function.  This can include frozen closure variables,
+       lifted loops, etc. */
+    PyObject *consts;
+} EnvironmentObject;
+
+
+static PyMemberDef env_members[] = {
+    {"globals", T_OBJECT, offsetof(EnvironmentObject, globals), READONLY, NULL},
+    {"consts", T_OBJECT, offsetof(EnvironmentObject, consts), READONLY, NULL},
+    {NULL}  /* Sentinel */
+};
+
+static int
+env_traverse(EnvironmentObject *env, visitproc visit, void *arg)
+{
+    Py_VISIT(env->globals);
+    Py_VISIT(env->consts);
+    return 0;
+}
+
+static int
+env_clear(EnvironmentObject *env)
+{
+    Py_CLEAR(env->globals);
+    Py_CLEAR(env->consts);
+    return 0;
+}
+
+static void
+env_dealloc(EnvironmentObject *env)
+{
+    PyObject_GC_UnTrack((PyObject *) env);
+    env_clear(env);
+    Py_TYPE(env)->tp_free((PyObject *) env);
+}
+
+static EnvironmentObject *
+env_new_empty(PyTypeObject* type)
+{
+    return (EnvironmentObject *) PyType_GenericNew(type, NULL, NULL);
+}
+
+static PyObject *
+env_new(PyTypeObject* type, PyObject* args, PyObject* kwds)
+{
+    PyObject *globals;
+    EnvironmentObject *env;
+    static char *kwlist[] = {"globals", 0};
+
+    if (!PyArg_ParseTupleAndKeywords(
+            args, kwds, "O!:function", kwlist,
+            &PyDict_Type, &globals))
+        return NULL;
+
+    env = env_new_empty(type);
+    if (env == NULL)
+        return NULL;
+    Py_INCREF(globals);
+    env->globals = globals;
+    env->consts = PyList_New(0);
+    if (!env->consts) {
+        Py_DECREF(env);
+        return NULL;
+    }
+    return (PyObject *) env;
+}
+
+
+static PyTypeObject EnvironmentType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "_dynfunc.Environment",                  /* tp_name */
+    sizeof(EnvironmentObject),               /* tp_basicsize */
+    0,                                       /* tp_itemsize */
+    (destructor) env_dealloc,                /* tp_dealloc */
+    0,                                       /* tp_vectorcall_offset */
+    0,                                       /* tp_getattr*/
+    0,                                       /* tp_setattr */
+    0,                                       /* tp_as_async */
+    0,                                       /* tp_repr */
+    0,                                       /* tp_as_number */
+    0,                                       /* tp_as_sequence */
+    0,                                       /* tp_as_mapping */
+    0,                                       /* tp_hash */
+    0,                                       /* tp_call */
+    0,                                       /* tp_str */
+    0,                                       /* tp_getattro */
+    0,                                       /* tp_setattro */
+    0,                                       /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC, /* tp_flags */
+    0,                                       /* tp_doc */
+    (traverseproc) env_traverse,             /* tp_traverse */
+    (inquiry) env_clear,                     /* tp_clear */
+    0,                                       /* tp_richcompare */
+    0,                                       /* tp_weaklistoffset */
+    0,                                       /* tp_iter */
+    0,                                       /* tp_iternext */
+    0,                                       /* tp_methods */
+    env_members,                             /* tp_members */
+    0,                                       /* tp_getset */
+    0,                                       /* tp_base */
+    0,                                       /* tp_dict */
+    0,                                       /* tp_descr_get */
+    0,                                       /* tp_descr_set */
+    0,                                       /* tp_dictoffset */
+    0,                                       /* tp_init */
+    0,                                       /* tp_alloc */
+    env_new,                                 /* tp_new */
+    0,                                       /* tp_free */
+    0,                                       /* tp_is_gc */
+    0,                                       /* tp_bases */
+    0,                                       /* tp_mro */
+    0,                                       /* tp_cache */
+    0,                                       /* tp_subclasses */
+    0,                                       /* tp_weaklist */
+    0,                                       /* tp_del */
+    0,                                       /* tp_version_tag */
+    0,                                       /* tp_finalize */
+    0,                                       /* tp_vectorcall */
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12)
+/* This was introduced first in 3.12
+ * https://github.com/python/cpython/issues/91051
+ */
+    0,                                           /* tp_watched */
+#endif
+
+/* WARNING: Do not remove this, only modify it! It is a version guard to
+ * act as a reminder to update this struct on Python version update! */
+#if (PY_MAJOR_VERSION == 3)
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
+#error "Python minor version is not supported."
+#endif
+#else
+#error "Python major version is not supported."
+#endif
+/* END WARNING*/
+};
+
+/* A closure object is created for each call to make_function(), and stored
+   as the resulting PyCFunction object's "self" pointer.  It points to an
+   EnvironmentObject which is constructed during compilation.  This allows
+   for two things:
+       - lifetime management of dependent data (e.g. lifted loop dispatchers)
+       - access to the execution environment by the compiled function
+         (for example the globals module)
+   */
+
+/* Closure is a variable-sized object for binary compatibility with
+   Generator (see below). */
+#define CLOSURE_HEAD          \
+    PyObject_VAR_HEAD         \
+    EnvironmentObject *env;
+
+typedef struct {
+    CLOSURE_HEAD
+    /* The dynamically-filled method definition for the PyCFunction object
+       using this closure. */
+    PyMethodDef def;
+    /* Arbitrary object to keep alive during the closure's lifetime.
+       (put a tuple to put several objects alive).
+       In practice, this helps keep the LLVM module and its generated
+       code alive. */
+    PyObject *keepalive;
+    PyObject *weakreflist;
+} ClosureObject;
+
+
+static int
+closure_traverse(ClosureObject *clo, visitproc visit, void *arg)
+{
+    Py_VISIT(clo->env);
+    Py_VISIT(clo->keepalive);
+    return 0;
+}
+
+static void
+closure_dealloc(ClosureObject *clo)
+{
+    PyObject_GC_UnTrack((PyObject *) clo);
+    if (clo->weakreflist != NULL)
+        PyObject_ClearWeakRefs((PyObject *) clo);
+    PyObject_Free((void *) clo->def.ml_name);
+    PyObject_Free((void *) clo->def.ml_doc);
+    Py_XDECREF(clo->env);
+    Py_XDECREF(clo->keepalive);
+    Py_TYPE(clo)->tp_free((PyObject *) clo);
+}
+
+static PyTypeObject ClosureType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "_dynfunc._Closure",                     /* tp_name */
+    sizeof(ClosureObject),                   /* tp_basicsize */
+    0,                                       /* tp_itemsize */
+    (destructor) closure_dealloc,            /* tp_dealloc */
+    0,                                       /* tp_vectorcall_offset */
+    0,                                       /* tp_getattr */
+    0,                                       /* tp_setattr */
+    0,                                       /* tp_as_async */
+    0,                                       /* tp_repr */
+    0,                                       /* tp_as_number */
+    0,                                       /* tp_as_sequence */
+    0,                                       /* tp_as_mapping */
+    0,                                       /* tp_hash */
+    0,                                       /* tp_call */
+    0,                                       /* tp_str */
+    0,                                       /* tp_getattro */
+    0,                                       /* tp_setattro */
+    0,                                       /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /* tp_flags */
+    0,                                       /* tp_doc */
+    (traverseproc) closure_traverse,         /* tp_traverse */
+    0,                                       /* tp_clear */
+    0,                                       /* tp_richcompare */
+    offsetof(ClosureObject, weakreflist),    /* tp_weaklistoffset */
+    0,                                       /* tp_iter */
+    0,                                       /* tp_iternext */
+    0,                                       /* tp_methods */
+    0,                                       /* tp_members */
+    0,                                       /* tp_getset */
+    0,                                       /* tp_base */
+    0,                                       /* tp_dict */
+    0,                                       /* tp_descr_get */
+    0,                                       /* tp_descr_set */
+    0,                                       /* tp_dictoffset */
+    0,                                       /* tp_init */
+    0,                                       /* tp_alloc */
+    0,                                       /* tp_new */
+    0,                                       /* tp_free */
+    0,                                       /* tp_is_gc */
+    0,                                       /* tp_bases */
+    0,                                       /* tp_mro */
+    0,                                       /* tp_cache */
+    0,                                       /* tp_subclasses */
+    0,                                       /* tp_weaklist */
+    0,                                       /* tp_del */
+    0,                                       /* tp_version_tag */
+    0,                                       /* tp_finalize */
+    0,                                       /* tp_vectorcall */
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12)
+/* This was introduced first in 3.12
+ * https://github.com/python/cpython/issues/91051
+ */
+    0,                                           /* tp_watched */
+#endif
+
+/* WARNING: Do not remove this, only modify it! It is a version guard to
+ * act as a reminder to update this struct on Python version update! */
+#if (PY_MAJOR_VERSION == 3)
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
+#error "Python minor version is not supported."
+#endif
+#else
+#error "Python major version is not supported."
+#endif
+/* END WARNING*/
+};
+
+
+/* Return an owned piece of character data duplicating a Python string
+   object's value. */
+static char *
+dup_string(PyObject *strobj)
+{
+    const char *tmp = NULL;
+    char *str;
+    tmp = PyString_AsString(strobj);
+    if (tmp == NULL)
+        return NULL;
+    /* Using PyObject_Malloc allows this memory to be tracked for
+       leaks. */
+    str = PyObject_Malloc(strlen(tmp) + 1);
+    if (str == NULL) {
+        PyErr_NoMemory();
+        return NULL;
+    }
+    strcpy(str, tmp);
+    return str;
+}
+
+/* Create and initialize a new Closure object */
+static ClosureObject *
+closure_new(PyObject *name, PyObject *doc, PyCFunction fnaddr,
+            EnvironmentObject *env, PyObject *keepalive)
+{
+    ClosureObject *clo = (ClosureObject *) PyType_GenericAlloc(&ClosureType, 0);
+    if (clo == NULL)
+        return NULL;
+
+    clo->def.ml_name = dup_string(name);
+    if (!clo->def.ml_name) {
+        Py_DECREF(clo);
+        return NULL;
+    }
+    clo->def.ml_meth = fnaddr;
+    clo->def.ml_flags = METH_VARARGS | METH_KEYWORDS;
+    clo->def.ml_doc = dup_string(doc);
+    if (!clo->def.ml_doc) {
+        Py_DECREF(clo);
+        return NULL;
+    }
+    Py_INCREF(env);
+    clo->env = env;
+    Py_XINCREF(keepalive);
+    clo->keepalive = keepalive;
+    return clo;
+}
+
+/* Create a new PyCFunction object wrapping a closure defined by
+   the given arguments. */
+static PyObject *
+pycfunction_new(PyObject *module, PyObject *name, PyObject *doc,
+                PyCFunction fnaddr, EnvironmentObject *env, PyObject *keepalive)
+{
+    PyObject *funcobj;
+    PyObject *modname = NULL;
+    ClosureObject *closure = NULL;
+
+    closure = closure_new(name, doc, fnaddr, env, keepalive);
+    if (closure == NULL) goto FAIL;
+
+    modname = PyObject_GetAttrString(module, "__name__");
+    if (modname == NULL) goto FAIL;
+
+    funcobj = PyCFunction_NewEx(&closure->def, (PyObject *) closure, modname);
+    Py_DECREF(closure);
+    Py_DECREF(modname);
+
+    return funcobj;
+
+FAIL:
+    Py_XDECREF(closure);
+    Py_XDECREF(modname);
+    return NULL;
+}
+
+/*
+ * Python-facing wrapper for Numba-compiled generator.
+ * Note the Environment's offset inside the struct is the same as in the
+ * Closure object.  This is required to simplify generation of Python wrappers.
+ */
+
+typedef void (*gen_finalizer_t)(void *);
+
+typedef struct {
+    CLOSURE_HEAD
+    PyCFunctionWithKeywords nextfunc;
+    gen_finalizer_t finalizer;
+    PyObject *weakreflist;
+    union {
+        double dummy;   /* Force alignment */
+        char state[0];
+    };
+} GeneratorObject;
+
+static int
+generator_traverse(GeneratorObject *gen, visitproc visit, void *arg)
+{
+    /* XXX this doesn't traverse the state, which can own references to
+       PyObjects */
+    Py_VISIT(gen->env);
+    return 0;
+}
+
+static int
+generator_clear(GeneratorObject *gen)
+{
+    if (gen->finalizer != NULL) {
+        gen->finalizer(gen->state);
+        gen->finalizer = NULL;
+    }
+    Py_CLEAR(gen->env);
+    gen->nextfunc = NULL;
+    return 0;
+}
+
+static void
+generator_dealloc(GeneratorObject *gen)
+{
+    PyObject_GC_UnTrack((PyObject *) gen);
+    if (gen->weakreflist != NULL)
+        PyObject_ClearWeakRefs((PyObject *) gen);
+    /* XXX The finalizer may be called after the LLVM module has been
+       destroyed (typically at interpreter shutdown) */
+    if (!_Py_IsFinalizing())
+        if (gen->finalizer != NULL)
+            gen->finalizer(gen->state);
+    Py_XDECREF(gen->env);
+    Py_TYPE(gen)->tp_free((PyObject *) gen);
+}
+
+static PyObject *
+generator_iternext(GeneratorObject *gen)
+{
+    PyObject *res, *args;
+    if (gen->nextfunc == NULL) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "cannot call next() on finalized generator");
+        return NULL;
+    }
+    args = PyTuple_Pack(1, (PyObject *) gen);
+    if (args == NULL)
+        return NULL;
+    res = (*gen->nextfunc)((PyObject *) gen, args, NULL);
+    Py_DECREF(args);
+    return res;
+}
+
+static PyTypeObject GeneratorType = {
+    PyVarObject_HEAD_INIT(NULL, 0)
+    "_dynfunc._Generator",                    /* tp_name*/
+    offsetof(GeneratorObject, state),         /* tp_basicsize*/
+    1,                                        /* tp_itemsize*/
+    (destructor) generator_dealloc,           /* tp_dealloc*/
+    0,                                        /* tp_vectorcall_offset*/
+    0,                                        /* tp_getattr*/
+    0,                                        /* tp_setattr*/
+    0,                                        /* tp_as_async*/
+    0,                                        /* tp_repr*/
+    0,                                        /* tp_as_number*/
+    0,                                        /* tp_as_sequence*/
+    0,                                        /* tp_as_mapping*/
+    0,                                        /* tp_hash */
+    0,                                        /* tp_call*/
+    0,                                        /* tp_str*/
+    0,                                        /* tp_getattro*/
+    0,                                        /* tp_setattro*/
+    0,                                        /* tp_as_buffer*/
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC
+                       | Py_TPFLAGS_BASETYPE, /* tp_flags*/
+    0,                                        /* tp_doc */
+    (traverseproc) generator_traverse,        /* tp_traverse */
+    (inquiry) generator_clear,                /* tp_clear */
+    0,                                        /* tp_richcompare */
+    offsetof(GeneratorObject, weakreflist),   /* tp_weaklistoffset */
+    PyObject_SelfIter,                        /* tp_iter */
+    (iternextfunc) generator_iternext,        /* tp_iternext */
+    0,                                        /* tp_methods */
+    0,                                        /* tp_members */
+    0,                                        /* tp_getset */
+    0,                                        /* tp_base */
+    0,                                        /* tp_dict */
+    0,                                        /* tp_descr_get */
+    0,                                        /* tp_descr_set */
+    0,                                        /* tp_dictoffset */
+    0,                                        /* tp_init */
+    0,                                        /* tp_alloc */
+    0,                                        /* tp_new */
+    0,                                        /* tp_free */
+    0,                                        /* tp_is_gc */
+    0,                                        /* tp_bases */
+    0,                                        /* tp_mro */
+    0,                                        /* tp_cache */
+    0,                                        /* tp_subclasses */
+    0,                                        /* tp_weaklist */
+    0,                                        /* tp_del */
+    0,                                        /* tp_version_tag */
+    0,                                        /* tp_finalize */
+    0,                                        /* tp_vectorcall */
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12)
+/* This was introduced first in 3.12
+ * https://github.com/python/cpython/issues/91051
+ */
+    0,                                           /* tp_watched */
+#endif
+
+/* WARNING: Do not remove this, only modify it! It is a version guard to
+ * act as a reminder to update this struct on Python version update! */
+#if (PY_MAJOR_VERSION == 3)
+#if ! (NB_SUPPORTED_PYTHON_MINOR)
+#error "Python minor version is not supported."
+#endif
+#else
+#error "Python major version is not supported."
+#endif
+/* END WARNING*/
+};
+
+/* Dynamically create a new generator object */
+static PyObject *
+Numba_make_generator(Py_ssize_t gen_state_size,
+                     void *initial_state,
+                     PyCFunctionWithKeywords nextfunc,
+                     gen_finalizer_t finalizer,
+                     EnvironmentObject *env)
+{
+    GeneratorObject *gen;
+    gen = (GeneratorObject *) PyType_GenericAlloc(&GeneratorType, gen_state_size);
+    if (gen == NULL)
+        return NULL;
+    memcpy(gen->state, initial_state, gen_state_size);
+    gen->nextfunc = nextfunc;
+    Py_XINCREF(env);
+    gen->env = env;
+    gen->finalizer = finalizer;
+    return (PyObject *) gen;
+}
+
+/* Initialization subroutine for use by modules including this */
+static int
+init_dynfunc_module(PyObject *module)
+{
+    if (PyType_Ready(&ClosureType))
+        return -1;
+    if (PyType_Ready(&EnvironmentType))
+        return -1;
+    if (PyType_Ready(&GeneratorType))
+        return -1;
+    return 0;
+}

lib/python3.10/site-packages/numba/_dynfuncmod.c

@@ -0,0 +1,93 @@
+#include "_dynfunc.c"
+
+/* Python-facing function to dynamically create a new C function object */
+static PyObject*
+make_function(PyObject *self, PyObject *args)
+{
+    PyObject *module, *fname, *fdoc, *fnaddrobj;
+    void *fnaddr;
+    EnvironmentObject *env;
+    PyObject *keepalive;
+
+    if (!PyArg_ParseTuple(args, "OOOOO!|O",
+            &module, &fname, &fdoc, &fnaddrobj, &EnvironmentType, &env,
+            &keepalive)) {
+        return NULL;
+    }
+
+    fnaddr = PyLong_AsVoidPtr(fnaddrobj);
+    if (fnaddr == NULL && PyErr_Occurred())
+        return NULL;
+
+    return pycfunction_new(module, fname, fdoc, fnaddr, env, keepalive);
+}
+
+static PyMethodDef ext_methods[] = {
+#define declmethod(func) { #func , ( PyCFunction )func , METH_VARARGS , NULL }
+    declmethod(make_function),
+    { NULL },
+#undef declmethod
+};
+
+
+static PyObject *
+build_c_helpers_dict(void)
+{
+    PyObject *dct = PyDict_New();
+    if (dct == NULL)
+        goto error;
+
+#define _declpointer(name, value) do {                 \
+    PyObject *o = PyLong_FromVoidPtr(value);           \
+    if (o == NULL) goto error;                         \
+    if (PyDict_SetItemString(dct, name, o)) {          \
+        Py_DECREF(o);                                  \
+        goto error;                                    \
+    }                                                  \
+    Py_DECREF(o);                                      \
+} while (0)
+
+#define declmethod(func) _declpointer(#func, &Numba_##func)
+
+#define declpointer(ptr) _declpointer(#ptr, &ptr)
+
+    declmethod(make_generator);
+
+#undef declmethod
+    return dct;
+error:
+    Py_XDECREF(dct);
+    return NULL;
+}
+
+MOD_INIT(_dynfunc) {
+    PyObject *m, *impl_info;
+
+    MOD_DEF(m, "_dynfunc", "No docs", ext_methods)
+    if (m == NULL)
+        return MOD_ERROR_VAL;
+
+    if (init_dynfunc_module(m))
+        return MOD_ERROR_VAL;
+
+    impl_info = Py_BuildValue(
+        "{snsnsn}",
+        "offsetof_closure_body", offsetof(ClosureObject, env),
+        "offsetof_env_body", offsetof(EnvironmentObject, globals),
+        "offsetof_generator_state", offsetof(GeneratorObject, state)
+        );
+    if (impl_info == NULL)
+        return MOD_ERROR_VAL;
+    PyModule_AddObject(m, "_impl_info", impl_info);
+
+    Py_INCREF(&ClosureType);
+    PyModule_AddObject(m, "_Closure", (PyObject *) (&ClosureType));
+    Py_INCREF(&EnvironmentType);
+    PyModule_AddObject(m, "Environment", (PyObject *) (&EnvironmentType));
+    Py_INCREF(&GeneratorType);
+    PyModule_AddObject(m, "_Generator", (PyObject *) (&GeneratorType));
+
+    PyModule_AddObject(m, "c_helpers", build_c_helpers_dict());
+
+    return MOD_SUCCESS_VAL(m);
+}

lib/python3.10/site-packages/numba/_hashtable.h

@@ -0,0 +1,132 @@
+/*
+ * See _hashtable.c for more information about this file.
+ */
+
+#ifndef Py_HASHTABLE_H
+#define Py_HASHTABLE_H
+
+/* The whole API is private */
+#ifndef Py_LIMITED_API
+
+typedef struct _Py_slist_item_s {
+    struct _Py_slist_item_s *next;
+} _Py_slist_item_t;
+
+typedef struct {
+    _Py_slist_item_t *head;
+} _Py_slist_t;
+
+#define _Py_SLIST_ITEM_NEXT(ITEM) (((_Py_slist_item_t *)ITEM)->next)
+
+#define _Py_SLIST_HEAD(SLIST) (((_Py_slist_t *)SLIST)->head)
+
+typedef struct {
+    /* used by _Numba_hashtable_t.buckets to link entries */
+    _Py_slist_item_t _Py_slist_item;
+
+    const void *key;
+    Py_uhash_t key_hash;
+
+    /* data follows */
+} _Numba_hashtable_entry_t;
+
+#define _Numba_HASHTABLE_ENTRY_DATA(ENTRY) \
+        ((char *)(ENTRY) + sizeof(_Numba_hashtable_entry_t))
+
+#define _Numba_HASHTABLE_ENTRY_DATA_AS_VOID_P(ENTRY) \
+        (*(void **)_Numba_HASHTABLE_ENTRY_DATA(ENTRY))
+
+#define _Numba_HASHTABLE_ENTRY_READ_DATA(TABLE, DATA, DATA_SIZE, ENTRY) \
+    do { \
+        assert((DATA_SIZE) == (TABLE)->data_size); \
+        memcpy(DATA, _Numba_HASHTABLE_ENTRY_DATA(ENTRY), DATA_SIZE); \
+    } while (0)
+
+typedef Py_uhash_t (*_Numba_hashtable_hash_func) (const void *key);
+typedef int (*_Numba_hashtable_compare_func) (const void *key, const _Numba_hashtable_entry_t *he);
+typedef void* (*_Numba_hashtable_copy_data_func)(void *data);
+typedef void (*_Numba_hashtable_free_data_func)(void *data);
+typedef size_t (*_Numba_hashtable_get_data_size_func)(void *data);
+
+typedef struct {
+    /* allocate a memory block */
+    void* (*malloc) (size_t size);
+
+    /* release a memory block */
+    void (*free) (void *ptr);
+} _Numba_hashtable_allocator_t;
+
+typedef struct {
+    size_t num_buckets;
+    size_t entries; /* Total number of entries in the table. */
+    _Py_slist_t *buckets;
+    size_t data_size;
+
+    _Numba_hashtable_hash_func hash_func;
+    _Numba_hashtable_compare_func compare_func;
+    _Numba_hashtable_copy_data_func copy_data_func;
+    _Numba_hashtable_free_data_func free_data_func;
+    _Numba_hashtable_get_data_size_func get_data_size_func;
+    _Numba_hashtable_allocator_t alloc;
+} _Numba_hashtable_t;
+
+/* hash and compare functions for integers and pointers */
+extern "C" PyAPI_FUNC(Py_uhash_t) _Numba_hashtable_hash_ptr(const void *key);
+extern "C" PyAPI_FUNC(Py_uhash_t) _Numba_hashtable_hash_int(const void *key);
+extern "C" PyAPI_FUNC(int) _Numba_hashtable_compare_direct(const void *key, const _Numba_hashtable_entry_t *entry);
+
+extern "C" PyAPI_FUNC(_Numba_hashtable_t *) _Numba_hashtable_new(
+    size_t data_size,
+    _Numba_hashtable_hash_func hash_func,
+    _Numba_hashtable_compare_func compare_func);
+extern "C" PyAPI_FUNC(_Numba_hashtable_t *) _Numba_hashtable_new_full(
+    size_t data_size,
+    size_t init_size,
+    _Numba_hashtable_hash_func hash_func,
+    _Numba_hashtable_compare_func compare_func,
+    _Numba_hashtable_copy_data_func copy_data_func,
+    _Numba_hashtable_free_data_func free_data_func,
+    _Numba_hashtable_get_data_size_func get_data_size_func,
+    _Numba_hashtable_allocator_t *allocator);
+extern "C" PyAPI_FUNC(_Numba_hashtable_t *) _Numba_hashtable_copy(_Numba_hashtable_t *src);
+extern "C" PyAPI_FUNC(void) _Numba_hashtable_clear(_Numba_hashtable_t *ht);
+extern "C" PyAPI_FUNC(void) _Numba_hashtable_destroy(_Numba_hashtable_t *ht);
+
+typedef int (*_Numba_hashtable_foreach_func) (_Numba_hashtable_entry_t *entry, void *arg);
+
+extern "C" PyAPI_FUNC(int) _Numba_hashtable_foreach(
+    _Numba_hashtable_t *ht,
+    _Numba_hashtable_foreach_func func, void *arg);
+extern "C" PyAPI_FUNC(size_t) _Numba_hashtable_size(_Numba_hashtable_t *ht);
+
+extern "C" PyAPI_FUNC(_Numba_hashtable_entry_t*) _Numba_hashtable_get_entry(
+    _Numba_hashtable_t *ht,
+    const void *key);
+extern "C" PyAPI_FUNC(int) _Numba_hashtable_set(
+    _Numba_hashtable_t *ht,
+    const void *key,
+    void *data,
+    size_t data_size);
+extern "C" PyAPI_FUNC(int) _Numba_hashtable_get(
+    _Numba_hashtable_t *ht,
+    const void *key,
+    void *data,
+    size_t data_size);
+extern "C" PyAPI_FUNC(int) _Numba_hashtable_pop(
+    _Numba_hashtable_t *ht,
+    const void *key,
+    void *data,
+    size_t data_size);
+extern "C" PyAPI_FUNC(void) _Numba_hashtable_delete(
+    _Numba_hashtable_t *ht,
+    const void *key);
+
+#define _Numba_HASHTABLE_SET(TABLE, KEY, DATA) \
+    _Numba_hashtable_set(TABLE, KEY, &(DATA), sizeof(DATA))
+
+#define _Numba_HASHTABLE_GET(TABLE, KEY, DATA) \
+    _Numba_hashtable_get(TABLE, KEY, &(DATA), sizeof(DATA))
+
+#endif   /* Py_LIMITED_API */
+
+#endif

lib/python3.10/site-packages/numba/_helperlib.c

@@ -0,0 +1,1251 @@
+/*
+ * Helper functions used by Numba at runtime.
+ * This C file is meant to be included after defining the
+ * NUMBA_EXPORT_FUNC() and NUMBA_EXPORT_DATA() macros.
+ */
+
+#include "_pymodule.h"
+#include <stddef.h>
+#include <stdio.h>
+#include <math.h>
+#include <complex.h>
+#ifdef _MSC_VER
+    #define int64_t signed __int64
+    #define uint64_t unsigned __int64
+    #define uint32_t unsigned __int32
+    #define _complex_float_t _Fcomplex
+    #define _complex_float_ctor(r, i) _FCbuild(r, i)
+    #define _complex_double_t _Dcomplex
+#else
+    #include <stdint.h>
+    #define _complex_float_t complex float
+    #if defined(_Imaginary_I)
+        #define _complex_float_ctor(r, i) (r + _Imaginary_I * i)
+    #elif defined(_Complex_I)
+        #define _complex_float_ctor(r, i) (r + _Complex_I * i)
+    #else
+        #error "Lack _Imaginary_I and _Complex_I"
+    #endif 
+    #define _complex_double_t complex double
+#endif
+#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
+#include <numpy/ndarrayobject.h>
+#include <numpy/arrayscalars.h>
+
+#include "_arraystruct.h"
+
+
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 11)
+    /*
+     * For struct _frame
+     */
+    #include "internal/pycore_frame.h"
+#endif
+
+/*
+ * Other helpers.
+ */
+
+
+/* Fix fmod() and fmodf() for windows x64 VC 9.0 (VS 2008)
+https://support.microsoft.com/en-us/kb/982107
+*/
+static  void (*fnclex)(void) = NULL;
+
+NUMBA_EXPORT_FUNC(double)
+numba_fixed_fmod(double x, double y){
+    fnclex();  /* no inline asm in x64 =( */
+    return fmod(x, y);
+}
+
+NUMBA_EXPORT_FUNC(float)
+numba_fixed_fmodf(float x, float y) {
+    fnclex();  /* no inline asm in x64 =( */
+    return fmodf(x, y);
+}
+
+NUMBA_EXPORT_FUNC(void)
+numba_set_fnclex(void *fn){
+    fnclex = fn;
+}
+
+/* provide 64-bit division function to 32-bit platforms */
+NUMBA_EXPORT_FUNC(int64_t)
+numba_sdiv(int64_t a, int64_t b) {
+    return a / b;
+}
+
+NUMBA_EXPORT_FUNC(uint64_t)
+numba_udiv(uint64_t a, uint64_t b) {
+    return a / b;
+}
+
+/* provide 64-bit remainder function to 32-bit platforms */
+NUMBA_EXPORT_FUNC(int64_t)
+numba_srem(int64_t a, int64_t b) {
+    return a % b;
+}
+
+NUMBA_EXPORT_FUNC(uint64_t)
+numba_urem(uint64_t a, uint64_t b) {
+    return a % b;
+}
+
+/* provide frexp and ldexp; these wrappers deal with special cases
+ * (zero, nan, infinity) directly, to sidestep platform differences.
+ */
+NUMBA_EXPORT_FUNC(double)
+numba_frexp(double x, int *exp)
+{
+    if (!Py_IS_FINITE(x) || !x)
+        *exp = 0;
+    else
+        x = frexp(x, exp);
+    return x;
+}
+
+NUMBA_EXPORT_FUNC(float)
+numba_frexpf(float x, int *exp)
+{
+    if (Py_IS_NAN(x) || Py_IS_INFINITY(x) || !x)
+        *exp = 0;
+    else
+        x = frexpf(x, exp);
+    return x;
+}
+
+NUMBA_EXPORT_FUNC(double)
+numba_ldexp(double x, int exp)
+{
+    if (Py_IS_FINITE(x) && x && exp)
+        x = ldexp(x, exp);
+    return x;
+}
+
+NUMBA_EXPORT_FUNC(float)
+numba_ldexpf(float x, int exp)
+{
+    if (Py_IS_FINITE(x) && x && exp)
+        x = ldexpf(x, exp);
+    return x;
+}
+
+/* provide complex power */
+NUMBA_EXPORT_FUNC(void)
+numba_cpow(Py_complex *a, Py_complex *b, Py_complex *out) {
+    errno = 0;
+    *out = _Py_c_pow(*a, *b);
+    if (errno == EDOM) {
+        /* _Py_c_pow() doesn't bother returning the right value
+           in this case, as Python raises ZeroDivisionError */
+        out->real = out->imag = Py_NAN;
+    }
+}
+
+NUMBA_EXPORT_FUNC(void)
+numba_cpowf(_complex_float_t *a, _complex_float_t *b, _complex_float_t *out) {
+    Py_complex _a, _b, _out;
+    _a.real = crealf(*a);
+    _a.imag = cimagf(*a);
+    _b.real = crealf(*b);
+    _b.imag = cimagf(*b);
+    numba_cpow(&_a, &_b, &_out);
+    *out = _complex_float_ctor((float) _out.real, (float) _out.imag);
+}
+
+/* C99 math functions: redirect to system implementations */
+
+NUMBA_EXPORT_FUNC(double)
+numba_gamma(double x)
+{
+    return tgamma(x);
+}
+
+NUMBA_EXPORT_FUNC(float)
+numba_gammaf(float x)
+{
+    return tgammaf(x);
+}
+
+NUMBA_EXPORT_FUNC(double)
+numba_lgamma(double x)
+{
+    return lgamma(x);
+}
+
+NUMBA_EXPORT_FUNC(float)
+numba_lgammaf(float x)
+{
+    return lgammaf(x);
+}
+
+NUMBA_EXPORT_FUNC(double)
+numba_erf(double x)
+{
+    return erf(x);
+}
+
+NUMBA_EXPORT_FUNC(float)
+numba_erff(float x)
+{
+    return erff(x);
+}
+
+NUMBA_EXPORT_FUNC(double)
+numba_erfc(double x)
+{
+    return erfc(x);
+}
+
+NUMBA_EXPORT_FUNC(float)
+numba_erfcf(float x)
+{
+    return erfcf(x);
+}
+
+NUMBA_EXPORT_FUNC(float)
+numba_nextafterf(float a, float b)
+{
+    return nextafterf(a, b);
+}
+
+NUMBA_EXPORT_FUNC(double)
+numba_nextafter(double a, double b)
+{
+    return nextafter(a, b);
+}
+
+/* Unpack any Python complex-like object into a Py_complex structure */
+NUMBA_EXPORT_FUNC(int)
+numba_complex_adaptor(PyObject* obj, Py_complex *out) {
+    PyObject* fobj;
+    PyArray_Descr *dtype;
+    double val[2];
+
+    // Convert from python complex or numpy complex128
+    if (PyComplex_Check(obj)) {
+        out->real = PyComplex_RealAsDouble(obj);
+        out->imag = PyComplex_ImagAsDouble(obj);
+    }
+    // Convert from numpy complex64
+    else if (PyArray_IsScalar(obj, ComplexFloating)) {
+        dtype = PyArray_DescrFromScalar(obj);
+        if (dtype == NULL) {
+            return 0;
+        }
+        if (PyArray_CastScalarDirect(obj, dtype, &val[0], NPY_CDOUBLE) < 0) {
+            Py_DECREF(dtype);
+            return 0;
+        }
+        out->real = val[0];
+        out->imag = val[1];
+        Py_DECREF(dtype);
+    } else {
+        fobj = PyNumber_Float(obj);
+        if (!fobj) return 0;
+        out->real = PyFloat_AsDouble(fobj);
+        out->imag = 0.;
+        Py_DECREF(fobj);
+    }
+    return 1;
+}
+
+/* Minimum PyBufferObject structure to hack inside it */
+typedef struct {
+    PyObject_HEAD
+    PyObject *b_base;
+    void *b_ptr;
+    Py_ssize_t b_size;
+    Py_ssize_t b_offset;
+}  PyBufferObject_Hack;
+
+/*
+Get data address of record data buffer
+*/
+NUMBA_EXPORT_FUNC(void *)
+numba_extract_record_data(PyObject *recordobj, Py_buffer *pbuf) {
+    PyObject *attrdata;
+    void *ptr;
+
+    attrdata = PyObject_GetAttrString(recordobj, "data");
+    if (!attrdata) return NULL;
+
+    if (-1 == PyObject_GetBuffer(attrdata, pbuf, 0)){
+        Py_DECREF(attrdata);
+        return NULL;
+    } else {
+        ptr = pbuf->buf;
+    }
+    Py_DECREF(attrdata);
+    return ptr;
+}
+
+/*
+ * Return a record instance with dtype as the record type, and backed
+ * by a copy of the memory area pointed to by (pdata, size).
+ */
+NUMBA_EXPORT_FUNC(PyObject *)
+numba_recreate_record(void *pdata, int size, PyObject *dtype) {
+    PyObject *numpy = NULL;
+    PyObject *numpy_record = NULL;
+    PyObject *aryobj = NULL;
+    PyObject *dtypearg = NULL;
+    PyObject *record = NULL;
+    PyArray_Descr *descr = NULL;
+
+    if (dtype == NULL) {
+        PyErr_Format(PyExc_RuntimeError,
+            "In 'numba_recreate_record', 'dtype' is NULL");
+        return NULL;
+    }
+
+    numpy = PyImport_ImportModule("numpy");
+    if (!numpy) goto CLEANUP;
+
+    numpy_record = PyObject_GetAttrString(numpy, "record");
+    if (!numpy_record) goto CLEANUP;
+
+    dtypearg = PyTuple_Pack(2, numpy_record, dtype);
+    if (!dtypearg || !PyArray_DescrConverter(dtypearg, &descr))
+        goto CLEANUP;
+
+    /* This steals a reference to descr, so we don't have to DECREF it */
+    aryobj = PyArray_FromString(pdata, size, descr, 1, NULL);
+    if (!aryobj) goto CLEANUP;
+
+    record = PySequence_GetItem(aryobj, 0);
+
+CLEANUP:
+    Py_XDECREF(numpy);
+    Py_XDECREF(numpy_record);
+    Py_XDECREF(aryobj);
+    Py_XDECREF(dtypearg);
+
+    return record;
+}
+
+NUMBA_EXPORT_FUNC(int)
+numba_adapt_ndarray(PyObject *obj, arystruct_t* arystruct) {
+    PyArrayObject *ndary;
+    int i, ndim;
+    npy_intp *p;
+
+    if (!PyArray_Check(obj)) {
+        return -1;
+    }
+
+    ndary = (PyArrayObject*)obj;
+    ndim = PyArray_NDIM(ndary);
+
+    arystruct->data = PyArray_DATA(ndary);
+    arystruct->nitems = PyArray_SIZE(ndary);
+    arystruct->itemsize = PyArray_ITEMSIZE(ndary);
+    arystruct->parent = obj;
+    p = arystruct->shape_and_strides;
+    for (i = 0; i < ndim; i++, p++) {
+        *p = PyArray_DIM(ndary, i);
+    }
+    for (i = 0; i < ndim; i++, p++) {
+        *p = PyArray_STRIDE(ndary, i);
+    }
+    arystruct->meminfo = NULL;
+    return 0;
+}
+
+NUMBA_EXPORT_FUNC(int)
+numba_get_buffer(PyObject *obj, Py_buffer *buf)
+{
+    /* Ask for shape and strides, but no suboffsets */
+    return PyObject_GetBuffer(obj, buf, PyBUF_RECORDS_RO);
+}
+
+NUMBA_EXPORT_FUNC(void)
+numba_adapt_buffer(Py_buffer *buf, arystruct_t *arystruct)
+{
+    int i;
+    npy_intp *p;
+
+    arystruct->data = buf->buf;
+    arystruct->itemsize = buf->itemsize;
+    arystruct->parent = buf->obj;
+    arystruct->nitems = 1;
+    p = arystruct->shape_and_strides;
+    for (i = 0; i < buf->ndim; i++, p++) {
+        *p = buf->shape[i];
+        arystruct->nitems *= buf->shape[i];
+    }
+    for (i = 0; i < buf->ndim; i++, p++) {
+        *p = buf->strides[i];
+    }
+    arystruct->meminfo = NULL;
+}
+
+NUMBA_EXPORT_FUNC(void)
+numba_release_buffer(Py_buffer *buf)
+{
+    PyBuffer_Release(buf);
+}
+
+NUMBA_EXPORT_FUNC(PyObject *)
+numba_ndarray_new(int nd,
+                  npy_intp *dims,   /* shape */
+                  npy_intp *strides,
+                  void* data,
+                  int type_num,
+                  int itemsize)
+{
+    PyObject *ndary;
+    int flags = NPY_ARRAY_BEHAVED;
+    ndary = PyArray_New((PyTypeObject*)&PyArray_Type, nd, dims, type_num,
+                       strides, data, 0, flags, NULL);
+    return ndary;
+}
+
+
+/*
+ * Handle reshaping of zero-sized array.
+ * See numba_attempt_nocopy_reshape() below.
+ */
+static int
+nocopy_empty_reshape(npy_intp nd, const npy_intp *dims, const npy_intp *strides,
+                     npy_intp newnd, const npy_intp *newdims,
+                     npy_intp *newstrides, npy_intp itemsize,
+                     int is_f_order)
+{
+    int i;
+    /* Just make the strides vaguely reasonable
+     * (they can have any value in theory).
+     */
+    for (i = 0; i < newnd; i++)
+        newstrides[i] = itemsize;
+    return 1;  /* reshape successful */
+}
+
+/*
+ * Straight from Numpy's _attempt_nocopy_reshape()
+ * (np/core/src/multiarray/shape.c).
+ * Attempt to reshape an array without copying data
+ *
+ * This function should correctly handle all reshapes, including
+ * axes of length 1. Zero strides should work but are untested.
+ *
+ * If a copy is needed, returns 0
+ * If no copy is needed, returns 1 and fills `npy_intp *newstrides`
+ *     with appropriate strides
+ */
+
+NUMBA_EXPORT_FUNC(int)
+numba_attempt_nocopy_reshape(npy_intp nd, const npy_intp *dims, const npy_intp *strides,
+                             npy_intp newnd, const npy_intp *newdims,
+                             npy_intp *newstrides, npy_intp itemsize,
+                             int is_f_order)
+{
+    int oldnd;
+    npy_intp olddims[NPY_MAXDIMS];
+    npy_intp oldstrides[NPY_MAXDIMS];
+    npy_intp np, op, last_stride;
+    int oi, oj, ok, ni, nj, nk;
+
+    oldnd = 0;
+    /*
+     * Remove axes with dimension 1 from the old array. They have no effect
+     * but would need special cases since their strides do not matter.
+     */
+    for (oi = 0; oi < nd; oi++) {
+        if (dims[oi]!= 1) {
+            olddims[oldnd] = dims[oi];
+            oldstrides[oldnd] = strides[oi];
+            oldnd++;
+        }
+    }
+
+    np = 1;
+    for (ni = 0; ni < newnd; ni++) {
+        np *= newdims[ni];
+    }
+    op = 1;
+    for (oi = 0; oi < oldnd; oi++) {
+        op *= olddims[oi];
+    }
+    if (np != op) {
+        /* different total sizes; no hope */
+        return 0;
+    }
+
+    if (np == 0) {
+        /* the Numpy code does not handle 0-sized arrays */
+        return nocopy_empty_reshape(nd, dims, strides,
+                                    newnd, newdims, newstrides,
+                                    itemsize, is_f_order);
+    }
+
+    /* oi to oj and ni to nj give the axis ranges currently worked with */
+    oi = 0;
+    oj = 1;
+    ni = 0;
+    nj = 1;
+    while (ni < newnd && oi < oldnd) {
+        np = newdims[ni];
+        op = olddims[oi];
+
+        while (np != op) {
+            if (np < op) {
+                /* Misses trailing 1s, these are handled later */
+                np *= newdims[nj++];
+            } else {
+                op *= olddims[oj++];
+            }
+        }
+
+        /* Check whether the original axes can be combined */
+        for (ok = oi; ok < oj - 1; ok++) {
+            if (is_f_order) {
+                if (oldstrides[ok+1] != olddims[ok]*oldstrides[ok]) {
+                     /* not contiguous enough */
+                    return 0;
+                }
+            }
+            else {
+                /* C order */
+                if (oldstrides[ok] != olddims[ok+1]*oldstrides[ok+1]) {
+                    /* not contiguous enough */
+                    return 0;
+                }
+            }
+        }
+
+        /* Calculate new strides for all axes currently worked with */
+        if (is_f_order) {
+            newstrides[ni] = oldstrides[oi];
+            for (nk = ni + 1; nk < nj; nk++) {
+                newstrides[nk] = newstrides[nk - 1]*newdims[nk - 1];
+            }
+        }
+        else {
+            /* C order */
+            newstrides[nj - 1] = oldstrides[oj - 1];
+            for (nk = nj - 1; nk > ni; nk--) {
+                newstrides[nk - 1] = newstrides[nk]*newdims[nk];
+            }
+        }
+        ni = nj++;
+        oi = oj++;
+    }
+
+    /*
+     * Set strides corresponding to trailing 1s of the new shape.
+     */
+    if (ni >= 1) {
+        last_stride = newstrides[ni - 1];
+    }
+    else {
+        last_stride = itemsize;
+    }
+    if (is_f_order) {
+        last_stride *= newdims[ni - 1];
+    }
+    for (nk = ni; nk < newnd; nk++) {
+        newstrides[nk] = last_stride;
+    }
+
+    return 1;
+}
+
+/*
+ * Cython utilities.
+ */
+
+/* Fetch the address of the given function, as exposed by
+   a cython module */
+static void *
+import_cython_function(const char *module_name, const char *function_name)
+{
+    PyObject *module, *capi, *cobj;
+    void *res = NULL;
+    const char *capsule_name;
+
+    module = PyImport_ImportModule(module_name);
+    if (module == NULL)
+        return NULL;
+    capi = PyObject_GetAttrString(module, "__pyx_capi__");
+    Py_DECREF(module);
+    if (capi == NULL)
+        return NULL;
+    cobj = PyMapping_GetItemString(capi, (char *)function_name);
+    Py_DECREF(capi);
+    if (cobj == NULL) {
+        PyErr_Clear();
+        PyErr_Format(PyExc_ValueError,
+                     "No function '%s' found in __pyx_capi__ of '%s'",
+                     function_name, module_name);
+        return NULL;
+    }
+    /* 2.7+ => Cython exports a PyCapsule */
+    capsule_name = PyCapsule_GetName(cobj);
+    if (capsule_name != NULL) {
+        res = PyCapsule_GetPointer(cobj, capsule_name);
+    }
+    Py_DECREF(cobj);
+    return res;
+}
+
+NUMBA_EXPORT_FUNC(PyObject *)
+_numba_import_cython_function(PyObject *self, PyObject *args)
+{
+    const char *module_name;
+    const char *function_name;
+    void *p = NULL;
+    PyObject *res;
+
+    if (!PyArg_ParseTuple(args, "ss", &module_name, &function_name)) {
+        return NULL;
+    }
+    p = import_cython_function(module_name, function_name);
+    if (p == NULL) {
+        return NULL;
+    }
+    res = PyLong_FromVoidPtr(p);
+    if (res == NULL) {
+      PyErr_SetString(PyExc_RuntimeError,
+                      "Could not convert function address to int");
+      return NULL;
+    }
+    return res;
+}
+
+/* We use separate functions for datetime64 and timedelta64, to ensure
+ * proper type checking.
+ */
+NUMBA_EXPORT_FUNC(npy_int64)
+numba_extract_np_datetime(PyObject *td)
+{
+    if (!PyArray_IsScalar(td, Datetime)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "expected a numpy.datetime64 object");
+        return -1;
+    }
+    return PyArrayScalar_VAL(td, Timedelta);
+}
+
+NUMBA_EXPORT_FUNC(npy_int64)
+numba_extract_np_timedelta(PyObject *td)
+{
+    if (!PyArray_IsScalar(td, Timedelta)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "expected a numpy.timedelta64 object");
+        return -1;
+    }
+    return PyArrayScalar_VAL(td, Timedelta);
+}
+
+NUMBA_EXPORT_FUNC(PyObject *)
+numba_create_np_datetime(npy_int64 value, int unit_code)
+{
+    PyDatetimeScalarObject *obj = (PyDatetimeScalarObject *)
+        PyArrayScalar_New(Datetime);
+    if (obj != NULL) {
+        obj->obval = value;
+        obj->obmeta.base = unit_code;
+        obj->obmeta.num = 1;
+    }
+    return (PyObject *) obj;
+}
+
+NUMBA_EXPORT_FUNC(PyObject *)
+numba_create_np_timedelta(npy_int64 value, int unit_code)
+{
+    PyTimedeltaScalarObject *obj = (PyTimedeltaScalarObject *)
+        PyArrayScalar_New(Timedelta);
+    if (obj != NULL) {
+        obj->obval = value;
+        obj->obmeta.base = unit_code;
+        obj->obmeta.num = 1;
+    }
+    return (PyObject *) obj;
+}
+
+NUMBA_EXPORT_FUNC(uint64_t)
+numba_fptoui(double x) {
+    /* First cast to signed int of the full width to make sure sign extension
+       happens (this can make a difference on some platforms...). */
+    return (uint64_t) (int64_t) x;
+}
+
+NUMBA_EXPORT_FUNC(uint64_t)
+numba_fptouif(float x) {
+    return (uint64_t) (int64_t) x;
+}
+
+NUMBA_EXPORT_FUNC(void)
+numba_gil_ensure(PyGILState_STATE *state) {
+    *state = PyGILState_Ensure();
+}
+
+NUMBA_EXPORT_FUNC(void)
+numba_gil_release(PyGILState_STATE *state) {
+    PyGILState_Release(*state);
+}
+
+NUMBA_EXPORT_FUNC(PyObject *)
+numba_py_type(PyObject *obj) {
+    return (PyObject *) Py_TYPE(obj);
+}
+
+
+/*
+ * Functions for tagging an arbitrary Python object with an arbitrary pointer.
+ * These functions make strong lifetime assumptions, see below.
+ */
+
+static PyObject *private_data_dict = NULL;
+
+static PyObject *
+_get_private_data_dict(void)
+{
+    if (private_data_dict == NULL)
+        private_data_dict = PyDict_New();
+    return private_data_dict;
+}
+
+NUMBA_EXPORT_FUNC(void)
+numba_set_pyobject_private_data(PyObject *obj, void *ptr)
+{
+    PyObject *dct = _get_private_data_dict();
+    /* This assumes the reference to setobj is kept alive until the
+       call to numba_reset_set_private_data()! */
+    PyObject *key = PyLong_FromVoidPtr((void *) obj);
+    PyObject *value = PyLong_FromVoidPtr(ptr);
+
+    if (!dct || !value || !key)
+        goto error;
+    if (PyDict_SetItem(dct, key, value))
+        goto error;
+    Py_DECREF(key);
+    Py_DECREF(value);
+    return;
+
+error:
+    Py_FatalError("unable to set private data");
+}
+
+NUMBA_EXPORT_FUNC(void *)
+numba_get_pyobject_private_data(PyObject *obj)
+{
+    PyObject *dct = _get_private_data_dict();
+    PyObject *value, *key = PyLong_FromVoidPtr((void *) obj);
+    void *ptr;
+    if (!dct || !key)
+        goto error;
+
+    value = PyDict_GetItem(dct, key);
+    Py_DECREF(key);
+    if (!value)
+        return NULL;
+    else {
+        ptr = PyLong_AsVoidPtr(value);
+        if (ptr == NULL && PyErr_Occurred())
+            goto error;
+        return ptr;
+    }
+
+error:
+    Py_FatalError("unable to get private data");
+    return NULL;
+}
+
+NUMBA_EXPORT_FUNC(void)
+numba_reset_pyobject_private_data(PyObject *obj)
+{
+    PyObject *dct = _get_private_data_dict();
+    PyObject *key = PyLong_FromVoidPtr((void *) obj);
+
+    if (!key)
+        goto error;
+    if (PyDict_DelItem(dct, key))
+        PyErr_Clear();
+    Py_DECREF(key);
+    return;
+
+error:
+    Py_FatalError("unable to reset private data");
+}
+
+NUMBA_EXPORT_FUNC(int)
+numba_unpack_slice(PyObject *obj,
+                   Py_ssize_t *start, Py_ssize_t *stop, Py_ssize_t *step)
+{
+    PySliceObject *slice = (PySliceObject *) obj;
+    if (!PySlice_Check(obj)) {
+        PyErr_Format(PyExc_TypeError,
+                     "Expected a slice object, got '%s'",
+                     Py_TYPE(slice)->tp_name);
+        return -1;
+    }
+#define FETCH_MEMBER(NAME, DEFAULT)                             \
+    if (slice->NAME != Py_None) {                               \
+        Py_ssize_t v = PyNumber_AsSsize_t(slice->NAME,          \
+                                          PyExc_OverflowError); \
+        if (v == -1 && PyErr_Occurred())                        \
+            return -1;                                          \
+        *NAME = v;                                              \
+    }                                                           \
+    else {                                                      \
+        *NAME = DEFAULT;                                        \
+    }
+    FETCH_MEMBER(step, 1)
+    FETCH_MEMBER(stop, (*step > 0) ? PY_SSIZE_T_MAX : PY_SSIZE_T_MIN)
+    FETCH_MEMBER(start, (*step > 0) ? 0 : PY_SSIZE_T_MAX)
+    return 0;
+
+#undef FETCH_MEMBER
+}
+
+NUMBA_EXPORT_FUNC(int)
+numba_fatal_error(void)
+{
+    PyGILState_Ensure();
+    Py_FatalError("in Numba-compiled function");
+    return 0; /* unreachable */
+}
+
+/* Insert a frame into the traceback for (funcname, filename, lineno). */
+/* This function is CPython's _PyTraceback_Add, renamed, see:
+ * https://github.com/python/cpython/blob/d545869d084e70d4838310e79b52a25a72a1ca56/Python/traceback.c#L246
+ * and modified for Python 2.x based on
+ * https://github.com/python/cpython/blob/2e1a34025cde19bddf12a2eac8fedb6afcca8339/Modules/_ctypes/callbacks.c#L151-L174
+ */
+static void traceback_add(const char *funcname, const char *filename, int lineno)
+{
+    PyObject *globals = NULL;
+    PyCodeObject *code = NULL;
+    PyFrameObject *frame = NULL;
+    PyObject *exc, *val, *tb;
+
+    /* Save and clear the current exception. Python functions must not be
+       called with an exception set. Calling Python functions happens when
+       the codec of the filesystem encoding is implemented in pure Python. */
+    PyErr_Fetch(&exc, &val, &tb);
+
+    globals = PyDict_New();
+    if (!globals)
+        goto error;
+    code = PyCode_NewEmpty(filename, funcname, lineno);
+    if (!code) {
+        goto error;
+    }
+    frame = PyFrame_New(PyThreadState_Get(), code, globals, NULL);
+    Py_DECREF(globals);
+    Py_DECREF(code);
+    if (!frame)
+        goto error;
+
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12) || (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 13) /* 3.12 or 3.13 */
+#elif (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 11) /* 3.11 */
+
+    /* unsafe cast to our copy of _frame to access the f_lineno field */
+    typedef struct _frame py_frame;
+    py_frame* hacked_frame = (py_frame*)frame;
+    hacked_frame->f_lineno = lineno;
+
+#elif (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION < 11) /* <3.11 */
+    frame->f_lineno = lineno;
+#else
+    #error "Check if struct _frame has been changed in the new version"
+#endif
+    PyErr_Restore(exc, val, tb);
+    PyTraceBack_Here(frame);
+    Py_DECREF(frame);
+    return;
+
+#if (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 12) || (PY_MAJOR_VERSION == 3) && (PY_MINOR_VERSION == 13) /* 3.12 or 3.13 */
+error:
+    _PyErr_ChainExceptions1(exc);
+#elif (PY_MAJOR_VERSION == 3) && ((PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11)) /* 3.11 and below */
+error:
+    _PyErr_ChainExceptions(exc, val, tb);
+#else
+#error "Python major version is not supported."
+#endif
+}
+
+
+/*
+ * Add traceback information to *loc* to the active exception.
+ * loc can be NULL, which causes this function to become a no-op.
+ */
+static
+void traceback_add_loc(PyObject *loc) {
+    const char *function_name_str = NULL, *filename_str = NULL;
+    PyObject *function_name = NULL, *filename = NULL, *lineno = NULL;
+    Py_ssize_t pos;
+
+    /* instance is instantiated/internal exception is raised, if loc is present
+     * add a frame for it into the traceback */
+    if(loc && loc != Py_None && PyTuple_Check(loc))
+    {
+        pos = 0;
+        function_name = PyTuple_GET_ITEM(loc, pos);
+        function_name_str = PyString_AsString(function_name);
+        pos = 1;
+        filename = PyTuple_GET_ITEM(loc, pos);
+        filename_str = PyString_AsString(filename);
+        pos = 2;
+        lineno = PyTuple_GET_ITEM(loc, pos);
+        traceback_add(function_name_str, filename_str, \
+                      (int)PyLong_AsLong(lineno));
+    }
+}
+
+/**
+ * Re-raise the current active exception.
+ * Called internal by process_raise() when *exc* is None.
+ */
+static
+int reraise_exc_is_none(void) {
+    /* Reraise */
+    PyObject *tb, *type, *value;
+
+#if (PY_MAJOR_VERSION >= 3) && (PY_MINOR_VERSION >= 11)
+    PyErr_GetExcInfo(&type, &value, &tb);
+#elif (PY_MAJOR_VERSION >= 3) && (PY_MINOR_VERSION >= 10)
+    PyThreadState *tstate = PyThreadState_GET();
+    _PyErr_StackItem *tstate_exc = tstate->exc_info;
+    type = tstate_exc->exc_type;
+    value = tstate_exc->exc_value;
+    tb = tstate_exc->exc_traceback;
+#endif
+    if (type == Py_None) {
+        PyErr_SetString(PyExc_RuntimeError,
+                        "No active exception to reraise");
+        return 0;
+    }
+    /* incref needed because PyErr_Restore DOES NOT */
+    Py_XINCREF(type);
+    Py_XINCREF(value);
+    Py_XINCREF(tb);
+    PyErr_Restore(type, value, tb);
+    return 1;
+}
+
+/*
+ * Set exception given the Exception type and the constructor argument.
+ * Equivalent to ``raise exc(value)``.
+ * PyExceptionClass_Check(exc) must be True.
+ * value can be NULL.
+ */
+static
+int process_exception_class(PyObject *exc, PyObject *value) {
+    PyObject *type;
+    /* It is a class, type used here just as a tmp var */
+    type = PyObject_CallObject(exc, value);
+    if (type == NULL){
+        return 0;
+    }
+    if (!PyExceptionInstance_Check(type)) {
+        PyErr_SetString(PyExc_TypeError,
+                        "exceptions must derive from BaseException");
+        Py_DECREF(type);
+        return 0;
+    }
+    /* all ok, set type to the exc */
+    Py_DECREF(type);
+    type = exc;
+    PyErr_SetObject(type, value);
+    return 1;
+}
+
+/*
+ * Internal routine to process exceptions.
+ * exc cannot be NULL. It can be a None, Exception type, or Exception instance.
+ * value can be NULL for absent, or any PyObject valid for the exception.
+ */
+static
+int process_raise(PyObject *exc, PyObject *value) {
+    /* exc is None */
+    if (exc == Py_None) {
+        return reraise_exc_is_none();
+    }
+    /* exc should be an exception class */
+    else if (PyExceptionClass_Check(exc)) {
+        return process_exception_class(exc, value);
+    }
+    /* exc is an instance of an Exception */
+    else if (PyExceptionInstance_Check(exc)) {
+        PyObject *type = PyExceptionInstance_Class(exc);
+        PyErr_SetObject(type, exc);
+        return 0;
+    }
+    else {
+        /* Not something you can raise.  You get an exception
+        anyway, just not what you specified :-) */
+        PyErr_SetString(PyExc_TypeError,
+                        "exceptions must derive from BaseException");
+        return 0;
+    }
+}
+
+/* Logic for raising an arbitrary object.  Adapted from CPython's ceval.c.
+   This *consumes* a reference count to its argument. */
+NUMBA_EXPORT_FUNC(int)
+numba_do_raise(PyObject *exc_packed)
+{
+    int status;
+    PyObject *exc = NULL, *value = NULL, *loc = NULL;
+
+    /* We support the following forms of raise:
+       raise
+       raise <instance>
+       raise <type> */
+
+    /* could be a tuple from npm (some exc like thing, args, location) */
+    if (PyTuple_CheckExact(exc_packed)) {
+        /* Unpack a (class/inst/tuple, arguments, location) tuple. */
+        if (!PyArg_ParseTuple(exc_packed, "OOO", &exc, &value, &loc)) {
+            traceback_add_loc(loc);
+            return 0;
+        }
+    } else {
+        /* could be a reraise or an exception from objmode */
+        exc = exc_packed;
+        /* branch exit with value = NULL and loc = NULL */
+    }
+    /* value is either NULL or borrowed */
+    status = process_raise(exc, value);
+    traceback_add_loc(loc);
+    Py_DECREF(exc_packed);
+    return status;
+}
+
+#ifdef PYCC_COMPILING
+/* AOT avoid the use of `numba.core.serialize` */
+NUMBA_EXPORT_FUNC(PyObject *)
+numba_unpickle(const char *data, int n, const char *hashed)
+{
+    PyObject *buf, *obj;
+    static PyObject *loads;
+
+    /* Caching the pickle.loads function shaves a couple µs here. */
+    if (loads == NULL) {
+        PyObject *picklemod;
+        picklemod = PyImport_ImportModule("pickle");
+        if (picklemod == NULL)
+            return NULL;
+        loads = PyObject_GetAttrString(picklemod, "loads");
+        Py_DECREF(picklemod);
+        if (loads == NULL)
+            return NULL;
+    }
+
+    buf = PyBytes_FromStringAndSize(data, n);
+    if (buf == NULL)
+        return NULL;
+    obj = PyObject_CallFunctionObjArgs(loads, buf, NULL);
+    Py_DECREF(buf);
+    return obj;
+}
+
+#else
+
+NUMBA_EXPORT_FUNC(PyObject *)
+numba_unpickle(const char *data, int n, const char *hashed)
+{
+    PyObject *buf=NULL, *obj=NULL, *addr=NULL, *hashedbuf=NULL;
+    static PyObject *loads=NULL;
+
+    /* Caching the _numba_unpickle function shaves a couple µs here. */
+    if (loads == NULL) {
+        PyObject *picklemod;
+        picklemod = PyImport_ImportModule("numba.core.serialize");
+        if (picklemod == NULL)
+            return NULL;
+        loads = PyObject_GetAttrString(picklemod, "_numba_unpickle");
+        Py_DECREF(picklemod);
+        if (loads == NULL)
+            return NULL;
+    }
+
+    buf = PyBytes_FromStringAndSize(data, n);
+    if (buf == NULL)
+        return NULL;
+    /* SHA1 produces 160 bit or 20 bytes */
+    hashedbuf = PyBytes_FromStringAndSize(hashed, 20);
+    if (hashedbuf == NULL)
+        goto error;
+    addr = PyLong_FromVoidPtr((void*)data);
+    if (addr == NULL)
+        goto error;
+    obj = PyObject_CallFunctionObjArgs(loads, addr, buf, hashedbuf, NULL);
+error:
+    Py_XDECREF(addr);
+    Py_XDECREF(hashedbuf);
+    Py_DECREF(buf);
+    return obj;
+}
+#endif
+
+NUMBA_EXPORT_FUNC(PyObject *)
+numba_runtime_build_excinfo_struct(PyObject* struct_gv, PyObject* exc_args)
+{
+    PyObject *obj = NULL;
+    static PyObject *func = NULL;
+
+    /* Caching the function shaves a couple µs here. */
+    if (func == NULL)
+    {
+        PyObject *picklemod;
+        picklemod = PyImport_ImportModule("numba.core.serialize");
+        if (picklemod == NULL)
+            return NULL;
+        func = PyObject_GetAttrString(picklemod,
+                                      "runtime_build_excinfo_struct");
+        Py_DECREF(picklemod);
+        if (func == NULL)
+            return NULL;
+    }
+
+    obj = PyObject_CallFunctionObjArgs(func, struct_gv, exc_args, NULL);
+    // func returns None on failure (i.e. can't serialize one of the args).
+    // Is there a better way to handle this? raise an exception here?
+    return obj;
+}
+
+/*
+ * Unicode helpers
+ */
+
+/* Developer note:
+ *
+ * The hash value of unicode objects is obtained via:
+ * ((PyASCIIObject *)(obj))->hash;
+ * The use comes from this definition:
+ * https://github.com/python/cpython/blob/6d43f6f081023b680d9db4542d19b9e382149f0a/Objects/unicodeobject.c#L119-L120
+ * and it's used extensively throughout the `cpython/Object/unicodeobject.c`
+ * source, not least in `unicode_hash` itself:
+ * https://github.com/python/cpython/blob/6d43f6f081023b680d9db4542d19b9e382149f0a/Objects/unicodeobject.c#L11662-L11679
+ *
+ * The Unicode string struct layouts are described here:
+ * https://github.com/python/cpython/blob/6d43f6f081023b680d9db4542d19b9e382149f0a/Include/cpython/unicodeobject.h#L82-L161
+ * essentially, all the unicode string layouts start with a `PyASCIIObject` at
+ * offset 0 (as of commit 6d43f6f081023b680d9db4542d19b9e382149f0a, somewhere
+ * in the 3.8 development cycle).
+ *
+ * For safety against future CPython internal changes, the code checks that the
+ * _base members of the unicode structs are what is expected in 3.7, and that
+ * their offset is 0. It then walks the struct to the hash location to make sure
+ * the offset is indeed the same as PyASCIIObject->hash.
+ * Note: The large condition in the if should evaluate to a compile time
+ * constant.
+ */
+
+#define MEMBER_SIZE(structure, member) sizeof(((structure *)0)->member)
+
+NUMBA_EXPORT_FUNC(void *)
+numba_extract_unicode(PyObject *obj, Py_ssize_t *length, int *kind,
+                      unsigned int *ascii, Py_ssize_t *hash) {
+    if (!PyUnicode_READY(obj)) {
+        *length = PyUnicode_GET_LENGTH(obj);
+        *kind = PyUnicode_KIND(obj);
+        /* could also use PyUnicode_IS_ASCII but it is not publicly advertised in https://docs.python.org/3/c-api/unicode.html */
+        *ascii = (unsigned int)(PyUnicode_MAX_CHAR_VALUE(obj) == (0x7f));
+        /* this is here as a crude check for safe casting of all unicode string
+         * structs to a PyASCIIObject */
+        if (MEMBER_SIZE(PyCompactUnicodeObject, _base) == sizeof(PyASCIIObject)             &&
+            MEMBER_SIZE(PyUnicodeObject, _base) == sizeof(PyCompactUnicodeObject)           &&
+            offsetof(PyCompactUnicodeObject, _base) == 0                                    &&
+            offsetof(PyUnicodeObject, _base) == 0                                           &&
+            offsetof(PyCompactUnicodeObject, _base.hash) == offsetof(PyASCIIObject, hash)   &&
+            offsetof(PyUnicodeObject, _base._base.hash) == offsetof(PyASCIIObject, hash)
+           ) {
+            /* Grab the hash from the type object cache, do not compute it. */
+            *hash = ((PyASCIIObject *)(obj))->hash;
+        }
+        else {
+            /* cast is not safe, fail */
+            return NULL;
+        }
+        return PyUnicode_DATA(obj);
+    } else {
+        return NULL;
+    }
+}
+
+/* this is late included as it #defines e.g. SHIFT that should not impact
+ * the above */
+#include "_unicodetype_db.h"
+
+/* This function is a modified copy of the private function gettyperecord from
+ * CPython's Objects/unicodectype.c
+ *
+ * See:https://github.com/python/cpython/blob/1d4b6ba19466aba0eb91c4ba01ba509acf18c723/Objects/unicodectype.c#L45-L59
+ */
+NUMBA_EXPORT_FUNC(void)
+numba_gettyperecord(Py_UCS4 code, int *upper, int *lower, int *title,
+                    unsigned char *decimal, unsigned char *digit,
+                    unsigned short *flags)
+{
+    int index;
+    const numba_PyUnicode_TypeRecord *rec;
+
+    if (code >= 0x110000)
+        index = 0;
+    else
+    {
+        index = index1[(code>>SHIFT)];
+        index = index2[(index<<SHIFT)+(code&((1<<SHIFT)-1))];
+    }
+
+    rec = &numba_PyUnicode_TypeRecords[index];
+    *upper = rec->upper;
+    *lower = rec->lower;
+    *title = rec->title;
+    *decimal = rec->decimal;
+    *digit = rec->digit;
+    *flags = rec->flags;
+}
+
+/* This function provides a consistent access point for the
+ * _PyUnicode_ExtendedCase array defined in CPython's Objects/unicodectype.c
+ * and now also as numba_PyUnicode_ExtendedCase in Numba's _unicodetype_db.h
+ */
+NUMBA_EXPORT_FUNC(Py_UCS4)
+numba_get_PyUnicode_ExtendedCase(int code)
+{
+    return numba_PyUnicode_ExtendedCase[code];
+}
+
+/* from _unicodetype_db.h */
+#undef SHIFT
+
+/*
+ * defined break point for gdb
+ */
+NUMBA_EXPORT_FUNC(void)
+numba_gdb_breakpoint(void) {
+  /* does nothing */
+}
+
+/*
+ * Define bridge for all math functions
+ */
+
+#define MATH_UNARY(F, R, A) \
+    NUMBA_EXPORT_FUNC(R) numba_##F(A a) { return F(a); }
+#define MATH_BINARY(F, R, A, B) \
+    NUMBA_EXPORT_FUNC(R) numba_##F(A a, B b) { return F(a, b); }
+
+#include "mathnames.h"
+
+#undef MATH_UNARY
+#undef MATH_BINARY
+
+/*
+ * BLAS and LAPACK wrappers
+ */
+
+#include "_lapack.c"
+
+/*
+ * PRNG support
+ */
+
+#include "_random.c"

lib/python3.10/site-packages/numba/_helpermod.c

@@ -0,0 +1,277 @@
+/*
+Expose all functions as pointers in a dedicated C extension.
+*/
+#include "cext/cext.h"
+/* Import _pymodule.h first, for a recent _POSIX_C_SOURCE */
+#include "_pymodule.h"
+
+#include <math.h>
+#ifdef _MSC_VER
+    #define false 0
+    #define true 1
+    #define bool int
+#else
+    #include <stdbool.h>
+#endif
+
+/*
+Include C-extension here
+*/
+#include "cext/cext.h"
+
+/* Numba C helpers */
+#include "_helperlib.c"
+
+static PyObject *
+build_c_helpers_dict(void)
+{
+    PyObject *dct = PyDict_New();
+    if (dct == NULL)
+        goto error;
+
+#define _declpointer(name, value) do {                 \
+    PyObject *o = PyLong_FromVoidPtr(value);           \
+    if (o == NULL) goto error;                         \
+    if (PyDict_SetItemString(dct, name, o)) {          \
+        Py_DECREF(o);                                  \
+        goto error;                                    \
+    }                                                  \
+    Py_DECREF(o);                                      \
+} while (0)
+
+#define declmethod(func) _declpointer(#func, &numba_##func)
+
+#define declpointer(ptr) _declpointer(#ptr, &numba_##ptr)
+
+    declmethod(fixed_fmod);
+    declmethod(fixed_fmodf);
+    declmethod(set_fnclex);
+
+    declmethod(sdiv);
+    declmethod(srem);
+    declmethod(udiv);
+    declmethod(urem);
+    declmethod(frexp);
+    declmethod(frexpf);
+    declmethod(ldexp);
+    declmethod(ldexpf);
+    declmethod(cpow);
+    declmethod(cpowf);
+    declmethod(erf);
+    declmethod(erff);
+    declmethod(erfc);
+    declmethod(erfcf);
+    declmethod(gamma);
+    declmethod(gammaf);
+    declmethod(lgamma);
+    declmethod(lgammaf);
+    declmethod(nextafter);
+    declmethod(nextafterf);
+    declmethod(complex_adaptor);
+    declmethod(adapt_ndarray);
+    declmethod(ndarray_new);
+    declmethod(extract_record_data);
+    declmethod(get_buffer);
+    declmethod(adapt_buffer);
+    declmethod(release_buffer);
+    declmethod(extract_np_datetime);
+    declmethod(create_np_datetime);
+    declmethod(extract_np_timedelta);
+    declmethod(create_np_timedelta);
+    declmethod(recreate_record);
+    declmethod(fptoui);
+    declmethod(fptouif);
+    declmethod(gil_ensure);
+    declmethod(gil_release);
+    declmethod(fatal_error);
+    declmethod(py_type);
+    declmethod(unpack_slice);
+    declmethod(do_raise);
+    declmethod(unpickle);
+    declmethod(runtime_build_excinfo_struct);
+    declmethod(attempt_nocopy_reshape);
+    declmethod(get_pyobject_private_data);
+    declmethod(set_pyobject_private_data);
+    declmethod(reset_pyobject_private_data);
+
+    /* BLAS / LAPACK */
+    declmethod(xxgemm);
+    declmethod(xxgemv);
+    declmethod(xxdot);
+    declmethod(xxgetrf);
+    declmethod(ez_xxgetri);
+    declmethod(xxpotrf);
+    declmethod(ez_rgeev);
+    declmethod(ez_cgeev);
+    declmethod(ez_xxxevd);
+    declmethod(ez_gesdd);
+    declmethod(ez_geqrf);
+    declmethod(ez_xxgqr);
+    declmethod(ez_gelsd);
+    declmethod(xgesv);
+    declmethod(xxnrm2);
+
+    /* PRNG support */
+    declmethod(get_py_random_state);
+    declmethod(get_np_random_state);
+    declmethod(get_internal_random_state);
+    declmethod(rnd_shuffle);
+    declmethod(rnd_init);
+    declmethod(poisson_ptrs);
+
+    /* Unicode string support */
+    declmethod(extract_unicode);
+    declmethod(gettyperecord);
+    declmethod(get_PyUnicode_ExtendedCase);
+
+    /* for gdb breakpoint */
+    declmethod(gdb_breakpoint);
+
+    /* for dictionary support */
+    declmethod(test_dict);
+    declmethod(dict_new_sized);
+    declmethod(dict_set_method_table);
+    declmethod(dict_free);
+    declmethod(dict_length);
+    declmethod(dict_lookup);
+    declmethod(dict_insert);
+    declmethod(dict_insert_ez);
+    declmethod(dict_delitem);
+    declmethod(dict_popitem);
+    declmethod(dict_iter_sizeof);
+    declmethod(dict_iter);
+    declmethod(dict_iter_next);
+    declmethod(dict_dump);
+
+    /* for list support */
+    declmethod(test_list);
+    declmethod(list_new);
+    declmethod(list_set_method_table);
+    declmethod(list_free);
+    declmethod(list_base_ptr);
+    declmethod(list_size_address);
+    declmethod(list_length);
+    declmethod(list_allocated);
+    declmethod(list_is_mutable);
+    declmethod(list_set_is_mutable);
+    declmethod(list_setitem);
+    declmethod(list_getitem);
+    declmethod(list_append);
+    declmethod(list_delitem);
+    declmethod(list_delete_slice);
+    declmethod(list_iter_sizeof);
+    declmethod(list_iter);
+    declmethod(list_iter_next);
+
+#define MATH_UNARY(F, R, A) declmethod(F);
+#define MATH_BINARY(F, R, A, B) declmethod(F);
+    #include "mathnames.h"
+#undef MATH_UNARY
+#undef MATH_BINARY
+
+#undef declmethod
+    return dct;
+error:
+    Py_XDECREF(dct);
+    return NULL;
+}
+
+
+/*
+ * Helper to deal with flushing stdout
+ */
+PyAPI_FUNC(void) _numba_flush_stdout(void) ;
+
+void
+_numba_flush_stdout(void) {
+  fflush(stdout);
+}
+
+
+static PyMethodDef ext_methods[] = {
+    { "rnd_get_state", (PyCFunction) _numba_rnd_get_state, METH_O, NULL },
+    { "rnd_get_py_state_ptr", (PyCFunction) _numba_rnd_get_py_state_ptr, METH_NOARGS, NULL },
+    { "rnd_get_np_state_ptr", (PyCFunction) _numba_rnd_get_np_state_ptr, METH_NOARGS, NULL },
+    { "rnd_seed", (PyCFunction) _numba_rnd_seed, METH_VARARGS, NULL },
+    { "rnd_set_state", (PyCFunction) _numba_rnd_set_state, METH_VARARGS, NULL },
+    { "rnd_shuffle", (PyCFunction) _numba_rnd_shuffle, METH_O, NULL },
+    { "_import_cython_function", (PyCFunction) _numba_import_cython_function, METH_VARARGS, NULL },
+    { NULL },
+};
+
+/*
+ * These functions are exported by the module's DLL, to exercise ctypes / cffi
+ * without relying on libc availability (see https://bugs.python.org/issue23606)
+ */
+
+PyAPI_FUNC(double) _numba_test_sin(double x);
+PyAPI_FUNC(double) _numba_test_cos(double x);
+PyAPI_FUNC(double) _numba_test_exp(double x);
+PyAPI_FUNC(void) _numba_test_vsquare(int n, double *x, double *out);
+PyAPI_FUNC(double) _numba_test_funcptr(double (*func)(double));
+PyAPI_FUNC(bool) _numba_test_boolean(void);
+
+double _numba_test_sin(double x)
+{
+    return sin(x);
+}
+
+double _numba_test_cos(double x)
+{
+    return cos(x);
+}
+
+double _numba_test_exp(double x)
+{
+    return exp(x);
+}
+
+void _numba_test_vsquare(int n, double *x, double *out)
+{
+    int i;
+    for (i = 0; i < n; i++)
+        out[i] = pow(x[i], 2.0);
+}
+
+void _numba_test_vcube(int n, double *x, double *out)
+{
+    int i;
+    for (i = 0; i < n; i++)
+        out[i] = pow(x[i], 3.0);
+}
+
+double _numba_test_funcptr(double (*func)(double))
+{
+    return func(1.5);
+}
+
+bool _numba_test_boolean()
+{
+    return true;
+}
+
+MOD_INIT(_helperlib) {
+    PyObject *m;
+    MOD_DEF(m, "_helperlib", "No docs", ext_methods)
+    if (m == NULL)
+        return MOD_ERROR_VAL;
+
+    import_array();
+
+    PyModule_AddObject(m, "c_helpers", build_c_helpers_dict());
+    PyModule_AddIntConstant(m, "long_min", LONG_MIN);
+    PyModule_AddIntConstant(m, "long_max", LONG_MAX);
+    PyModule_AddIntConstant(m, "py_buffer_size", sizeof(Py_buffer));
+    PyModule_AddIntConstant(m, "py_gil_state_size", sizeof(PyGILState_STATE));
+    PyModule_AddIntConstant(m, "py_unicode_1byte_kind", PyUnicode_1BYTE_KIND);
+    PyModule_AddIntConstant(m, "py_unicode_2byte_kind", PyUnicode_2BYTE_KIND);
+    PyModule_AddIntConstant(m, "py_unicode_4byte_kind", PyUnicode_4BYTE_KIND);
+#if (PY_MAJOR_VERSION == 3)
+#if ((PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11))
+    PyModule_AddIntConstant(m, "py_unicode_wchar_kind", PyUnicode_WCHAR_KIND);
+#endif
+#endif
+    numba_rnd_ensure_global_init();
+
+    return MOD_SUCCESS_VAL(m);
+}

lib/python3.10/site-packages/numba/_lapack.c

@@ -0,0 +1,1946 @@
+/*
+ * This file contains wrappers of BLAS and LAPACK functions
+ */
+/*
+ * BLAS calling helpers.  The helpers can be called without the GIL held.
+ * The caller is responsible for checking arguments (especially dimensions).
+ */
+
+/* Fast getters caching the value of a function's address after
+   the first call to import_cblas_function(). */
+
+#define EMIT_GET_CBLAS_FUNC(name)                                 \
+    static void *cblas_ ## name = NULL;                           \
+    static void *get_cblas_ ## name(void) {                       \
+        if (cblas_ ## name == NULL) {                             \
+            PyGILState_STATE st = PyGILState_Ensure();            \
+            const char *mod = "scipy.linalg.cython_blas";         \
+            cblas_ ## name = import_cython_function(mod, # name); \
+            PyGILState_Release(st);                               \
+        }                                                         \
+        return cblas_ ## name;                                    \
+    }
+
+EMIT_GET_CBLAS_FUNC(dgemm)
+EMIT_GET_CBLAS_FUNC(sgemm)
+EMIT_GET_CBLAS_FUNC(cgemm)
+EMIT_GET_CBLAS_FUNC(zgemm)
+EMIT_GET_CBLAS_FUNC(dgemv)
+EMIT_GET_CBLAS_FUNC(sgemv)
+EMIT_GET_CBLAS_FUNC(cgemv)
+EMIT_GET_CBLAS_FUNC(zgemv)
+EMIT_GET_CBLAS_FUNC(ddot)
+EMIT_GET_CBLAS_FUNC(sdot)
+EMIT_GET_CBLAS_FUNC(cdotu)
+EMIT_GET_CBLAS_FUNC(zdotu)
+EMIT_GET_CBLAS_FUNC(cdotc)
+EMIT_GET_CBLAS_FUNC(zdotc)
+EMIT_GET_CBLAS_FUNC(snrm2)
+EMIT_GET_CBLAS_FUNC(dnrm2)
+EMIT_GET_CBLAS_FUNC(scnrm2)
+EMIT_GET_CBLAS_FUNC(dznrm2)
+
+
+#undef EMIT_GET_CBLAS_FUNC
+
+/*
+ * NOTE: On return value convention.
+ * For LAPACK wrapper development the following conventions are followed:
+ * Publicly exposed wrapper functions must return:-
+ * STATUS_ERROR  : For an unrecoverable error e.g. caught by xerbla, this is so
+ *                 a Py_FatalError can be raised.
+ * STATUS_SUCCESS: For successful execution
+ * +n            : Where n is an integer for a routine specific error
+ *                 (typically derived from an `info` argument).
+ *
+ * The caller is responsible for checking and handling the error status.
+ */
+
+/* return STATUS_SUCCESS if everything went ok */
+#define STATUS_SUCCESS  (0)
+
+/* return STATUS_ERROR if an unrecoverable error is encountered */
+#define STATUS_ERROR  (-1)
+
+/*
+ * A union of all the types accepted by BLAS/LAPACK for use in cases where
+ * stack based allocation is needed (typically for work space query args length
+ * 1).
+ */
+typedef union all_dtypes_
+{
+    float  s;
+    double d;
+    npy_complex64 c;
+    npy_complex128 z;
+} all_dtypes;
+
+/*
+ * A checked PyMem_RawMalloc, ensures that the var is either NULL
+ * and an exception is raised, or that the allocation was successful.
+ * Returns zero on success for status checking.
+ */
+static int checked_PyMem_RawMalloc(void** var, size_t bytes)
+{
+    *var = NULL;
+    *var = PyMem_RawMalloc(bytes);
+    if (!(*var))
+    {
+        {
+            PyGILState_STATE st = PyGILState_Ensure();
+
+            PyErr_SetString(PyExc_MemoryError,
+                            "Insufficient memory for buffer allocation\
+                             required by LAPACK.");
+            PyGILState_Release(st);
+        }
+        return 1;
+    }
+    return 0;
+}
+
+/*
+ * Checks that the char kind is valid (one of [s,d,c,z]) for use in blas/lapack.
+ * Returns zero on success for status checking.
+ */
+static int check_kind(char kind)
+{
+    switch (kind)
+    {
+        case 's':
+        case 'd':
+        case 'c':
+        case 'z':
+            break;
+        default:
+        {
+            PyGILState_STATE st = PyGILState_Ensure();
+            PyErr_SetString(PyExc_ValueError,
+                            "invalid data type (kind) found");
+            PyGILState_Release(st);
+        }
+        return 1;
+    }
+    return 0;
+}
+
+/*
+ * Guard macro for ensuring a valid data "kind" is being used.
+ * Place at the top of all routines with switches on "kind" that accept
+ * one of [s,d,c,z].
+ */
+#define ENSURE_VALID_KIND(__KIND) \
+if (check_kind( __KIND ))         \
+{                                 \
+    return STATUS_ERROR;          \
+}                                 \
+
+/*
+ * Checks that the char kind is valid for the real domain (one of [s,d])
+ * for use in blas/lapack.
+ * Returns zero on success for status checking.
+ */
+static int check_real_kind(char kind)
+{
+    switch (kind)
+    {
+        case 's':
+        case 'd':
+            break;
+        default:
+        {
+            PyGILState_STATE st = PyGILState_Ensure();
+            PyErr_SetString(PyExc_ValueError,
+                            "invalid data type (kind) found");
+            PyGILState_Release(st);
+        }
+        return 1;
+    }
+    return 0;
+}
+
+/*
+ * Guard macro for ensuring a valid data "kind" is being used for the
+ * real domain routines.
+ * Place at the top of all routines with switches on "kind" that accept
+ * one of [s,d].
+ */
+#define ENSURE_VALID_REAL_KIND(__KIND) \
+if (check_real_kind( __KIND ))         \
+{                                      \
+    return STATUS_ERROR;               \
+}                                      \
+
+
+/*
+ * Checks that the char kind is valid for the complex domain (one of [c,z])
+ * for use in blas/lapack.
+ * Returns zero on success for status checking.
+ */
+static int check_complex_kind(char kind)
+{
+    switch (kind)
+    {
+        case 'c':
+        case 'z':
+            break;
+        default:
+        {
+            PyGILState_STATE st = PyGILState_Ensure();
+            PyErr_SetString(PyExc_ValueError,
+                            "invalid data type (kind) found");
+            PyGILState_Release(st);
+        }
+        return 1;
+    }
+    return 0;
+}
+
+/*
+ * Guard macro for ensuring a valid data "kind" is being used for the
+ * real domain routines.
+ * Place at the top of all routines with switches on "kind" that accept
+ * one of [c,z].
+ */
+#define ENSURE_VALID_COMPLEX_KIND(__KIND) \
+if (check_complex_kind( __KIND ))         \
+{                                         \
+    return STATUS_ERROR;                  \
+}                                         \
+
+
+/*
+ * Checks that a function is found (i.e. not null)
+ * Returns zero on success for status checking.
+ */
+static int check_func(void *func)
+{
+    if (func == NULL)
+    {
+        PyGILState_STATE st = PyGILState_Ensure();
+        PyErr_SetString(PyExc_RuntimeError,
+                        "Specified LAPACK function could not be found.");
+        PyGILState_Release(st);
+        return STATUS_ERROR;
+    }
+    return STATUS_SUCCESS;
+}
+
+
+/*
+ * Guard macro for ensuring a valid function is found.
+ */
+#define ENSURE_VALID_FUNC(__FUNC)         \
+if (check_func(__FUNC))                   \
+{                                         \
+    return STATUS_ERROR;                  \
+}                                         \
+
+
+/*
+ * Define what a Fortran "int" is, some LAPACKs have 64 bit integer support
+ * numba presently opts for a 32 bit C int.
+ * This definition allows scope for later configuration time magic to adjust
+ * the size of int at all the call sites.
+ */
+#define F_INT int
+
+
+typedef float (*sdot_t)(F_INT *n, void *dx, F_INT *incx, void *dy, F_INT *incy);
+typedef double (*ddot_t)(F_INT *n, void *dx, F_INT *incx, void *dy, F_INT
+                         *incy);
+typedef npy_complex64 (*cdot_t)(F_INT *n, void *dx, F_INT *incx, void *dy,
+                                F_INT *incy);
+typedef npy_complex128 (*zdot_t)(F_INT *n, void *dx, F_INT *incx, void *dy,
+                                 F_INT *incy);
+
+typedef void (*xxgemv_t)(char *trans, F_INT *m, F_INT *n,
+                         void *alpha, void *a, F_INT *lda,
+                         void *x, F_INT *incx, void *beta,
+                         void *y, F_INT *incy);
+
+typedef void (*xxgemm_t)(char *transa, char *transb,
+                         F_INT *m, F_INT *n, F_INT *k,
+                         void *alpha, void *a, F_INT *lda,
+                         void *b, F_INT *ldb, void *beta,
+                         void *c, F_INT *ldc);
+
+typedef float (*sxnrm2_t) (F_INT *n, void *x, F_INT *incx);
+typedef double (*dxnrm2_t) (F_INT *n, void *x, F_INT *incx);
+
+/* Vector * vector: result = dx * dy */
+NUMBA_EXPORT_FUNC(int)
+numba_xxdot(char kind, char conjugate, Py_ssize_t n, void *dx, void *dy,
+            void *result)
+{
+    void *raw_func = NULL;
+    F_INT _n;
+    F_INT inc = 1;
+
+    ENSURE_VALID_KIND(kind)
+
+    switch (kind)
+    {
+        case 's':
+            raw_func = get_cblas_sdot();
+            break;
+        case 'd':
+            raw_func = get_cblas_ddot();
+            break;
+        case 'c':
+            raw_func = conjugate ? get_cblas_cdotc() : get_cblas_cdotu();
+            break;
+        case 'z':
+            raw_func = conjugate ? get_cblas_zdotc() : get_cblas_zdotu();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    _n = (F_INT) n;
+
+    switch (kind)
+    {
+        case 's':
+            *(float *) result = (*(sdot_t) raw_func)(&_n, dx, &inc, dy, &inc);;
+            break;
+        case 'd':
+            *(double *) result = (*(ddot_t) raw_func)(&_n, dx, &inc, dy, &inc);;
+            break;
+        case 'c':
+            *(npy_complex64 *) result = (*(cdot_t) raw_func)(&_n, dx, &inc, dy,\
+                                        &inc);;
+            break;
+        case 'z':
+            *(npy_complex128 *) result = (*(zdot_t) raw_func)(&_n, dx, &inc,\
+                                         dy, &inc);;
+            break;
+    }
+
+    return 0;
+}
+
+/* Matrix * vector: y = alpha * a * x + beta * y */
+NUMBA_EXPORT_FUNC(int)
+numba_xxgemv(char kind, char trans, Py_ssize_t m, Py_ssize_t n,
+             void *alpha, void *a, Py_ssize_t lda,
+             void *x, void *beta, void *y)
+{
+    void *raw_func = NULL;
+    F_INT _m, _n;
+    F_INT _lda;
+    F_INT inc = 1;
+
+    ENSURE_VALID_KIND(kind)
+
+    switch (kind)
+    {
+        case 's':
+            raw_func = get_cblas_sgemv();
+            break;
+        case 'd':
+            raw_func = get_cblas_dgemv();
+            break;
+        case 'c':
+            raw_func = get_cblas_cgemv();
+            break;
+        case 'z':
+            raw_func = get_cblas_zgemv();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    _m = (F_INT) m;
+    _n = (F_INT) n;
+    _lda = (F_INT) lda;
+
+    (*(xxgemv_t) raw_func)(&trans, &_m, &_n, alpha, a, &_lda,
+                           x, &inc, beta, y, &inc);
+    return 0;
+}
+
+/* Matrix * matrix: c = alpha * a * b + beta * c */
+NUMBA_EXPORT_FUNC(int)
+numba_xxgemm(char kind, char transa, char transb,
+             Py_ssize_t m, Py_ssize_t n, Py_ssize_t k,
+             void *alpha, void *a, Py_ssize_t lda,
+             void *b, Py_ssize_t ldb, void *beta,
+             void *c, Py_ssize_t ldc)
+{
+    void *raw_func = NULL;
+    F_INT _m, _n, _k;
+    F_INT _lda, _ldb, _ldc;
+
+    ENSURE_VALID_KIND(kind)
+
+    switch (kind)
+    {
+        case 's':
+            raw_func = get_cblas_sgemm();
+            break;
+        case 'd':
+            raw_func = get_cblas_dgemm();
+            break;
+        case 'c':
+            raw_func = get_cblas_cgemm();
+            break;
+        case 'z':
+            raw_func = get_cblas_zgemm();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    _m = (F_INT) m;
+    _n = (F_INT) n;
+    _k = (F_INT) k;
+    _lda = (F_INT) lda;
+    _ldb = (F_INT) ldb;
+    _ldc = (F_INT) ldc;
+
+    (*(xxgemm_t) raw_func)(&transa, &transb, &_m, &_n, &_k, alpha, a, &_lda,
+                           b, &_ldb, beta, c, &_ldc);
+    return 0;
+}
+
+
+/* L2-norms */
+NUMBA_EXPORT_FUNC(F_INT)
+numba_xxnrm2(char kind, Py_ssize_t n, void * x, Py_ssize_t incx, void * result)
+{
+    void *raw_func = NULL;
+    F_INT _incx;
+    F_INT _n;
+
+    ENSURE_VALID_KIND(kind)
+
+    switch (kind)
+    {
+        case 's':
+            raw_func = get_cblas_snrm2();
+            break;
+        case 'd':
+            raw_func = get_cblas_dnrm2();
+            break;
+        case 'c':
+            raw_func = get_cblas_scnrm2();
+            break;
+        case 'z':
+            raw_func = get_cblas_dznrm2();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    _n = (F_INT) n;
+    _incx = (F_INT) incx;
+
+    switch (kind)
+    {
+        case 's':
+            *(float *) result = (*(sxnrm2_t) raw_func)(&_n, x, &_incx);;
+            break;
+        case 'd':
+            *(double *) result = (*(dxnrm2_t) raw_func)(&_n, x, &_incx);;
+            break;
+        case 'c':
+            *(float *) result = (*(sxnrm2_t) raw_func)(&_n, x, &_incx);;
+            break;
+        case 'z':
+            *(double *) result = (*(dxnrm2_t) raw_func)(&_n, x, &_incx);;
+            break;
+    }
+
+    return 0;
+}
+
+
+/*
+ * LAPACK calling helpers.  The helpers can be called without the GIL held.
+ * The caller is responsible for checking arguments (especially dimensions).
+ */
+
+/* Fast getters caching the value of a function's address after
+   the first call to import_clapack_function(). */
+
+#define EMIT_GET_CLAPACK_FUNC(name)                                 \
+    static void *clapack_ ## name = NULL;                           \
+    static void *get_clapack_ ## name(void) {                       \
+        if (clapack_ ## name == NULL) {                             \
+            PyGILState_STATE st = PyGILState_Ensure();              \
+            const char *mod = "scipy.linalg.cython_lapack";         \
+            clapack_ ## name = import_cython_function(mod, # name); \
+            PyGILState_Release(st);                                 \
+        }                                                           \
+        return clapack_ ## name;                                    \
+    }
+
+/* Computes an LU factorization of a general M-by-N matrix A
+ * using partial pivoting with row interchanges.
+ */
+EMIT_GET_CLAPACK_FUNC(sgetrf)
+EMIT_GET_CLAPACK_FUNC(dgetrf)
+EMIT_GET_CLAPACK_FUNC(cgetrf)
+EMIT_GET_CLAPACK_FUNC(zgetrf)
+
+/* Computes the inverse of a matrix using the LU factorization
+ * computed by xGETRF.
+ */
+EMIT_GET_CLAPACK_FUNC(sgetri)
+EMIT_GET_CLAPACK_FUNC(dgetri)
+EMIT_GET_CLAPACK_FUNC(cgetri)
+EMIT_GET_CLAPACK_FUNC(zgetri)
+
+/* Compute Cholesky factorizations */
+EMIT_GET_CLAPACK_FUNC(spotrf)
+EMIT_GET_CLAPACK_FUNC(dpotrf)
+EMIT_GET_CLAPACK_FUNC(cpotrf)
+EMIT_GET_CLAPACK_FUNC(zpotrf)
+
+/* Computes for an N-by-N real nonsymmetric matrix A, the
+ * eigenvalues and, optionally, the left and/or right eigenvectors.
+ */
+EMIT_GET_CLAPACK_FUNC(sgeev)
+EMIT_GET_CLAPACK_FUNC(dgeev)
+EMIT_GET_CLAPACK_FUNC(cgeev)
+EMIT_GET_CLAPACK_FUNC(zgeev)
+
+/* Computes for an N-by-N Hermitian matrix A, the
+ * eigenvalues and, optionally, the left and/or right eigenvectors.
+ */
+EMIT_GET_CLAPACK_FUNC(ssyevd)
+EMIT_GET_CLAPACK_FUNC(dsyevd)
+EMIT_GET_CLAPACK_FUNC(cheevd)
+EMIT_GET_CLAPACK_FUNC(zheevd)
+
+/* Computes generalised SVD */
+EMIT_GET_CLAPACK_FUNC(sgesdd)
+EMIT_GET_CLAPACK_FUNC(dgesdd)
+EMIT_GET_CLAPACK_FUNC(cgesdd)
+EMIT_GET_CLAPACK_FUNC(zgesdd)
+
+/* Computes QR decompositions */
+EMIT_GET_CLAPACK_FUNC(sgeqrf)
+EMIT_GET_CLAPACK_FUNC(dgeqrf)
+EMIT_GET_CLAPACK_FUNC(cgeqrf)
+EMIT_GET_CLAPACK_FUNC(zgeqrf)
+
+/* Computes columns of Q from elementary reflectors produced by xgeqrf() (QR).
+ */
+EMIT_GET_CLAPACK_FUNC(sorgqr)
+EMIT_GET_CLAPACK_FUNC(dorgqr)
+EMIT_GET_CLAPACK_FUNC(cungqr)
+EMIT_GET_CLAPACK_FUNC(zungqr)
+
+/* Computes the minimum norm solution to linear least squares problems */
+EMIT_GET_CLAPACK_FUNC(sgelsd)
+EMIT_GET_CLAPACK_FUNC(dgelsd)
+EMIT_GET_CLAPACK_FUNC(cgelsd)
+EMIT_GET_CLAPACK_FUNC(zgelsd)
+
+// Computes the solution to a system of linear equations
+EMIT_GET_CLAPACK_FUNC(sgesv)
+EMIT_GET_CLAPACK_FUNC(dgesv)
+EMIT_GET_CLAPACK_FUNC(cgesv)
+EMIT_GET_CLAPACK_FUNC(zgesv)
+
+
+#undef EMIT_GET_CLAPACK_FUNC
+
+typedef void (*xxgetrf_t)(F_INT *m, F_INT *n, void *a, F_INT *lda, F_INT *ipiv,
+                          F_INT *info);
+
+typedef void (*xxgetri_t)(F_INT *n, void *a, F_INT *lda, F_INT *ipiv, void
+                          *work, F_INT *lwork, F_INT *info);
+
+typedef void (*xxpotrf_t)(char *uplo, F_INT *n, void *a, F_INT *lda, F_INT
+                          *info);
+
+typedef void (*rgeev_t)(char *jobvl, char *jobvr, F_INT *n, void *a, F_INT *lda,
+                        void *wr, void *wi, void *vl, F_INT *ldvl, void *vr,
+                        F_INT *ldvr, void *work, F_INT *lwork, F_INT *info);
+
+typedef void (*cgeev_t)(char *jobvl, char *jobvr, F_INT *n, void *a, F_INT
+                        *lda, void *w, void *vl, F_INT *ldvl, void *vr,
+                        F_INT *ldvr, void *work, F_INT *lwork, void *rwork,
+                        F_INT *info);
+
+typedef void (*rgesdd_t)(char *jobz, F_INT *m, F_INT *n, void *a, F_INT *lda,
+                         void *s, void *u, F_INT *ldu, void *vt, F_INT *ldvt,
+                         void *work, F_INT *lwork, F_INT *iwork, F_INT *info);
+
+typedef void (*cgesdd_t)(char *jobz, F_INT *m, F_INT *n, void *a, F_INT *lda,
+                         void *s, void * u, F_INT *ldu, void * vt, F_INT *ldvt,
+                         void *work, F_INT *lwork, void *rwork, F_INT *iwork,
+                         F_INT *info);
+
+typedef void (*xsyevd_t)(char *jobz, char *uplo, F_INT *n, void *a, F_INT *lda,
+                         void *w, void *work, F_INT *lwork, F_INT *iwork,
+                         F_INT *liwork, F_INT *info);
+
+typedef void (*xheevd_t)(char *jobz, char *uplo, F_INT *n, void *a, F_INT *lda,
+                         void *w, void *work, F_INT *lwork, void *rwork,
+                         F_INT *lrwork, F_INT *iwork, F_INT *liwork,
+                         F_INT *info);
+
+typedef void (*xgeqrf_t)(F_INT *m, F_INT *n, void *a, F_INT *lda, void *tau,
+                         void *work, F_INT *lwork, F_INT *info);
+
+typedef void (*xxxgqr_t)(F_INT *m, F_INT *n, F_INT *k, void *a, F_INT *lda,
+                         void *tau, void *work, F_INT *lwork, F_INT *info);
+
+typedef void (*rgelsd_t)(F_INT *m, F_INT *n, F_INT *nrhs, void *a, F_INT *lda,
+                         void *b, F_INT *ldb, void *s, void *rcond, F_INT *rank,
+                         void *work, F_INT *lwork, F_INT *iwork, F_INT *info);
+
+typedef void (*cgelsd_t)(F_INT *m, F_INT *n, F_INT *nrhs, void *a, F_INT *lda,
+                         void *b, F_INT *ldb, void *s, void *rcond, F_INT *rank,
+                         void *work, F_INT *lwork, void *rwork, F_INT *iwork,
+                         F_INT *info);
+
+typedef void (*xgesv_t)(F_INT *n, F_INT *nrhs, void *a, F_INT *lda, F_INT *ipiv,
+                        void *b, F_INT *ldb, F_INT *info);
+
+
+
+/*
+ * kind_size()
+ * gets the data size appropriate for a specified kind.
+ *
+ * Input:
+ * kind - the kind, one of:
+ *         (s, d, c, z) = (float, double, complex, double complex).
+ *
+ * Returns:
+ * data_size - the appropriate data size.
+ *
+ */
+static size_t kind_size(char kind)
+{
+    size_t data_size = 0;
+    switch (kind)
+    {
+        case 's':
+            data_size  = sizeof(float);
+            break;
+        case 'd':
+            data_size  = sizeof(double);
+            break;
+        case 'c':
+            data_size  = sizeof(npy_complex64);
+            break;
+        case 'z':
+            data_size  = sizeof(npy_complex128);
+            break;
+    }
+    return data_size;
+
+}
+
+/*
+ * underlying_float_kind()
+ * gets the underlying float kind for a given kind.
+ *
+ * Input:
+ * kind - the kind, one of:
+ *         (s, d, c, z) = (float, double, complex, double complex).
+ *
+ * Returns:
+ * underlying_float_kind - the underlying float kind, one of:
+ *         (s, d) = (float, double).
+ *
+ * This function essentially provides a map between the char kind
+ * of a type and the char kind of the underlying float used in the
+ * type. Essentially:
+ * ---------------
+ * Input -> Output
+ * ---------------
+ *     s -> s
+ *     d -> d
+ *     c -> s
+ *     z -> d
+ * ---------------
+ *
+ */
+static char underlying_float_kind(char kind)
+{
+    switch(kind)
+    {
+        case 's':
+        case 'c':
+            return 's';
+        case 'd':
+        case 'z':
+            return 'd';
+        default:
+        {
+            PyGILState_STATE st = PyGILState_Ensure();
+            PyErr_SetString(PyExc_ValueError,
+                            "invalid kind in underlying_float_kind()");
+            PyGILState_Release(st);
+        }
+    }
+    return -1;
+}
+
+/*
+ * cast_from_X()
+ * cast from a kind (s, d, c, z) = (float, double, complex, double complex)
+ * to a Fortran integer.
+ *
+ * Parameters:
+ * kind the kind of val
+ * val  a pointer to the value to cast
+ *
+ * Returns:
+ * A Fortran int from a cast of val (in complex case, takes the real part).
+ *
+ * Struct access via non c99 (python only) cmplx types, used for compatibility.
+ */
+static F_INT
+cast_from_X(char kind, void *val)
+{
+    switch(kind)
+    {
+        case 's':
+            return (F_INT)(*((float *) val));
+        case 'd':
+            return (F_INT)(*((double *) val));
+        case 'c':
+            return (F_INT)crealf(*((_complex_float_t *)val));
+        case 'z':
+            return (F_INT)creal(*((_complex_double_t *)val));
+        default:
+        {
+            PyGILState_STATE st = PyGILState_Ensure();
+            PyErr_SetString(PyExc_ValueError,
+                            "invalid kind in cast");
+            PyGILState_Release(st);
+        }
+    }
+    return -1;
+}
+
+
+#define CATCH_LAPACK_INVALID_ARG(__routine, info)                      \
+    do {                                                               \
+        if (info < 0) {                                                \
+            PyGILState_STATE st = PyGILState_Ensure();                 \
+            PyErr_Format(PyExc_RuntimeError,                           \
+                 "LAPACK Error: Routine " #__routine ". On input %d\n",\
+                  -(int) info);                                        \
+            PyGILState_Release(st);                                    \
+            return STATUS_ERROR;                                       \
+        }                                                              \
+    } while(0)
+
+/* Compute LU decomposition of A
+ * NOTE: ipiv is an array of Fortran integers allocated by the caller,
+ * which is therefore expected to use the right dtype.
+ */
+NUMBA_EXPORT_FUNC(int)
+numba_xxgetrf(char kind, Py_ssize_t m, Py_ssize_t n, void *a, Py_ssize_t lda,
+              F_INT *ipiv)
+{
+    void *raw_func = NULL;
+    F_INT _m, _n, _lda, info;
+
+    ENSURE_VALID_KIND(kind)
+
+    switch (kind)
+    {
+        case 's':
+            raw_func = get_clapack_sgetrf();
+            break;
+        case 'd':
+            raw_func = get_clapack_dgetrf();
+            break;
+        case 'c':
+            raw_func = get_clapack_cgetrf();
+            break;
+        case 'z':
+            raw_func = get_clapack_zgetrf();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    _m = (F_INT) m;
+    _n = (F_INT) n;
+    _lda = (F_INT) lda;
+
+    (*(xxgetrf_t) raw_func)(&_m, &_n, a, &_lda, ipiv, &info);
+    CATCH_LAPACK_INVALID_ARG("xxgetrf", info);
+
+    return (int)info;
+}
+
+/* Compute the inverse of a matrix given its LU decomposition
+ * Args are as per LAPACK.
+ */
+static int
+numba_raw_xxgetri(char kind, F_INT n, void *a, F_INT lda,
+                  F_INT *ipiv, void *work, F_INT *lwork, F_INT *info)
+{
+    void *raw_func = NULL;
+
+    ENSURE_VALID_KIND(kind)
+
+    switch (kind)
+    {
+        case 's':
+            raw_func = get_clapack_sgetri();
+            break;
+        case 'd':
+            raw_func = get_clapack_dgetri();
+            break;
+        case 'c':
+            raw_func = get_clapack_cgetri();
+            break;
+        case 'z':
+            raw_func = get_clapack_zgetri();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    (*(xxgetri_t) raw_func)(&n, a, &lda, ipiv, work, lwork, info);
+
+    return 0;
+}
+
+/* Compute the inverse of a matrix from the factorization provided by
+ * xxgetrf. (see numba_xxgetrf() about ipiv)
+ * Args are as per LAPACK.
+ */
+NUMBA_EXPORT_FUNC(int)
+numba_ez_xxgetri(char kind, Py_ssize_t n, void *a, Py_ssize_t lda,
+                 F_INT *ipiv)
+{
+    F_INT _n, _lda;
+    F_INT lwork = -1;
+    F_INT info = 0;
+    size_t base_size = -1;
+    void * work = NULL;
+    all_dtypes stack_slot;
+
+    ENSURE_VALID_KIND(kind)
+
+    _n = (F_INT)n;
+    _lda = (F_INT)lda;
+
+    base_size = kind_size(kind);
+
+    work = &stack_slot;
+
+    numba_raw_xxgetri(kind, _n, a, _lda, ipiv, work, &lwork, &info);
+    CATCH_LAPACK_INVALID_ARG("xxgetri", info);
+
+    lwork = cast_from_X(kind, work);
+
+    if (checked_PyMem_RawMalloc(&work, base_size * lwork))
+    {
+        return STATUS_ERROR;
+    }
+
+    numba_raw_xxgetri(kind, _n, a, _lda, ipiv, work, &lwork, &info);
+    PyMem_RawFree(work);
+    CATCH_LAPACK_INVALID_ARG("xxgetri", info);
+
+    return (int)info;
+}
+
+/* Compute the Cholesky factorization of a matrix. */
+NUMBA_EXPORT_FUNC(int)
+numba_xxpotrf(char kind, char uplo, Py_ssize_t n, void *a, Py_ssize_t lda)
+{
+    void *raw_func = NULL;
+    F_INT _n, _lda, info;
+
+    ENSURE_VALID_KIND(kind)
+
+    switch (kind)
+    {
+        case 's':
+            raw_func = get_clapack_spotrf();
+            break;
+        case 'd':
+            raw_func = get_clapack_dpotrf();
+            break;
+        case 'c':
+            raw_func = get_clapack_cpotrf();
+            break;
+        case 'z':
+            raw_func = get_clapack_zpotrf();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    _n = (F_INT) n;
+    _lda = (F_INT) lda;
+
+    (*(xxpotrf_t) raw_func)(&uplo, &_n, a, &_lda, &info);
+    CATCH_LAPACK_INVALID_ARG("xxpotrf", info);
+    return (int)info;
+}
+
+
+/* real space eigen systems info from dgeev/sgeev */
+static int
+numba_raw_rgeev(char kind, char jobvl, char jobvr,
+                Py_ssize_t n, void *a, Py_ssize_t lda, void *wr, void *wi,
+                void *vl, Py_ssize_t ldvl, void *vr, Py_ssize_t ldvr,
+                void *work, Py_ssize_t lwork, F_INT *info)
+{
+    void *raw_func = NULL;
+    F_INT _n, _lda, _ldvl, _ldvr, _lwork;
+
+    ENSURE_VALID_REAL_KIND(kind)
+
+    switch (kind)
+    {
+        case 's':
+            raw_func = get_clapack_sgeev();
+            break;
+        case 'd':
+            raw_func = get_clapack_dgeev();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    _n = (F_INT) n;
+    _lda = (F_INT) lda;
+    _ldvl = (F_INT) ldvl;
+    _ldvr = (F_INT) ldvr;
+    _lwork = (F_INT) lwork;
+
+    (*(rgeev_t) raw_func)(&jobvl, &jobvr, &_n, a, &_lda, wr, wi, vl, &_ldvl, vr,
+                          &_ldvr, work, &_lwork, info);
+    return 0;
+}
+
+/* Real space eigen systems info from dgeev/sgeev
+ * as numba_raw_rgeev but the allocation and error handling is done for the user.
+ * Args are as per LAPACK.
+ */
+NUMBA_EXPORT_FUNC(int)
+numba_ez_rgeev(char kind, char jobvl, char jobvr, Py_ssize_t n, void *a,
+               Py_ssize_t lda, void *wr, void *wi, void *vl, Py_ssize_t ldvl,
+               void *vr, Py_ssize_t ldvr)
+{
+    F_INT info = 0;
+    F_INT lwork = -1;
+    F_INT _n, _lda, _ldvl, _ldvr;
+    size_t base_size = -1;
+    void * work = NULL;
+    all_dtypes stack_slot;
+
+    ENSURE_VALID_REAL_KIND(kind)
+
+    _n = (F_INT) n;
+    _lda = (F_INT) lda;
+    _ldvl = (F_INT) ldvl;
+    _ldvr = (F_INT) ldvr;
+
+    base_size = kind_size(kind);
+
+    work = &stack_slot;
+    numba_raw_rgeev(kind, jobvl, jobvr, _n, a, _lda, wr, wi, vl, _ldvl,
+                    vr, _ldvr, work, lwork, &info);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_rgeev", info);
+
+    lwork = cast_from_X(kind, work);
+    if (checked_PyMem_RawMalloc(&work, base_size * lwork))
+    {
+        return STATUS_ERROR;
+    }
+    numba_raw_rgeev(kind, jobvl, jobvr, _n, a, _lda, wr, wi, vl, _ldvl,
+                    vr, _ldvr, work, lwork, &info);
+    PyMem_RawFree(work);
+
+    CATCH_LAPACK_INVALID_ARG("numba_raw_rgeev", info);
+
+    return (int)info;
+}
+
+/* Complex space eigen systems info from cgeev/zgeev
+ * Args are as per LAPACK.
+ */
+static int
+numba_raw_cgeev(char kind, char jobvl, char jobvr,
+                Py_ssize_t n, void *a, Py_ssize_t lda, void *w, void *vl,
+                Py_ssize_t ldvl, void *vr, Py_ssize_t ldvr, void *work,
+                Py_ssize_t lwork, void *rwork, F_INT *info)
+{
+    void *raw_func = NULL;
+    F_INT _n, _lda, _ldvl, _ldvr, _lwork;
+
+    ENSURE_VALID_COMPLEX_KIND(kind)
+
+    _n = (F_INT) n;
+    _lda = (F_INT) lda;
+    _ldvl = (F_INT) ldvl;
+    _ldvr = (F_INT) ldvr;
+    _lwork = (F_INT) lwork;
+
+    switch (kind)
+    {
+        case 'c':
+            raw_func = get_clapack_cgeev();
+            break;
+        case 'z':
+            raw_func = get_clapack_zgeev();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    (*(cgeev_t) raw_func)(&jobvl, &jobvr, &_n, a, &_lda, w, vl, &_ldvl, vr,
+                          &_ldvr, work, &_lwork, rwork, info);
+    return 0;
+}
+
+
+/* Complex space eigen systems info from cgeev/zgeev
+ * as numba_raw_cgeev but the allocation and error handling is done for the user.
+ * Args are as per LAPACK.
+ */
+NUMBA_EXPORT_FUNC(int)
+numba_ez_cgeev(char kind, char jobvl, char jobvr,  Py_ssize_t n, void *a,
+               Py_ssize_t lda, void *w, void *vl, Py_ssize_t ldvl, void *vr,
+               Py_ssize_t ldvr)
+{
+    F_INT info = 0;
+    F_INT lwork = -1;
+    F_INT _n, _lda, _ldvl, _ldvr;
+    size_t base_size = -1;
+    all_dtypes stack_slot, wk;
+    void * work = NULL;
+    void * rwork = (void *)&wk;
+
+    ENSURE_VALID_COMPLEX_KIND(kind)
+
+    _n = (F_INT) n;
+    _lda = (F_INT) lda;
+    _ldvl = (F_INT) ldvl;
+    _ldvr = (F_INT) ldvr;
+
+    base_size = kind_size(kind);
+
+    work = &stack_slot;
+    numba_raw_cgeev(kind, jobvl, jobvr, n, a, lda, w, vl, ldvl,
+                    vr, ldvr, work, lwork, rwork, &info);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_cgeev", info);
+
+    lwork = cast_from_X(kind, work);
+    if (checked_PyMem_RawMalloc((void**)&rwork, 2*n*base_size))
+    {
+        return STATUS_ERROR;
+    }
+    if (checked_PyMem_RawMalloc(&work, base_size * lwork))
+    {
+        PyMem_RawFree(rwork);
+        return STATUS_ERROR;
+    }
+    numba_raw_cgeev(kind, jobvl, jobvr, _n, a, _lda, w, vl, _ldvl,
+                    vr, _ldvr, work, lwork, rwork, &info);
+    PyMem_RawFree(work);
+    PyMem_RawFree(rwork);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_cgeev", info);
+
+    return (int)info;
+}
+
+/* real space symmetric eigen systems info from ssyevd/dsyevd */
+static int
+numba_raw_rsyevd(char kind, char jobz, char uplo, Py_ssize_t n, void *a,
+                 Py_ssize_t lda, void *w, void *work, Py_ssize_t lwork,
+                 F_INT *iwork, Py_ssize_t liwork, F_INT *info)
+{
+    void *raw_func = NULL;
+    F_INT _n, _lda, _lwork, _liwork;
+
+    ENSURE_VALID_REAL_KIND(kind)
+
+    switch (kind)
+    {
+        case 's':
+            raw_func = get_clapack_ssyevd();
+            break;
+        case 'd':
+            raw_func = get_clapack_dsyevd();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    _n = (F_INT) n;
+    _lda = (F_INT) lda;
+    _lwork = (F_INT) lwork;
+    _liwork = (F_INT) liwork;
+
+    (*(xsyevd_t) raw_func)(&jobz, &uplo, &_n, a, &_lda, w, work, &_lwork, iwork, &_liwork, info);
+    return 0;
+}
+
+/* Real space eigen systems info from dsyevd/ssyevd
+ * as numba_raw_rsyevd but the allocation and error handling is done for the user.
+ * Args are as per LAPACK.
+ */
+static int
+numba_ez_rsyevd(char kind, char jobz, char uplo, Py_ssize_t n, void *a, Py_ssize_t lda, void *w)
+{
+    F_INT info = 0;
+    F_INT lwork = -1, liwork=-1;
+    F_INT _n, _lda;
+    size_t base_size = -1;
+    void *work = NULL;
+    F_INT *iwork = NULL;
+    all_dtypes stack_slot;
+    int stack_int = -1;
+
+    ENSURE_VALID_REAL_KIND(kind)
+
+    _n = (F_INT) n;
+    _lda = (F_INT) lda;
+
+    base_size = kind_size(kind);
+
+    work = &stack_slot;
+    iwork = &stack_int;
+    numba_raw_rsyevd(kind, jobz, uplo, _n, a, _lda, w, work, lwork, iwork, liwork, &info);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_rsyevd", info);
+
+    lwork = cast_from_X(kind, work);
+    if (checked_PyMem_RawMalloc(&work, base_size * lwork))
+    {
+        return STATUS_ERROR;
+    }
+    liwork = *iwork;
+    if (checked_PyMem_RawMalloc((void**)&iwork, base_size * liwork))
+    {
+        PyMem_RawFree(work);
+        return STATUS_ERROR;
+    }
+    numba_raw_rsyevd(kind, jobz, uplo, _n, a, _lda, w, work, lwork, iwork, liwork, &info);
+    PyMem_RawFree(work);
+    PyMem_RawFree(iwork);
+
+    CATCH_LAPACK_INVALID_ARG("numba_raw_rsyevd", info);
+
+    return (int)info;
+}
+
+
+/* complex space symmetric eigen systems info from cheevd/zheevd*/
+static int
+numba_raw_cheevd(char kind, char jobz, char uplo, Py_ssize_t n, void *a,
+                 Py_ssize_t lda, void *w, void *work, Py_ssize_t lwork,
+                 void *rwork, Py_ssize_t lrwork, F_INT *iwork,
+                 Py_ssize_t liwork, F_INT *info)
+{
+    void *raw_func = NULL;
+    F_INT _n, _lda, _lwork, _lrwork, _liwork;
+
+    ENSURE_VALID_COMPLEX_KIND(kind)
+
+    switch (kind)
+    {
+        case 'c':
+            raw_func = get_clapack_cheevd();
+            break;
+        case 'z':
+            raw_func = get_clapack_zheevd();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    _n = (F_INT) n;
+    _lda = (F_INT) lda;
+    _lwork = (F_INT) lwork;
+    _lrwork = (F_INT) lrwork;
+    _liwork = (F_INT) liwork;
+
+    (*(xheevd_t) raw_func)(&jobz, &uplo, &_n, a, &_lda, w, work, &_lwork, rwork, &_lrwork, iwork, &_liwork, info);
+    return 0;
+}
+
+/* complex space eigen systems info from cheevd/zheevd
+ * as numba_raw_cheevd but the allocation and error handling is done for the user.
+ * Args are as per LAPACK.
+ */
+static int
+numba_ez_cheevd(char kind, char jobz, char uplo, Py_ssize_t n, void *a, Py_ssize_t lda, void *w)
+{
+    F_INT info = 0;
+    F_INT lwork = -1, lrwork = -1, liwork=-1;
+    F_INT _n, _lda;
+    size_t base_size = -1, underlying_float_size = -1;
+    void *work = NULL, *rwork = NULL;
+    F_INT *iwork = NULL;
+    all_dtypes stack_slot1, stack_slot2;
+    char uf_kind;
+    int stack_int = -1;
+
+    ENSURE_VALID_COMPLEX_KIND(kind)
+
+    _n = (F_INT) n;
+    _lda = (F_INT) lda;
+
+    base_size = kind_size(kind);
+    uf_kind = underlying_float_kind(kind);
+    underlying_float_size = kind_size(uf_kind);
+
+    work = &stack_slot1;
+    rwork = &stack_slot2;
+    iwork = &stack_int;
+    numba_raw_cheevd(kind, jobz, uplo, _n, a, _lda, w, work, lwork, rwork, lrwork, iwork, liwork, &info);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_cheevd", info);
+
+    lwork = cast_from_X(uf_kind, work);
+    if (checked_PyMem_RawMalloc(&work, base_size * lwork))
+    {
+        return STATUS_ERROR;
+    }
+
+    lrwork = cast_from_X(uf_kind, rwork);
+    if (checked_PyMem_RawMalloc(&rwork, underlying_float_size * lrwork))
+    {
+        PyMem_RawFree(work);
+        return STATUS_ERROR;
+    }
+
+    liwork = *iwork;
+    if (checked_PyMem_RawMalloc((void**)&iwork, base_size * liwork))
+    {
+        PyMem_RawFree(work);
+        PyMem_RawFree(rwork);
+        return STATUS_ERROR;
+    }
+    numba_raw_cheevd(kind, jobz, uplo, _n, a, _lda, w, work, lwork, rwork, lrwork, iwork, liwork, &info);
+    PyMem_RawFree(work);
+    PyMem_RawFree(rwork);
+    PyMem_RawFree(iwork);
+
+    CATCH_LAPACK_INVALID_ARG("numba_raw_cheevd", info);
+
+    return (int)info;
+}
+
+/* Hermitian eigenvalue systems info from *syevd and *heevd.
+ * This routine hides the type and general complexity involved with making the
+ * calls. The work space computation and error handling etc is hidden.
+ * Args are as per LAPACK.
+ */
+NUMBA_EXPORT_FUNC(int)
+numba_ez_xxxevd(char kind, char jobz, char uplo, Py_ssize_t n, void *a, Py_ssize_t lda, void *w)
+{
+    ENSURE_VALID_KIND(kind)
+
+    switch (kind)
+    {
+        case 's':
+        case 'd':
+            return numba_ez_rsyevd(kind, jobz, uplo, n, a, lda, w);
+        case 'c':
+        case 'z':
+            return numba_ez_cheevd(kind, jobz, uplo, n, a, lda, w);
+    }
+    return STATUS_ERROR; /* unreachable */
+}
+
+/* Real space svd systems info from dgesdd/sgesdd
+ * Args are as per LAPACK.
+ */
+static int
+numba_raw_rgesdd(char kind, char jobz, Py_ssize_t m, Py_ssize_t n, void *a,
+                 Py_ssize_t lda, void *s, void *u, Py_ssize_t ldu, void *vt,
+                 Py_ssize_t ldvt, void *work, Py_ssize_t lwork,
+                 F_INT *iwork, F_INT *info)
+{
+    void *raw_func = NULL;
+    F_INT _m, _n, _lda, _ldu, _ldvt, _lwork;
+
+    ENSURE_VALID_REAL_KIND(kind)
+
+    _m = (F_INT) m;
+    _n = (F_INT) n;
+    _lda = (F_INT) lda;
+    _ldu = (F_INT) ldu;
+    _ldvt = (F_INT) ldvt;
+    _lwork = (F_INT) lwork;
+
+    switch (kind)
+    {
+        case 's':
+            raw_func = get_clapack_sgesdd();
+            break;
+        case 'd':
+            raw_func = get_clapack_dgesdd();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    (*(rgesdd_t) raw_func)(&jobz, &_m, &_n, a, &_lda, s, u, &_ldu, vt, &_ldvt,
+                           work, &_lwork, iwork, info);
+    return 0;
+}
+
+/* Real space svd info from dgesdd/sgesdd.
+ * As numba_raw_rgesdd but the allocation and error handling is done for the
+ * user.
+ * Args are as per LAPACK.
+ */
+static int
+numba_ez_rgesdd(char kind, char jobz, Py_ssize_t m, Py_ssize_t n, void *a,
+                Py_ssize_t lda, void *s, void *u, Py_ssize_t ldu, void *vt,
+                Py_ssize_t ldvt)
+{
+    F_INT info = 0;
+    Py_ssize_t minmn = -1;
+    Py_ssize_t lwork = -1;
+    all_dtypes stack_slot, wk;
+    size_t base_size = -1;
+    F_INT *iwork = (F_INT *)&wk;
+    void *work = NULL;
+
+    ENSURE_VALID_REAL_KIND(kind)
+
+    base_size = kind_size(kind);
+
+    work = &stack_slot;
+
+    /* Compute optimal work size (lwork) */
+    numba_raw_rgesdd(kind, jobz, m, n, a, lda, s, u, ldu, vt, ldvt, work,
+                     lwork, iwork, &info);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_rgesdd", info);
+
+    /* Allocate work array */
+    lwork = cast_from_X(kind, work);
+    if (checked_PyMem_RawMalloc(&work, base_size * lwork))
+        return -1;
+    minmn = m > n ? n : m;
+    if (checked_PyMem_RawMalloc((void**) &iwork, 8 * minmn * sizeof(F_INT)))
+    {
+        PyMem_RawFree(work);
+        return STATUS_ERROR;
+    }
+    numba_raw_rgesdd(kind, jobz, m, n, a, lda, s, u ,ldu, vt, ldvt, work, lwork,
+                     iwork, &info);
+    PyMem_RawFree(work);
+    PyMem_RawFree(iwork);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_rgesdd", info);
+
+    return (int)info;
+}
+
+/* Complex space svd systems info from cgesdd/zgesdd
+ * Args are as per LAPACK.
+ */
+static int
+numba_raw_cgesdd(char kind, char jobz, Py_ssize_t m, Py_ssize_t n, void *a,
+                 Py_ssize_t lda, void *s, void *u, Py_ssize_t ldu, void *vt,
+                 Py_ssize_t ldvt, void *work, Py_ssize_t lwork, void *rwork,
+                 F_INT *iwork, F_INT *info)
+{
+    void *raw_func = NULL;
+    F_INT _m, _n, _lda, _ldu, _ldvt, _lwork;
+
+    ENSURE_VALID_COMPLEX_KIND(kind)
+
+    _m = (F_INT) m;
+    _n = (F_INT) n;
+    _lda = (F_INT) lda;
+    _ldu = (F_INT) ldu;
+    _ldvt = (F_INT) ldvt;
+    _lwork = (F_INT) lwork;
+
+    switch (kind)
+    {
+        case 'c':
+            raw_func = get_clapack_cgesdd();
+            break;
+        case 'z':
+            raw_func = get_clapack_zgesdd();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    (*(cgesdd_t) raw_func)(&jobz, &_m, &_n, a, &_lda, s, u, &_ldu, vt, &_ldvt,
+                           work, &_lwork, rwork, iwork, info);
+    return 0;
+}
+
+/* complex space svd info from cgesdd/zgesdd.
+ * As numba_raw_cgesdd but the allocation and error handling is done for the
+ * user.
+ * Args are as per LAPACK.
+ */
+static int
+numba_ez_cgesdd(char kind, char jobz, Py_ssize_t m, Py_ssize_t n, void *a,
+                Py_ssize_t lda, void *s, void *u, Py_ssize_t ldu, void *vt,
+                Py_ssize_t ldvt)
+{
+    F_INT info = 0;
+    Py_ssize_t lwork = -1;
+    Py_ssize_t lrwork = -1;
+    Py_ssize_t minmn = -1;
+    Py_ssize_t tmp1, tmp2;
+    Py_ssize_t maxmn = -1;
+    size_t real_base_size = -1;
+    size_t complex_base_size = -1;
+    all_dtypes stack_slot, wk1, wk2;
+    void *work = NULL;
+    void *rwork = (void *)&wk1;
+    F_INT *iwork = (F_INT *)&wk2;
+
+    ENSURE_VALID_COMPLEX_KIND(kind)
+
+    switch (kind)
+    {
+        case 'c':
+            real_base_size = sizeof(float);
+            complex_base_size = sizeof(npy_complex64);
+            break;
+        case 'z':
+            real_base_size = sizeof(double);
+            complex_base_size = sizeof(npy_complex128);
+            break;
+        default:
+        {
+            PyGILState_STATE st = PyGILState_Ensure();
+            PyErr_SetString(PyExc_ValueError,\
+                            "Invalid kind in numba_ez_rgesdd");
+            PyGILState_Release(st);
+        }
+        return STATUS_ERROR;
+    }
+
+    work = &stack_slot;
+
+    /* Compute optimal work size (lwork) */
+    numba_raw_cgesdd(kind, jobz, m, n, a, lda, s, u ,ldu, vt, ldvt, work, lwork,
+                     rwork, iwork, &info);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_cgesdd", info);
+
+    /* Allocate work array */
+    lwork = cast_from_X(kind, work);
+    if (checked_PyMem_RawMalloc(&work, complex_base_size * lwork))
+        return STATUS_ERROR;
+
+    minmn = m > n ? n : m;
+    if (jobz == 'n')
+    {
+        lrwork = 7 * minmn;
+    }
+    else
+    {
+        maxmn = m > n ? m : n;
+        tmp1 = 5 * minmn + 7;
+        tmp2 = 2 * maxmn + 2 * minmn + 1;
+        lrwork = minmn * (tmp1 > tmp2 ? tmp1: tmp2);
+    }
+
+    if (checked_PyMem_RawMalloc(&rwork,
+                                real_base_size * (lrwork > 1 ? lrwork : 1)))
+    {
+        PyMem_RawFree(work);
+        return STATUS_ERROR;
+    }
+    if (checked_PyMem_RawMalloc((void **) &iwork,
+                                8 * minmn * sizeof(F_INT)))
+    {
+        PyMem_RawFree(work);
+        PyMem_RawFree(rwork);
+        return STATUS_ERROR;
+    }
+    numba_raw_cgesdd(kind, jobz, m, n, a, lda, s, u ,ldu, vt, ldvt, work, lwork,
+                     rwork, iwork, &info);
+    PyMem_RawFree(work);
+    PyMem_RawFree(rwork);
+    PyMem_RawFree(iwork);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_cgesdd", info);
+
+    return (int)info;
+}
+
+
+/* SVD systems info from *gesdd.
+ * This routine hides the type and general complexity involved with making the
+ * calls to *gesdd. The work space computation and error handling etc is hidden.
+ * Args are as per LAPACK.
+ */
+NUMBA_EXPORT_FUNC(int)
+numba_ez_gesdd(char kind, char jobz, Py_ssize_t m, Py_ssize_t n, void *a,
+               Py_ssize_t lda, void *s, void *u, Py_ssize_t ldu, void *vt,
+               Py_ssize_t ldvt)
+{
+    ENSURE_VALID_KIND(kind)
+
+    switch (kind)
+    {
+        case 's':
+        case 'd':
+            return numba_ez_rgesdd(kind, jobz, m, n, a, lda, s, u, ldu, vt,
+                                   ldvt);
+        case 'c':
+        case 'z':
+            return numba_ez_cgesdd(kind, jobz, m, n, a, lda, s, u, ldu, vt,
+                                   ldvt);
+    }
+    return STATUS_ERROR; /* unreachable */
+}
+
+
+/*
+ * Compute the QR factorization of a matrix.
+ * Return -1 on internal error, 0 on success, > 0 on failure.
+ */
+static int
+numba_raw_xgeqrf(char kind, Py_ssize_t m, Py_ssize_t n, void *a, Py_ssize_t
+                 lda, void *tau, void *work, Py_ssize_t lwork, F_INT *info)
+{
+    void *raw_func = NULL;
+    F_INT _m, _n, _lda, _lwork;
+
+    ENSURE_VALID_KIND(kind)
+
+    switch (kind)
+    {
+        case 's':
+            raw_func = get_clapack_sgeqrf();
+            break;
+        case 'd':
+            raw_func = get_clapack_dgeqrf();
+            break;
+        case 'c':
+            raw_func = get_clapack_cgeqrf();
+            break;
+        case 'z':
+            raw_func = get_clapack_zgeqrf();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    _m = (F_INT) m;
+    _n = (F_INT) n;
+    _lda = (F_INT) lda;
+    _lwork = (F_INT) lwork;
+
+    (*(xgeqrf_t) raw_func)(&_m, &_n, a, &_lda, tau, work, &_lwork, info);
+    return 0;
+}
+
+/*
+ * Compute the QR factorization of a matrix.
+ * This routine hides the type and general complexity involved with making the
+ * xgeqrf calls. The work space computation and error handling etc is hidden.
+ * Args are as per LAPACK.
+ */
+NUMBA_EXPORT_FUNC(int)
+numba_ez_geqrf(char kind, Py_ssize_t m, Py_ssize_t n, void *a, Py_ssize_t
+               lda, void *tau)
+{
+    F_INT info = 0;
+    Py_ssize_t lwork = -1;
+    size_t base_size = -1;
+    all_dtypes stack_slot;
+    void *work = NULL;
+
+    base_size = kind_size(kind);
+
+    work = &stack_slot;
+
+    /* Compute optimal work size (lwork) */
+    numba_raw_xgeqrf(kind, m, n, a, lda, tau, work, lwork, &info);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_xgeqrf", info);
+
+    /* Allocate work array */
+    lwork = cast_from_X(kind, work);
+    if (checked_PyMem_RawMalloc(&work, base_size * lwork))
+        return STATUS_ERROR;
+
+    numba_raw_xgeqrf(kind, m, n, a, lda, tau, work, lwork, &info);
+    PyMem_RawFree(work);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_xgeqrf", info);
+
+    return 0; /* info cannot be >0 */
+
+}
+
+
+/*
+ * Compute the orthogonal Q matrix (in QR) from elementary relectors.
+ */
+static int
+numba_raw_xxxgqr(char kind, Py_ssize_t m, Py_ssize_t n, Py_ssize_t k, void *a,
+                 Py_ssize_t lda, void *tau, void * work, Py_ssize_t lwork, F_INT *info)
+{
+    void *raw_func = NULL;
+    F_INT _m, _n, _k, _lda, _lwork;
+
+    ENSURE_VALID_KIND(kind)
+
+    switch (kind)
+    {
+        case 's':
+            raw_func = get_clapack_sorgqr();
+            break;
+        case 'd':
+            raw_func = get_clapack_dorgqr();
+            break;
+        case 'c':
+            raw_func = get_clapack_cungqr();
+            break;
+        case 'z':
+            raw_func = get_clapack_zungqr();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    _m = (F_INT) m;
+    _n = (F_INT) n;
+    _k = (F_INT) k;
+    _lda = (F_INT) lda;
+    _lwork = (F_INT) lwork;
+
+    (*(xxxgqr_t) raw_func)(&_m, &_n, &_k, a, &_lda, tau, work, &_lwork, info);
+    return 0;
+}
+
+
+/*
+ * Compute the orthogonal Q matrix (in QR) from elementary reflectors.
+ * This routine hides the type and general complexity involved with making the
+ * x{or,un}qrf calls. The work space computation and error handling etc is
+ * hidden. Args are as per LAPACK.
+ */
+NUMBA_EXPORT_FUNC(int)
+numba_ez_xxgqr(char kind, Py_ssize_t m, Py_ssize_t n, Py_ssize_t k, void *a,
+               Py_ssize_t lda, void *tau)
+{
+    F_INT info = 0;
+    Py_ssize_t lwork = -1;
+    size_t base_size = -1;
+    all_dtypes stack_slot;
+    void *work = NULL;
+
+    work = &stack_slot;
+
+    /* Compute optimal work size (lwork) */
+    numba_raw_xxxgqr(kind, m, n, k, a, lda, tau, work, lwork, &info);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_xxxgqr", info);
+
+    base_size = kind_size(kind);
+
+    /* Allocate work array */
+    lwork = cast_from_X(kind, work);
+    if (checked_PyMem_RawMalloc(&work, base_size * lwork))
+        return STATUS_ERROR;
+
+    numba_raw_xxxgqr(kind, m, n, k, a, lda, tau, work, lwork, &info);
+    PyMem_RawFree(work);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_xxxgqr", info);
+
+    return 0;  /* info cannot be >0 */
+
+}
+
+
+/*
+ * Compute the minimum-norm solution to a real linear least squares problem.
+ */
+static int
+numba_raw_rgelsd(char kind, Py_ssize_t m, Py_ssize_t n, Py_ssize_t nrhs,
+                 void *a, Py_ssize_t lda, void *b, Py_ssize_t ldb, void *S,
+                 void * rcond, Py_ssize_t * rank, void * work,
+                 Py_ssize_t lwork, F_INT *iwork, F_INT *info)
+{
+    void *raw_func = NULL;
+    F_INT _m, _n, _nrhs, _lda, _ldb, _rank, _lwork;
+
+    ENSURE_VALID_REAL_KIND(kind)
+
+    switch (kind)
+    {
+        case 's':
+            raw_func = get_clapack_sgelsd();
+            break;
+        case 'd':
+            raw_func = get_clapack_dgelsd();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    _m = (F_INT) m;
+    _n = (F_INT) n;
+    _nrhs = (F_INT) nrhs;
+    _lda = (F_INT) lda;
+    _ldb = (F_INT) ldb;
+    _lwork = (F_INT) lwork;
+
+    (*(rgelsd_t) raw_func)(&_m, &_n, &_nrhs, a, &_lda, b, &_ldb, S, rcond,
+                           &_rank, work, &_lwork, iwork, info);
+    *rank = (Py_ssize_t) _rank;
+    return 0;
+}
+
+/*
+ * Compute the minimum-norm solution to a real linear least squares problem.
+ * This routine hides the type and general complexity involved with making the
+ * {s,d}gelsd calls. The work space computation and error handling etc is
+ * hidden. Args are as per LAPACK.
+ */
+static int
+numba_ez_rgelsd(char kind, Py_ssize_t m, Py_ssize_t n, Py_ssize_t nrhs,
+                void *a, Py_ssize_t lda, void *b, Py_ssize_t ldb, void *S,
+                double rcond, Py_ssize_t * rank)
+{
+    F_INT info = 0;
+    Py_ssize_t lwork = -1;
+    size_t base_size = -1;
+    all_dtypes stack_slot;
+    void *work = NULL, *rcond_cast = NULL;
+    F_INT *iwork = NULL;
+    F_INT iwork_tmp;
+    float tmpf;
+
+    ENSURE_VALID_REAL_KIND(kind)
+
+    base_size = kind_size(kind);
+
+    work = &stack_slot;
+    rcond_cast = work; /* stop checks on null ptr complaining */
+
+    /* Compute optimal work size (lwork) */
+    numba_raw_rgelsd(kind, m, n, nrhs, a, lda, b, ldb, S, rcond_cast, rank,
+                     work, lwork, &iwork_tmp, &info);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_rgelsd", info);
+
+    /* Allocate work array */
+    lwork = cast_from_X(kind, work);
+    if (checked_PyMem_RawMalloc(&work, base_size * lwork))
+        return STATUS_ERROR;
+
+    /* Allocate iwork array */
+    if (checked_PyMem_RawMalloc((void **)&iwork, sizeof(F_INT) * iwork_tmp))
+    {
+        PyMem_RawFree(work);
+        return STATUS_ERROR;
+    }
+
+    /* cast rcond to the right type */
+    switch (kind)
+    {
+        case 's':
+            tmpf = (float)rcond;
+            rcond_cast = (void * )&tmpf;
+            break;
+        case 'd':
+            rcond_cast = (void * )&rcond;
+            break;
+    }
+
+    numba_raw_rgelsd(kind, m, n, nrhs, a, lda, b, ldb, S, rcond_cast, rank,
+                     work, lwork, iwork, &info);
+    PyMem_RawFree(work);
+    PyMem_RawFree(iwork);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_rgelsd", info);
+
+    return (int)info;
+}
+
+
+/*
+ * Compute the minimum-norm solution to a complex linear least squares problem.
+ */
+static int
+numba_raw_cgelsd(char kind, Py_ssize_t m, Py_ssize_t n, Py_ssize_t nrhs,
+                 void *a, Py_ssize_t lda, void *b, Py_ssize_t ldb, void *S,
+                 void *rcond, Py_ssize_t * rank, void * work,
+                 Py_ssize_t lwork, void * rwork, F_INT *iwork, F_INT *info)
+{
+    void *raw_func = NULL;
+    F_INT _m, _n, _nrhs, _lda, _ldb, _rank, _lwork;
+
+    ENSURE_VALID_COMPLEX_KIND(kind)
+
+    switch (kind)
+    {
+        case 'c':
+            raw_func = get_clapack_cgelsd();
+            break;
+        case 'z':
+            raw_func = get_clapack_zgelsd();
+            break;
+    }
+    ENSURE_VALID_FUNC(raw_func)
+
+    _m = (F_INT) m;
+    _n = (F_INT) n;
+    _nrhs = (F_INT) nrhs;
+    _lda = (F_INT) lda;
+    _ldb = (F_INT) ldb;
+    _lwork = (F_INT) lwork;
+
+    (*(cgelsd_t) raw_func)(&_m, &_n, &_nrhs, a, &_lda, b, &_ldb, S, rcond,
+                           &_rank, work, &_lwork, rwork, iwork, info);
+    *rank = (Py_ssize_t) _rank;
+    return 0;
+}
+
+
+/*
+ * Compute the minimum-norm solution to a complex linear least squares problem.
+ * This routine hides the type and general complexity involved with making the
+ * {c,z}gelsd calls. The work space computation and error handling etc is
+ * hidden. Args are as per LAPACK.
+ */
+static int
+numba_ez_cgelsd(char kind, Py_ssize_t m, Py_ssize_t n, Py_ssize_t nrhs,
+                void *a, Py_ssize_t lda, void *b, Py_ssize_t ldb, void *S,
+                double rcond, Py_ssize_t * rank)
+{
+    F_INT info = 0;
+    Py_ssize_t lwork = -1;
+    size_t base_size = -1;
+    all_dtypes stack_slot1, stack_slot2;
+    size_t real_base_size = 0;
+    void *work = NULL, *rwork = NULL, *rcond_cast = NULL;
+    Py_ssize_t lrwork;
+    F_INT *iwork = NULL;
+    F_INT iwork_tmp;
+    char real_kind = '-';
+    float tmpf;
+
+    ENSURE_VALID_COMPLEX_KIND(kind)
+
+    base_size = kind_size(kind);
+
+    work = &stack_slot1;
+    rwork = &stack_slot2;
+    rcond_cast = work; /* stop checks on null ptr complaining */
+
+    /* Compute optimal work size */
+    numba_raw_cgelsd(kind, m, n, nrhs, a, lda, b, ldb, S, rcond_cast, rank,
+                     work, lwork, rwork, &iwork_tmp, &info);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_cgelsd", info);
+
+    /* Allocate work array */
+    lwork = cast_from_X(kind, work);
+    if (checked_PyMem_RawMalloc(&work, base_size * lwork))
+        return STATUS_ERROR;
+
+    /* Allocate iwork array */
+    if (checked_PyMem_RawMalloc((void **)&iwork, sizeof(F_INT) * iwork_tmp))
+    {
+        PyMem_RawFree(work);
+        return STATUS_ERROR;
+    }
+
+    switch (kind)
+    {
+        case 'c':
+            real_kind = 's';
+            tmpf = (float)rcond;
+            rcond_cast = (void * )&tmpf;
+            break;
+        case 'z':
+            real_kind = 'd';
+            rcond_cast = (void * )&rcond;
+            break;
+    }
+
+    real_base_size = kind_size(real_kind);
+
+    lrwork = cast_from_X(real_kind, rwork);
+    if (checked_PyMem_RawMalloc((void **)&rwork, real_base_size * lrwork))
+    {
+        PyMem_RawFree(work);
+        PyMem_RawFree(iwork);
+        return STATUS_ERROR;
+    }
+
+    numba_raw_cgelsd(kind, m, n, nrhs, a, lda, b, ldb, S, rcond_cast, rank,
+                     work, lwork, rwork, iwork, &info);
+    PyMem_RawFree(work);
+    PyMem_RawFree(rwork);
+    PyMem_RawFree(iwork);
+    CATCH_LAPACK_INVALID_ARG("numba_raw_cgelsd", info);
+
+    return (int)info;
+}
+
+
+/*
+ * Compute the minimum-norm solution to a linear least squares problems.
+ * This routine hides the type and general complexity involved with making the
+ * calls to *gelsd. The work space computation and error handling etc is hidden.
+ * Args are as per LAPACK.
+ */
+NUMBA_EXPORT_FUNC(int)
+numba_ez_gelsd(char kind, Py_ssize_t m, Py_ssize_t n, Py_ssize_t nrhs,
+               void *a, Py_ssize_t lda, void *b, Py_ssize_t ldb, void *S,
+               double rcond, Py_ssize_t * rank)
+{
+    ENSURE_VALID_KIND(kind)
+
+    switch (kind)
+    {
+        case 's':
+        case 'd':
+            return numba_ez_rgelsd(kind, m, n, nrhs, a, lda, b, ldb, S, rcond,
+                                   rank);
+        case 'c':
+        case 'z':
+            return numba_ez_cgelsd(kind, m, n, nrhs, a, lda, b, ldb, S, rcond,
+                                   rank);
+    }
+    return STATUS_ERROR; /* unreachable */
+}
+
+
+/*
+ * Compute the solution to a system of linear equations
+ */
+NUMBA_EXPORT_FUNC(int)
+numba_xgesv(char kind, Py_ssize_t n, Py_ssize_t nrhs, void *a, Py_ssize_t lda,
+            F_INT *ipiv, void *b, Py_ssize_t ldb)
+{
+    void *raw_func = NULL;
+    F_INT _n, _nrhs, _lda, _ldb, info;
+
+    ENSURE_VALID_KIND(kind)
+
+    switch (kind)
+    {
+        case 's':
+            raw_func = get_clapack_sgesv();
+            break;
+        case 'd':
+            raw_func = get_clapack_dgesv();
+            break;
+        case 'c':
+            raw_func = get_clapack_cgesv();
+            break;
+        case 'z':
+            raw_func = get_clapack_zgesv();
+            break;
+    }
+
+    ENSURE_VALID_FUNC(raw_func)
+
+    _n = (F_INT) n;
+    _nrhs = (F_INT) nrhs;
+    _lda = (F_INT) lda;
+    _ldb = (F_INT) ldb;
+
+    (*(xgesv_t) raw_func)(&_n, &_nrhs, a, &_lda, ipiv, b, &_ldb, &info);
+    CATCH_LAPACK_INVALID_ARG("xgesv", info);
+
+    return (int)info;
+}
+
+/* undef defines and macros */
+#undef STATUS_SUCCESS
+#undef STATUS_ERROR
+#undef ENSURE_VALID_KIND
+#undef ENSURE_VALID_REAL_KIND
+#undef ENSURE_VALID_COMPLEX_KIND
+#undef ENSURE_VALID_FUNC
+#undef F_INT
+#undef EMIT_GET_CLAPACK_FUNC
+#undef CATCH_LAPACK_INVALID_ARG

lib/python3.10/site-packages/numba/_numba_common.h

@@ -0,0 +1,43 @@
+#ifndef NUMBA_COMMON_H_
+#define NUMBA_COMMON_H_
+
+/* __has_attribute() is a clang / gcc-5 macro */
+#ifndef __has_attribute
+#   define __has_attribute(x) 0
+#endif
+
+/* This attribute marks symbols that can be shared across C objects
+ * but are not exposed outside of a shared library or executable.
+ * Note this is default behaviour for global symbols under Windows.
+ */
+#if defined(_MSC_VER)
+    #define VISIBILITY_HIDDEN
+    #define VISIBILITY_GLOBAL __declspec(dllexport)
+#elif (__has_attribute(visibility) || (defined(__GNUC__) && __GNUC__ >= 4))
+    #define VISIBILITY_HIDDEN __attribute__ ((visibility("hidden")))
+    #define VISIBILITY_GLOBAL __attribute__ ((visibility("default")))
+#else
+    #define VISIBILITY_HIDDEN
+    #define VISIBILITY_GLOBAL
+#endif
+
+/*
+ * Numba's version of the PyArray_DescrCheck macro from NumPy, use it as a
+ * direct replacement of NumPy's PyArray_DescrCheck to ensure binary
+ * compatibility.
+ *
+ * Details of why this is needed:
+ * NumPy 1.18 changed the definition of the PyArray_DescrCheck macro here:
+ * https://github.com/numpy/numpy/commit/6108b5d1e138d07e3c9f2a4e3b1933749ad0e698
+ * the result of this being that building against NumPy <1.18 would prevent
+ * Numba running against NumPy >= 1.20 as noted here:
+ * https://github.com/numba/numba/issues/6041#issuecomment-665132199
+ *
+ * This macro definition is copied from:
+ * https://github.com/numpy/numpy/commit/6108b5d1e138d07e3c9f2a4e3b1933749ad0e698#diff-ad2213da23136c5fc5883d9eb2d88666R26
+ *
+ * NOTE: This is the NumPy 1.18 and above version of the macro.
+ */
+#define NUMBA_PyArray_DescrCheck(op) PyObject_TypeCheck(op, &PyArrayDescr_Type)
+
+#endif /* NUMBA_COMMON_H_ */

lib/python3.10/site-packages/numba/_pymodule.h

@@ -0,0 +1,35 @@
+#ifndef NUMBA_PY_MODULE_H_
+#define NUMBA_PY_MODULE_H_
+
+#define PY_SSIZE_T_CLEAN
+
+#include "Python.h"
+#include "structmember.h"
+#include "frameobject.h"
+
+#define MOD_ERROR_VAL NULL
+#define MOD_SUCCESS_VAL(val) val
+#define MOD_INIT(name) PyMODINIT_FUNC PyInit_##name(void)
+#define MOD_DEF(ob, name, doc, methods) { \
+        static struct PyModuleDef moduledef = { \
+          PyModuleDef_HEAD_INIT, name, doc, -1, methods, NULL, NULL, NULL, NULL }; \
+        ob = PyModule_Create(&moduledef); }
+#define MOD_INIT_EXEC(name) PyInit_##name();
+
+#define PyString_AsString PyUnicode_AsUTF8
+#define PyString_Check PyUnicode_Check
+#define PyString_FromFormat PyUnicode_FromFormat
+#define PyString_FromString PyUnicode_FromString
+#define PyString_InternFromString PyUnicode_InternFromString
+#define PyInt_Type PyLong_Type
+#define PyInt_Check PyLong_Check
+#define PyInt_CheckExact PyLong_CheckExact
+#define SetAttrStringFromVoidPointer(m, name) do { \
+        PyObject *tmp = PyLong_FromVoidPtr((void *) &name); \
+        PyObject_SetAttrString(m, #name, tmp); \
+        Py_DECREF(tmp); } while (0)
+
+
+#define NB_SUPPORTED_PYTHON_MINOR ((PY_MINOR_VERSION == 10) || (PY_MINOR_VERSION == 11) || (PY_MINOR_VERSION == 12) || (PY_MINOR_VERSION == 13))
+
+#endif /* NUMBA_PY_MODULE_H_ */

lib/python3.10/site-packages/numba/_random.c

@@ -0,0 +1,492 @@
+/*
+ * PRNG support.
+ */
+
+#ifdef _MSC_VER
+#define HAVE_PTHREAD_ATFORK 0
+#else
+#define HAVE_PTHREAD_ATFORK 1
+#include <pthread.h>
+#endif
+
+
+/* Magic Mersenne Twister constants */
+#define MT_N 624
+#define MT_M 397
+#define MT_MATRIX_A 0x9908b0dfU
+#define MT_UPPER_MASK 0x80000000U
+#define MT_LOWER_MASK 0x7fffffffU
+
+/*
+ * Note this structure is accessed in numba.targets.randomimpl,
+ * any changes here should be reflected there too.
+ */
+typedef struct {
+    int index;
+    /* unsigned int is sufficient on modern machines as we only need 32 bits */
+    unsigned int mt[MT_N];
+    int has_gauss;
+    double gauss;
+    int is_initialized;
+} rnd_state_t;
+
+/* Some code portions below from CPython's _randommodule.c, some others
+   from Numpy's and Jean-Sebastien Roy's randomkit.c. */
+
+NUMBA_EXPORT_FUNC(void)
+numba_rnd_shuffle(rnd_state_t *state)
+{
+    int i;
+    unsigned int y;
+
+    for (i = 0; i < MT_N - MT_M; i++) {
+        y = (state->mt[i] & MT_UPPER_MASK) | (state->mt[i+1] & MT_LOWER_MASK);
+        state->mt[i] = state->mt[i+MT_M] ^ (y >> 1) ^
+                       (-(int) (y & 1) & MT_MATRIX_A);
+    }
+    for (; i < MT_N - 1; i++) {
+        y = (state->mt[i] & MT_UPPER_MASK) | (state->mt[i+1] & MT_LOWER_MASK);
+        state->mt[i] = state->mt[i+(MT_M-MT_N)] ^ (y >> 1) ^
+                       (-(int) (y & 1) & MT_MATRIX_A);
+    }
+    y = (state->mt[MT_N - 1] & MT_UPPER_MASK) | (state->mt[0] & MT_LOWER_MASK);
+    state->mt[MT_N - 1] = state->mt[MT_M - 1] ^ (y >> 1) ^
+                          (-(int) (y & 1) & MT_MATRIX_A);
+}
+
+/* Initialize mt[] with an integer seed */
+NUMBA_EXPORT_FUNC(void)
+numba_rnd_init(rnd_state_t *state, unsigned int seed)
+{
+    unsigned int pos;
+    seed &= 0xffffffffU;
+
+    /* Knuth's PRNG as used in the Mersenne Twister reference implementation */
+    for (pos = 0; pos < MT_N; pos++) {
+        state->mt[pos] = seed;
+        seed = (1812433253U * (seed ^ (seed >> 30)) + pos + 1) & 0xffffffffU;
+    }
+    state->index = MT_N;
+    state->has_gauss = 0;
+    state->gauss = 0.0;
+    state->is_initialized = 1;
+}
+
+/* Perturb mt[] with a key array */
+static void
+rnd_init_by_array(rnd_state_t *state, unsigned int init_key[], size_t key_length)
+{
+    size_t i, j, k;
+    unsigned int *mt = state->mt;
+
+    numba_rnd_init(state, 19650218U);
+    i = 1; j = 0;
+    k = (MT_N > key_length ? MT_N : key_length);
+    for (; k; k--) {
+        mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1664525U))
+                 + init_key[j] + (unsigned int) j; /* non linear */
+        mt[i] &= 0xffffffffU;
+        i++; j++;
+        if (i >= MT_N) { mt[0] = mt[MT_N - 1]; i = 1; }
+        if (j >= key_length) j = 0;
+    }
+    for (k = MT_N - 1; k; k--) {
+        mt[i] = (mt[i] ^ ((mt[i-1] ^ (mt[i-1] >> 30)) * 1566083941U))
+                 - (unsigned int) i; /* non linear */
+        mt[i] &= 0xffffffffU;
+        i++;
+        if (i >= MT_N) { mt[0] = mt[MT_N - 1]; i=1; }
+    }
+
+    mt[0] = 0x80000000U; /* MSB is 1; ensuring non-zero initial array */
+    state->index = MT_N;
+    state->has_gauss = 0;
+    state->gauss = 0.0;
+    state->is_initialized = 1;
+}
+
+/*
+ * Management of thread-local random state.
+ */
+
+static int rnd_globally_initialized;
+
+#ifdef _MSC_VER
+#define THREAD_LOCAL(ty) __declspec(thread) ty
+#else
+/* Non-standard C99 extension that's understood by gcc and clang */
+#define THREAD_LOCAL(ty) __thread ty
+#endif
+
+static THREAD_LOCAL(rnd_state_t) numba_py_random_state;
+static THREAD_LOCAL(rnd_state_t) numba_np_random_state;
+static THREAD_LOCAL(rnd_state_t) numba_internal_random_state;
+
+/* Seed the state with random bytes */
+static int
+rnd_seed_with_bytes(rnd_state_t *state, Py_buffer *buf)
+{
+    unsigned int *keys;
+    unsigned char *bytes;
+    size_t i, nkeys;
+
+    nkeys = buf->len / sizeof(unsigned int);
+    keys = (unsigned int *) PyMem_Malloc(nkeys * sizeof(unsigned int));
+    if (keys == NULL) {
+        PyBuffer_Release(buf);
+        return -1;
+    }
+    bytes = (unsigned char *) buf->buf;
+    /* Convert input bytes to int32 keys, without violating alignment
+     * constraints.
+     */
+    for (i = 0; i < nkeys; i++, bytes += 4) {
+        keys[i] =
+            ((unsigned int)bytes[3] << 24) +
+            ((unsigned int)bytes[2] << 16) +
+            ((unsigned int)bytes[1] << 8) +
+            ((unsigned int)bytes[0] << 0);
+    }
+    PyBuffer_Release(buf);
+    rnd_init_by_array(state, keys, nkeys);
+    PyMem_Free(keys);
+    return 0;
+}
+
+#if HAVE_PTHREAD_ATFORK
+/* After a fork(), the child should reseed its random states.
+ * Since only the main thread survives in the child, it's enough to mark
+ * the current thread-local states as uninitialized.
+ */
+static void
+rnd_atfork_child(void)
+{
+    numba_py_random_state.is_initialized = 0;
+    numba_np_random_state.is_initialized = 0;
+    numba_internal_random_state.is_initialized = 0;
+}
+#endif
+
+/* Global initialization routine.  It must be called as early as possible.
+ */
+NUMBA_EXPORT_FUNC(void)
+numba_rnd_ensure_global_init(void)
+{
+    if (!rnd_globally_initialized) {
+#if HAVE_PTHREAD_ATFORK
+        pthread_atfork(NULL, NULL, rnd_atfork_child);
+#endif
+        numba_py_random_state.is_initialized = 0;
+        numba_np_random_state.is_initialized = 0;
+        numba_internal_random_state.is_initialized = 0;
+        rnd_globally_initialized = 1;
+    }
+}
+
+/* First-time init a random state */
+static void
+rnd_implicit_init(rnd_state_t *state)
+{
+    /* Initialize with random bytes.  The easiest way to get good-quality
+     * cross-platform random bytes is still to call os.urandom()
+     * using the Python interpreter...
+     */
+    PyObject *module, *bufobj;
+    Py_buffer buf;
+    PyGILState_STATE gilstate = PyGILState_Ensure();
+
+    module = PyImport_ImportModule("os");
+    if (module == NULL)
+        goto error;
+    /* Read as many bytes as necessary to get the full entropy
+     * exploitable by the MT generator.
+     */
+    bufobj = PyObject_CallMethod(module, "urandom", "i",
+                                 (int) (MT_N * sizeof(unsigned int)));
+    Py_DECREF(module);
+    if (bufobj == NULL)
+        goto error;
+    if (PyObject_GetBuffer(bufobj, &buf, PyBUF_SIMPLE))
+        goto error;
+    Py_DECREF(bufobj);
+    if (rnd_seed_with_bytes(state, &buf))
+        goto error;
+    /* state->is_initialized is set now */
+
+    PyGILState_Release(gilstate);
+    return;
+
+error:
+    /* In normal conditions, os.urandom() and PyMem_Malloc() shouldn't fail,
+     * and we don't want the caller to deal with errors, so just bail out.
+     */
+    if (PyErr_Occurred())
+        PyErr_Print();
+    Py_FatalError(NULL);
+}
+
+/* Functions returning the thread-local random state pointer.
+ * The LLVM JIT doesn't support thread-local variables so we rely
+ * on the C compiler instead.
+ */
+
+NUMBA_EXPORT_FUNC(rnd_state_t *)
+numba_get_py_random_state(void)
+{
+    rnd_state_t *state = &numba_py_random_state;
+    if (!state->is_initialized)
+        rnd_implicit_init(state);
+    return state;
+}
+
+NUMBA_EXPORT_FUNC(rnd_state_t *)
+numba_get_np_random_state(void)
+{
+    rnd_state_t *state = &numba_np_random_state;
+    if (!state->is_initialized)
+        rnd_implicit_init(state);
+    return state;
+}
+
+NUMBA_EXPORT_FUNC(rnd_state_t *)
+numba_get_internal_random_state(void)
+{
+    rnd_state_t *state = &numba_internal_random_state;
+    if (!state->is_initialized)
+        rnd_implicit_init(state);
+    return state;
+}
+
+/*
+ * Python-exposed helpers for state management and testing.
+ */
+static int
+rnd_state_converter(PyObject *obj, rnd_state_t **state)
+{
+    *state = (rnd_state_t *) PyLong_AsVoidPtr(obj);
+    return (*state != NULL || !PyErr_Occurred());
+}
+
+NUMBA_EXPORT_FUNC(PyObject *)
+_numba_rnd_get_py_state_ptr(PyObject *self)
+{
+    return PyLong_FromVoidPtr(numba_get_py_random_state());
+}
+
+NUMBA_EXPORT_FUNC(PyObject *)
+_numba_rnd_get_np_state_ptr(PyObject *self)
+{
+    return PyLong_FromVoidPtr(numba_get_np_random_state());
+}
+
+NUMBA_EXPORT_FUNC(PyObject *)
+_numba_rnd_shuffle(PyObject *self, PyObject *arg)
+{
+    rnd_state_t *state;
+    if (!rnd_state_converter(arg, &state))
+        return NULL;
+    numba_rnd_shuffle(state);
+    Py_RETURN_NONE;
+}
+
+NUMBA_EXPORT_FUNC(PyObject *)
+_numba_rnd_set_state(PyObject *self, PyObject *args)
+{
+    int i, index;
+    rnd_state_t *state;
+    PyObject *tuplearg, *intlist;
+
+    if (!PyArg_ParseTuple(args, "O&O!:rnd_set_state",
+                          rnd_state_converter, &state,
+                          &PyTuple_Type, &tuplearg))
+        return NULL;
+    if (!PyArg_ParseTuple(tuplearg, "iO!", &index, &PyList_Type, &intlist))
+        return NULL;
+    if (PyList_GET_SIZE(intlist) != MT_N) {
+        PyErr_SetString(PyExc_ValueError, "list object has wrong size");
+        return NULL;
+    }
+    state->index = index;
+    for (i = 0; i < MT_N; i++) {
+        PyObject *v = PyList_GET_ITEM(intlist, i);
+        unsigned long x = PyLong_AsUnsignedLong(v);
+        if (x == (unsigned long) -1 && PyErr_Occurred())
+            return NULL;
+        state->mt[i] = (unsigned int) x;
+    }
+    state->has_gauss = 0;
+    state->gauss = 0.0;
+    state->is_initialized = 1;
+    Py_RETURN_NONE;
+}
+
+NUMBA_EXPORT_FUNC(PyObject *)
+_numba_rnd_get_state(PyObject *self, PyObject *arg)
+{
+    PyObject *intlist;
+    int i;
+    rnd_state_t *state;
+    if (!rnd_state_converter(arg, &state))
+        return NULL;
+
+    intlist = PyList_New(MT_N);
+    if (intlist == NULL)
+        return NULL;
+    for (i = 0; i < MT_N; i++) {
+        PyObject *v = PyLong_FromUnsignedLong(state->mt[i]);
+        if (v == NULL) {
+            Py_DECREF(intlist);
+            return NULL;
+        }
+        PyList_SET_ITEM(intlist, i, v);
+    }
+    return Py_BuildValue("iN", state->index, intlist);
+}
+
+NUMBA_EXPORT_FUNC(PyObject *)
+_numba_rnd_seed(PyObject *self, PyObject *args)
+{
+    unsigned int seed;
+    rnd_state_t *state;
+
+    if (!PyArg_ParseTuple(args, "O&I:rnd_seed",
+                          rnd_state_converter, &state, &seed)) {
+        /* rnd_seed_*(bytes-like object) */
+        Py_buffer buf;
+
+        PyErr_Clear();
+        if (!PyArg_ParseTuple(args, "O&s*:rnd_seed",
+                              rnd_state_converter, &state, &buf))
+            return NULL;
+
+        if (rnd_seed_with_bytes(state, &buf))
+            return NULL;
+        else
+            Py_RETURN_NONE;
+    }
+    else {
+        /* rnd_seed_*(int32) */
+        numba_rnd_init(state, seed);
+        Py_RETURN_NONE;
+    }
+}
+
+/*
+ * Random distribution helpers.
+ * Most code straight from Numpy's distributions.c.
+ */
+
+#ifndef M_PI
+#define M_PI 3.14159265358979323846264338328
+#endif
+
+NUMBA_EXPORT_FUNC(unsigned int)
+get_next_int32(rnd_state_t *state)
+{
+    unsigned int y;
+
+    if (state->index == MT_N) {
+        numba_rnd_shuffle(state);
+        state->index = 0;
+    }
+    y = state->mt[state->index++];
+    /* Tempering */
+    y ^= (y >> 11);
+    y ^= (y << 7) & 0x9d2c5680U;
+    y ^= (y << 15) & 0xefc60000U;
+    y ^= (y >> 18);
+    return y;
+}
+
+NUMBA_EXPORT_FUNC(double)
+get_next_double(rnd_state_t *state)
+{
+    double a = get_next_int32(state) >> 5;
+    double b = get_next_int32(state) >> 6;
+    return (a * 67108864.0 + b) / 9007199254740992.0;
+}
+
+NUMBA_EXPORT_FUNC(double)
+loggam(double x)
+{
+    double x0, x2, xp, gl, gl0;
+    long k, n;
+
+    static double a[10] = {8.333333333333333e-02,-2.777777777777778e-03,
+         7.936507936507937e-04,-5.952380952380952e-04,
+         8.417508417508418e-04,-1.917526917526918e-03,
+         6.410256410256410e-03,-2.955065359477124e-02,
+         1.796443723688307e-01,-1.39243221690590e+00};
+    x0 = x;
+    n = 0;
+    if ((x == 1.0) || (x == 2.0))
+    {
+        return 0.0;
+    }
+    else if (x <= 7.0)
+    {
+        n = (long)(7 - x);
+        x0 = x + n;
+    }
+    x2 = 1.0/(x0*x0);
+    xp = 2*M_PI;
+    gl0 = a[9];
+    for (k=8; k>=0; k--)
+    {
+        gl0 *= x2;
+        gl0 += a[k];
+    }
+    gl = gl0/x0 + 0.5*log(xp) + (x0-0.5)*log(x0) - x0;
+    if (x <= 7.0)
+    {
+        for (k=1; k<=n; k++)
+        {
+            gl -= log(x0-1.0);
+            x0 -= 1.0;
+        }
+    }
+    return gl;
+}
+
+
+NUMBA_EXPORT_FUNC(int64_t)
+numba_poisson_ptrs(rnd_state_t *state, double lam)
+{
+    /* This method is invoked only if the parameter lambda of this
+     * distribution is big enough ( >= 10 ). The algorithm used is
+     * described in "Hörmann, W. 1992. 'The Transformed Rejection
+     * Method for Generating Poisson Random Variables'.
+     * The implementation comes straight from Numpy.
+     */
+    int64_t k;
+    double U, V, slam, loglam, a, b, invalpha, vr, us;
+
+    slam = sqrt(lam);
+    loglam = log(lam);
+    b = 0.931 + 2.53*slam;
+    a = -0.059 + 0.02483*b;
+    invalpha = 1.1239 + 1.1328/(b-3.4);
+    vr = 0.9277 - 3.6224/(b-2);
+
+    while (1)
+    {
+        U = get_next_double(state) - 0.5;
+        V = get_next_double(state);
+        us = 0.5 - fabs(U);
+        k = (int64_t) floor((2*a/us + b)*U + lam + 0.43);
+        if ((us >= 0.07) && (V <= vr))
+        {
+            return k;
+        }
+        if ((k < 0) ||
+            ((us < 0.013) && (V > us)))
+        {
+            continue;
+        }
+        if ((log(V) + log(invalpha) - log(a/(us*us)+b)) <=
+            (-lam + (double) k*loglam - loggam((double) k+1)))
+        {
+            return k;
+        }
+    }
+}

lib/python3.10/site-packages/numba/_typeof.h

@@ -0,0 +1,16 @@
+#ifndef NUMBA_TYPEOF_H_
+#define NUMBA_TYPEOF_H_
+
+#ifdef __cplusplus
+    extern "C" {
+#endif
+
+extern PyObject *typeof_init(PyObject *self, PyObject *args);
+extern int typeof_typecode(PyObject *dispatcher, PyObject *val);
+extern PyObject *typeof_compute_fingerprint(PyObject *val);
+
+#ifdef __cplusplus
+    }
+#endif
+
+#endif  /* NUMBA_TYPEOF_H_ */