Add files using upload-large-folder tool

venv/lib/python3.10/site-packages/numba/misc/gdb_print_extension.py

@@ -0,0 +1,204 @@
+"""gdb printing extension for Numba types.
+"""
+import re
+
+try:
+    import gdb.printing
+    import gdb
+except ImportError:
+    raise ImportError("GDB python support is not available.")
+
+
+class NumbaArrayPrinter:
+
+    def __init__(self, val):
+        self.val = val
+
+    def to_string(self):
+        try:
+            import numpy as np
+            HAVE_NUMPY = True
+        except ImportError:
+            HAVE_NUMPY = False
+
+        try:
+            NULL = 0x0
+
+            # Raw data references, these need unpacking/interpreting.
+
+            # Member "data" is...
+            # DW_TAG_member of DIDerivedType, tag of DW_TAG_pointer_type
+            # encoding e.g. DW_ATE_float
+            data = self.val["data"]
+
+            # Member "itemsize" is...
+            # DW_TAG_member of DIBasicType encoding DW_ATE_signed
+            itemsize = self.val["itemsize"]
+
+            # Members "shape" and "strides" are...
+            # DW_TAG_member of DIDerivedType, the type is a DICompositeType
+            # (it's a Numba UniTuple) with tag: DW_TAG_array_type, i.e. it's an
+            # array repr, it has a basetype of e.g. DW_ATE_unsigned and also
+            # "elements" which are referenced with a DISubrange(count: <const>)
+            # to say how many elements are in the array.
+            rshp = self.val["shape"]
+            rstrides = self.val["strides"]
+
+            # bool on whether the data is aligned.
+            is_aligned = False
+
+            # type information decode, simple type:
+            ty_str = str(self.val.type)
+            if HAVE_NUMPY and ('aligned' in ty_str or 'Record' in ty_str):
+                ty_str = ty_str.replace('unaligned ','').strip()
+                matcher = re.compile(r"array\((Record.*), (.*), (.*)\)\ \(.*")
+                # NOTE: need to deal with "Alignment" else dtype size is wrong
+                arr_info = [x.strip() for x in matcher.match(ty_str).groups()]
+                dtype_str, ndim_str, order_str = arr_info
+                rstr = r'Record\((.*\[.*\]);([0-9]+);(True|False)'
+                rstr_match = re.match(rstr, dtype_str)
+                # balign is unused, it's the alignment
+                fields, balign, is_aligned_str = rstr_match.groups()
+                is_aligned = is_aligned_str == 'True'
+                field_dts = fields.split(',')
+                struct_entries = []
+                for f in field_dts:
+                    splitted = f.split('[')
+                    name = splitted[0]
+                    dt_part = splitted[1:]
+                    if len(dt_part) > 1:
+                        raise TypeError('Unsupported sub-type: %s' % f)
+                    else:
+                        dt_part = dt_part[0]
+                        if "nestedarray" in dt_part:
+                            raise TypeError('Unsupported sub-type: %s' % f)
+                        dt_as_str = dt_part.split(';')[0].split('=')[1]
+                        dtype = np.dtype(dt_as_str)
+                    struct_entries.append((name, dtype))
+                    # The dtype is actually a record of some sort
+                dtype_str = struct_entries
+            else:  # simple type
+                matcher = re.compile(r"array\((.*),(.*),(.*)\)\ \(.*")
+                arr_info = [x.strip() for x in matcher.match(ty_str).groups()]
+                dtype_str, ndim_str, order_str = arr_info
+                # fix up unichr dtype
+                if 'unichr x ' in dtype_str:
+                    dtype_str = dtype_str[1:-1].replace('unichr x ', '<U')
+
+            def dwarr2inttuple(dwarr):
+                # Converts a gdb handle to a dwarf array to a tuple of ints
+                fields = dwarr.type.fields()
+                lo, hi = fields[0].type.range()
+                return tuple([int(dwarr[x]) for x in range(lo, hi + 1)])
+
+            # shape/strides extraction
+            shape = dwarr2inttuple(rshp)
+            strides = dwarr2inttuple(rstrides)
+
+            # if data is not NULL
+            if data != NULL:
+                if HAVE_NUMPY:
+                    # The data extent in bytes is:
+                    # sum(shape * strides)
+                    # get the data, then wire to as_strided
+                    shp_arr = np.array([max(0, x - 1) for x in shape])
+                    strd_arr = np.array(strides)
+                    extent = np.sum(shp_arr * strd_arr)
+                    extent += int(itemsize)
+                    dtype_clazz = np.dtype(dtype_str, align=is_aligned)
+                    dtype = dtype_clazz
+                    this_proc = gdb.selected_inferior()
+                    mem = this_proc.read_memory(int(data), extent)
+                    arr_data = np.frombuffer(mem, dtype=dtype)
+                    new_arr = np.lib.stride_tricks.as_strided(arr_data,
+                                                              shape=shape,
+                                                              strides=strides,)
+                    return '\n' + str(new_arr)
+                # Catch all for no NumPy
+                return "array([...], dtype=%s, shape=%s)" % (dtype_str, shape)
+            else:
+                # Not yet initialized or NULLed out data
+                buf = list(["NULL/Uninitialized"])
+                return "array([" + ', '.join(buf) + "]" + ")"
+        except Exception as e:
+            return 'array[Exception: Failed to parse. %s]' % e
+
+
+class NumbaComplexPrinter:
+
+    def __init__(self, val):
+        self.val = val
+
+    def to_string(self):
+        return "%s+%sj" % (self.val['real'], self.val['imag'])
+
+
+class NumbaTuplePrinter:
+
+    def __init__(self, val):
+        self.val = val
+
+    def to_string(self):
+        buf = []
+        fields = self.val.type.fields()
+        for f in fields:
+            buf.append(str(self.val[f.name]))
+        return "(%s)" % ', '.join(buf)
+
+
+class NumbaUniTuplePrinter:
+
+    def __init__(self, val):
+        self.val = val
+
+    def to_string(self):
+        # unituples are arrays
+        fields = self.val.type.fields()
+        lo, hi = fields[0].type.range()
+        buf = []
+        for i in range(lo, hi + 1):
+            buf.append(str(self.val[i]))
+        return "(%s)" % ', '.join(buf)
+
+
+class NumbaUnicodeTypePrinter:
+
+    def __init__(self, val):
+        self.val = val
+
+    def to_string(self):
+        NULL = 0x0
+        data = self.val["data"]
+        nitems = self.val["length"]
+        kind = self.val["kind"]
+        if data != NULL:
+            # This needs sorting out, encoding is wrong
+            this_proc = gdb.selected_inferior()
+            mem = this_proc.read_memory(int(data), nitems * kind)
+            if isinstance(mem, memoryview):
+                buf = bytes(mem).decode()
+            else:
+                buf = mem.decode('utf-8')
+        else:
+            buf = str(data)
+        return "'%s'" % buf
+
+
+def _create_printers():
+    printer = gdb.printing.RegexpCollectionPrettyPrinter("Numba")
+    printer.add_printer('Numba unaligned array printer', '^unaligned array\\(',
+                        NumbaArrayPrinter)
+    printer.add_printer('Numba array printer', '^array\\(', NumbaArrayPrinter)
+    printer.add_printer('Numba complex printer', '^complex[0-9]+\\ ',
+                        NumbaComplexPrinter)
+    printer.add_printer('Numba Tuple printer', '^Tuple\\(',
+                        NumbaTuplePrinter)
+    printer.add_printer('Numba UniTuple printer', '^UniTuple\\(',
+                        NumbaUniTuplePrinter)
+    printer.add_printer('Numba unicode_type printer', '^unicode_type\\s+\\(',
+                        NumbaUnicodeTypePrinter)
+    return printer
+
+
+# register the Numba pretty printers for the current object
+gdb.printing.register_pretty_printer(gdb.current_objfile(), _create_printers())

venv/lib/python3.10/site-packages/numba/misc/help/inspector.py

@@ -0,0 +1,433 @@
+"""
+This file contains `__main__` so that it can be run as a commandline tool.
+
+This file contains functions to inspect Numba's support for a given Python
+module or a Python package.
+"""
+
+import argparse
+import pkgutil
+import warnings
+import types as pytypes
+
+from numba.core import errors
+from numba._version import get_versions
+from numba.core.registry import cpu_target
+from numba.tests.support import captured_stdout
+
+
+def _get_commit():
+    full = get_versions()['full-revisionid']
+    if not full:
+        warnings.warn(
+            "Cannot find git commit hash. Source links could be inaccurate.",
+            category=errors.NumbaWarning,
+        )
+        return 'main'
+    return full
+
+
+commit = _get_commit()
+github_url = 'https://github.com/numba/numba/blob/{commit}/{path}#L{firstline}-L{lastline}'    # noqa: E501
+
+
+def inspect_function(function, target=None):
+    """Return information about the support of a function.
+
+    Returns
+    -------
+    info : dict
+        Defined keys:
+        - "numba_type": str or None
+            The numba type object of the function if supported.
+        - "explained": str
+            A textual description of the support.
+        - "source_infos": dict
+            A dictionary containing the source location of each definition.
+    """
+    target = target or cpu_target
+    tyct = target.typing_context
+    # Make sure we have loaded all extensions
+    tyct.refresh()
+    target.target_context.refresh()
+
+    info = {}
+    # Try getting the function type
+    source_infos = {}
+    try:
+        nbty = tyct.resolve_value_type(function)
+    except ValueError:
+        nbty = None
+        explained = 'not supported'
+    else:
+        # Make a longer explanation of the type
+        explained = tyct.explain_function_type(nbty)
+        for temp in nbty.templates:
+            try:
+                source_infos[temp] = temp.get_source_info()
+            except AttributeError:
+                source_infos[temp] = None
+
+    info['numba_type'] = nbty
+    info['explained'] = explained
+    info['source_infos'] = source_infos
+    return info
+
+
+def inspect_module(module, target=None, alias=None):
+    """Inspect a module object and yielding results from `inspect_function()`
+    for each function object in the module.
+    """
+    alias = {} if alias is None else alias
+    # Walk the module
+    for name in dir(module):
+        if name.startswith('_'):
+            # Skip
+            continue
+        obj = getattr(module, name)
+        supported_types = (pytypes.FunctionType, pytypes.BuiltinFunctionType)
+
+        if not isinstance(obj, supported_types):
+            # Skip if it's not a function
+            continue
+
+        info = dict(module=module, name=name, obj=obj)
+        if obj in alias:
+            info['alias'] = alias[obj]
+        else:
+            alias[obj] = "{module}.{name}".format(module=module.__name__,
+                                                  name=name)
+        info.update(inspect_function(obj, target=target))
+        yield info
+
+
+class _Stat(object):
+    """For gathering simple statistic of (un)supported functions"""
+    def __init__(self):
+        self.supported = 0
+        self.unsupported = 0
+
+    @property
+    def total(self):
+        total = self.supported + self.unsupported
+        return total
+
+    @property
+    def ratio(self):
+        ratio = self.supported / self.total * 100
+        return ratio
+
+    def describe(self):
+        if self.total == 0:
+            return "empty"
+        return "supported = {supported} / {total} = {ratio:.2f}%".format(
+            supported=self.supported,
+            total=self.total,
+            ratio=self.ratio,
+        )
+
+    def __repr__(self):
+        return "{clsname}({describe})".format(
+            clsname=self.__class__.__name__,
+            describe=self.describe(),
+        )
+
+
+def filter_private_module(module_components):
+    return not any(x.startswith('_') for x in module_components)
+
+
+def filter_tests_module(module_components):
+    return not any(x == 'tests' for x in module_components)
+
+
+_default_module_filters = (
+    filter_private_module,
+    filter_tests_module,
+)
+
+
+def list_modules_in_package(package, module_filters=_default_module_filters):
+    """Yield all modules in a given package.
+
+    Recursively walks the package tree.
+    """
+    onerror_ignore = lambda _: None
+
+    prefix = package.__name__ + "."
+    package_walker = pkgutil.walk_packages(
+        package.__path__,
+        prefix,
+        onerror=onerror_ignore,
+    )
+
+    def check_filter(modname):
+        module_components = modname.split('.')
+        return any(not filter_fn(module_components)
+                   for filter_fn in module_filters)
+
+    modname = package.__name__
+    if not check_filter(modname):
+        yield package
+
+    for pkginfo in package_walker:
+        modname = pkginfo[1]
+        if check_filter(modname):
+            continue
+        # In case importing of the module print to stdout
+        with captured_stdout():
+            try:
+                # Import the module
+                mod = __import__(modname)
+            except Exception:
+                continue
+
+            # Extract the module
+            for part in modname.split('.')[1:]:
+                try:
+                    mod = getattr(mod, part)
+                except AttributeError:
+                    # Suppress error in getting the attribute
+                    mod = None
+                    break
+
+        # Ignore if mod is not a module
+        if not isinstance(mod, pytypes.ModuleType):
+            # Skip non-module
+            continue
+
+        yield mod
+
+
+class Formatter(object):
+    """Base class for formatters.
+    """
+    def __init__(self, fileobj):
+        self._fileobj = fileobj
+
+    def print(self, *args, **kwargs):
+        kwargs.setdefault('file', self._fileobj)
+        print(*args, **kwargs)
+
+
+class HTMLFormatter(Formatter):
+    """Formatter that outputs HTML
+    """
+
+    def escape(self, text):
+        import html
+        return html.escape(text)
+
+    def title(self, text):
+        self.print('<h1>', text, '</h2>')
+
+    def begin_module_section(self, modname):
+        self.print('<h2>', modname, '</h2>')
+        self.print('<ul>')
+
+    def end_module_section(self):
+        self.print('</ul>')
+
+    def write_supported_item(self, modname, itemname, typename, explained,
+                             sources, alias):
+        self.print('<li>')
+        self.print('{}.<b>{}</b>'.format(
+            modname,
+            itemname,
+        ))
+        self.print(': <b>{}</b>'.format(typename))
+        self.print('<div><pre>', explained, '</pre></div>')
+
+        self.print("<ul>")
+        for tcls, source in sources.items():
+            if source:
+                self.print("<li>")
+                impl = source['name']
+                sig = source['sig']
+                filename = source['filename']
+                lines = source['lines']
+                self.print(
+                    "<p>defined by <b>{}</b>{} at {}:{}-{}</p>".format(
+                        self.escape(impl), self.escape(sig),
+                        self.escape(filename), lines[0], lines[1],
+                    ),
+                )
+                self.print('<p>{}</p>'.format(
+                    self.escape(source['docstring'] or '')
+                ))
+            else:
+                self.print("<li>{}".format(self.escape(str(tcls))))
+            self.print("</li>")
+        self.print("</ul>")
+        self.print('</li>')
+
+    def write_unsupported_item(self, modname, itemname):
+        self.print('<li>')
+        self.print('{}.<b>{}</b>: UNSUPPORTED'.format(
+            modname,
+            itemname,
+        ))
+        self.print('</li>')
+
+    def write_statistic(self, stats):
+        self.print('<p>{}</p>'.format(stats.describe()))
+
+
+class ReSTFormatter(Formatter):
+    """Formatter that output ReSTructured text format for Sphinx docs.
+    """
+    def escape(self, text):
+        return text
+
+    def title(self, text):
+        self.print(text)
+        self.print('=' * len(text))
+        self.print()
+
+    def begin_module_section(self, modname):
+        self.print(modname)
+        self.print('-' * len(modname))
+        self.print()
+
+    def end_module_section(self):
+        self.print()
+
+    def write_supported_item(self, modname, itemname, typename, explained,
+                             sources, alias):
+        self.print('.. function:: {}.{}'.format(modname, itemname))
+        self.print('   :noindex:')
+        self.print()
+
+        if alias:
+            self.print("   Alias to: ``{}``".format(alias))
+        self.print()
+
+        for tcls, source in sources.items():
+            if source:
+                impl = source['name']
+                sig = source['sig']
+                filename = source['filename']
+                lines = source['lines']
+                source_link = github_url.format(
+                    commit=commit,
+                    path=filename,
+                    firstline=lines[0],
+                    lastline=lines[1],
+                )
+                self.print(
+                    "   - defined by ``{}{}`` at `{}:{}-{} <{}>`_".format(
+                        impl, sig, filename, lines[0], lines[1], source_link,
+                    ),
+                )
+
+            else:
+                self.print("   - defined by ``{}``".format(str(tcls)))
+        self.print()
+
+    def write_unsupported_item(self, modname, itemname):
+        pass
+
+    def write_statistic(self, stat):
+        if stat.supported == 0:
+            self.print("This module is not supported.")
+        else:
+            msg = "Not showing {} unsupported functions."
+            self.print(msg.format(stat.unsupported))
+            self.print()
+            self.print(stat.describe())
+        self.print()
+
+
+def _format_module_infos(formatter, package_name, mod_sequence, target=None):
+    """Format modules.
+    """
+    formatter.title('Listings for {}'.format(package_name))
+    alias_map = {}  # remember object seen to track alias
+    for mod in mod_sequence:
+        stat = _Stat()
+        modname = mod.__name__
+        formatter.begin_module_section(formatter.escape(modname))
+        for info in inspect_module(mod, target=target, alias=alias_map):
+            nbtype = info['numba_type']
+            if nbtype is not None:
+                stat.supported += 1
+                formatter.write_supported_item(
+                    modname=formatter.escape(info['module'].__name__),
+                    itemname=formatter.escape(info['name']),
+                    typename=formatter.escape(str(nbtype)),
+                    explained=formatter.escape(info['explained']),
+                    sources=info['source_infos'],
+                    alias=info.get('alias'),
+                )
+
+            else:
+                stat.unsupported += 1
+                formatter.write_unsupported_item(
+                    modname=formatter.escape(info['module'].__name__),
+                    itemname=formatter.escape(info['name']),
+                )
+
+        formatter.write_statistic(stat)
+        formatter.end_module_section()
+
+
+def write_listings(package_name, filename, output_format):
+    """Write listing information into a file.
+
+    Parameters
+    ----------
+    package_name : str
+        Name of the package to inspect.
+    filename : str
+        Output filename. Always overwrite.
+    output_format : str
+        Support formats are "html" and "rst".
+    """
+    package = __import__(package_name)
+    if hasattr(package, '__path__'):
+        mods = list_modules_in_package(package)
+    else:
+        mods = [package]
+
+    if output_format == 'html':
+        with open(filename + '.html', 'w') as fout:
+            fmtr = HTMLFormatter(fileobj=fout)
+            _format_module_infos(fmtr, package_name, mods)
+    elif output_format == 'rst':
+        with open(filename + '.rst', 'w') as fout:
+            fmtr = ReSTFormatter(fileobj=fout)
+            _format_module_infos(fmtr, package_name, mods)
+    else:
+        raise ValueError(
+            "Output format '{}' is not supported".format(output_format))
+
+
+program_description = """
+Inspect Numba support for a given top-level package.
+""".strip()
+
+
+def main():
+    parser = argparse.ArgumentParser(description=program_description)
+    parser.add_argument(
+        'package', metavar='package', type=str,
+        help='Package to inspect',
+    )
+    parser.add_argument(
+        '--format', dest='format', default='html',
+        help='Output format; i.e. "html", "rst"',
+    )
+    parser.add_argument(
+        '--file', dest='file', default='inspector_output',
+        help='Output filename. Defaults to "inspector_output.<format>"',
+    )
+
+    args = parser.parse_args()
+    package_name = args.package
+    output_format = args.format
+    filename = args.file
+    write_listings(package_name, filename, output_format)
+
+
+if __name__ == '__main__':
+    main()

venv/lib/python3.10/site-packages/numba/misc/init_utils.py

@@ -0,0 +1,44 @@
+"""Collection of miscellaneous initialization utilities."""
+
+from collections import namedtuple
+
+version_info = namedtuple('version_info',
+                          ('major minor patch short full '
+                           'string tuple git_revision'))
+
+
+def generate_version_info(version):
+    """Process a version string into a structured version_info object.
+
+    Parameters
+    ----------
+    version: str
+        a string describing the current version
+
+    Returns
+    -------
+    version_info: tuple
+        structured version information
+
+    See also
+    --------
+    Look at the definition of 'version_info' in this module for details.
+
+    """
+    parts = version.split('.')
+
+    def try_int(x):
+        try:
+            return int(x)
+        except ValueError:
+            return None
+    major = try_int(parts[0]) if len(parts) >= 1 else None
+    minor = try_int(parts[1]) if len(parts) >= 2 else None
+    patch = try_int(parts[2]) if len(parts) >= 3 else None
+    short = (major, minor)
+    full = (major, minor, patch)
+    string = version
+    tup = tuple(parts)
+    git_revision = tup[3] if len(tup) >= 4 else None
+    return version_info(major, minor, patch, short, full, string, tup,
+                        git_revision)

venv/lib/python3.10/site-packages/numba/misc/inspection.py

@@ -0,0 +1,103 @@
+"""Miscellaneous inspection tools
+"""
+from tempfile import NamedTemporaryFile, TemporaryDirectory
+import os
+import warnings
+
+from numba.core.errors import NumbaWarning
+
+
+def disassemble_elf_to_cfg(elf, mangled_symbol):
+    """
+    Gets the CFG of the disassembly of an ELF object, elf, at mangled name,
+    mangled_symbol, and renders it appropriately depending on the execution
+    environment (terminal/notebook).
+    """
+    try:
+        import r2pipe
+    except ImportError:
+        raise RuntimeError("r2pipe package needed for disasm CFG")
+
+    def get_rendering(cmd=None):
+        from numba.pycc.platform import Toolchain # import local, circular ref
+        if cmd is None:
+            raise ValueError("No command given")
+
+        with TemporaryDirectory() as tmpdir:
+            # Write ELF as a temporary file in the temporary dir, do not delete!
+            with NamedTemporaryFile(delete=False, dir=tmpdir) as f:
+                f.write(elf)
+                f.flush()  # force write, radare2 needs a binary blob on disk
+
+            # Now try and link the ELF, this helps radare2 _a lot_
+            linked = False
+            try:
+                raw_dso_name = f'{os.path.basename(f.name)}.so'
+                linked_dso = os.path.join(tmpdir, raw_dso_name)
+                tc = Toolchain()
+                tc.link_shared(linked_dso, (f.name,))
+                obj_to_analyse = linked_dso
+                linked = True
+            except Exception as e:
+                # link failed, mention it to user, radare2 will still be able to
+                # analyse the object, but things like dwarf won't appear in the
+                # asm as comments.
+                msg = ('Linking the ELF object with the distutils toolchain '
+                       f'failed with: {e}. Disassembly will still work but '
+                       'might be less accurate and will not use DWARF '
+                       'information.')
+                warnings.warn(NumbaWarning(msg))
+                obj_to_analyse = f.name
+
+            # catch if r2pipe can actually talk to radare2
+            try:
+                flags = ['-2', # close stderr to hide warnings
+                         '-e io.cache=true', # fix relocations in disassembly
+                         '-e scr.color=1',  # 16 bit ANSI colour terminal
+                         '-e asm.dwarf=true', # DWARF decode
+                         '-e scr.utf8=true', # UTF8 output looks better
+                         ]
+                r = r2pipe.open(obj_to_analyse, flags=flags)
+                r.cmd('aaaaaa') # analyse as much as possible
+                # If the elf is linked then it's necessary to seek as the
+                # DSO ctor/dtor is at the default position
+                if linked:
+                    # r2 only matches up to 61 chars?! found this by experiment!
+                    mangled_symbol_61char = mangled_symbol[:61]
+                    # switch off demangle, the seek is on a mangled symbol
+                    r.cmd('e bin.demangle=false')
+                    # seek to the mangled symbol address
+                    r.cmd(f's `is~ {mangled_symbol_61char}[1]`')
+                    # switch demangling back on for output purposes
+                    r.cmd('e bin.demangle=true')
+                data = r.cmd('%s' % cmd) # print graph
+                r.quit()
+            except Exception as e:
+                if "radare2 in PATH" in str(e):
+                    msg = ("This feature requires 'radare2' to be "
+                           "installed and available on the system see: "
+                           "https://github.com/radareorg/radare2. "
+                           "Cannot find 'radare2' in $PATH.")
+                    raise RuntimeError(msg)
+                else:
+                    raise e
+        return data
+
+    class DisasmCFG(object):
+
+        def _repr_svg_(self):
+            try:
+                import graphviz
+            except ImportError:
+                raise RuntimeError("graphviz package needed for disasm CFG")
+            jupyter_rendering = get_rendering(cmd='agfd')
+            # this just makes it read slightly better in jupyter notebooks
+            jupyter_rendering.replace('fontname="Courier",',
+                                      'fontname="Courier",fontsize=6,')
+            src = graphviz.Source(jupyter_rendering)
+            return src.pipe('svg').decode('UTF-8')
+
+        def __repr__(self):
+            return get_rendering(cmd='agf')
+
+    return DisasmCFG()

venv/lib/python3.10/site-packages/numba/misc/literal.py

@@ -0,0 +1,24 @@
+from numba.core.extending import overload
+from numba.core import types
+from numba.misc.special import literally, literal_unroll
+from numba.core.errors import TypingError
+
+
+@overload(literally)
+def _ov_literally(obj):
+    if isinstance(obj, (types.Literal, types.InitialValue)):
+        return lambda obj: obj
+    else:
+        m = "Invalid use of non-Literal type in literally({})".format(obj)
+        raise TypingError(m)
+
+
+@overload(literal_unroll)
+def literal_unroll_impl(container):
+    if isinstance(container, types.Poison):
+        m = f"Invalid use of non-Literal type in literal_unroll({container})"
+        raise TypingError(m)
+
+    def impl(container):
+        return container
+    return impl

venv/lib/python3.10/site-packages/numba/misc/llvm_pass_timings.py

@@ -0,0 +1,409 @@
+import re
+import operator
+import heapq
+from collections import namedtuple
+from collections.abc import Sequence
+from contextlib import contextmanager
+from functools import cached_property
+
+from numba.core import config
+
+import llvmlite.binding as llvm
+
+
+class RecordLLVMPassTimings:
+    """A helper context manager to track LLVM pass timings.
+    """
+
+    __slots__ = ["_data"]
+
+    def __enter__(self):
+        """Enables the pass timing in LLVM.
+        """
+        llvm.set_time_passes(True)
+        return self
+
+    def __exit__(self, exc_val, exc_type, exc_tb):
+        """Reset timings and save report internally.
+        """
+        self._data = llvm.report_and_reset_timings()
+        llvm.set_time_passes(False)
+        return
+
+    def get(self):
+        """Retrieve timing data for processing.
+
+        Returns
+        -------
+        timings: ProcessedPassTimings
+        """
+        return ProcessedPassTimings(self._data)
+
+
+PassTimingRecord = namedtuple(
+    "PassTimingRecord",
+    [
+        "user_time",
+        "user_percent",
+        "system_time",
+        "system_percent",
+        "user_system_time",
+        "user_system_percent",
+        "wall_time",
+        "wall_percent",
+        "pass_name",
+        "instruction",
+    ],
+)
+
+
+def _adjust_timings(records):
+    """Adjust timing records because of truncated information.
+
+    Details: The percent information can be used to improve the timing
+    information.
+
+    Returns
+    -------
+    res: List[PassTimingRecord]
+    """
+    total_rec = records[-1]
+    assert total_rec.pass_name == "Total"  # guard for implementation error
+
+    def make_adjuster(attr):
+        time_attr = f"{attr}_time"
+        percent_attr = f"{attr}_percent"
+        time_getter = operator.attrgetter(time_attr)
+
+        def adjust(d):
+            """Compute percent x total_time = adjusted"""
+            total = time_getter(total_rec)
+            adjusted = total * d[percent_attr] * 0.01
+            d[time_attr] = adjusted
+            return d
+
+        return adjust
+
+    # Make adjustment functions for each field
+    adj_fns = [
+        make_adjuster(x) for x in ["user", "system", "user_system", "wall"]
+    ]
+
+    # Extract dictionaries from the namedtuples
+    dicts = map(lambda x: x._asdict(), records)
+
+    def chained(d):
+        # Chain the adjustment functions
+        for fn in adj_fns:
+            d = fn(d)
+        # Reconstruct the namedtuple
+        return PassTimingRecord(**d)
+
+    return list(map(chained, dicts))
+
+
+class ProcessedPassTimings:
+    """A class for processing raw timing report from LLVM.
+
+    The processing is done lazily so we don't waste time processing unused
+    timing information.
+    """
+
+    def __init__(self, raw_data):
+        self._raw_data = raw_data
+
+    def __bool__(self):
+        return bool(self._raw_data)
+
+    def get_raw_data(self):
+        """Returns the raw string data.
+
+        Returns
+        -------
+        res: str
+        """
+        return self._raw_data
+
+    def get_total_time(self):
+        """Compute the total time spend in all passes.
+
+        Returns
+        -------
+        res: float
+        """
+        return self.list_records()[-1].wall_time
+
+    def list_records(self):
+        """Get the processed data for the timing report.
+
+        Returns
+        -------
+        res: List[PassTimingRecord]
+        """
+        return self._processed
+
+    def list_top(self, n):
+        """Returns the top(n) most time-consuming (by wall-time) passes.
+
+        Parameters
+        ----------
+        n: int
+            This limits the maximum number of items to show.
+            This function will show the ``n`` most time-consuming passes.
+
+        Returns
+        -------
+        res: List[PassTimingRecord]
+            Returns the top(n) most time-consuming passes in descending order.
+        """
+        records = self.list_records()
+        key = operator.attrgetter("wall_time")
+        return heapq.nlargest(n, records[:-1], key)
+
+    def summary(self, topn=5, indent=0):
+        """Return a string summarizing the timing information.
+
+        Parameters
+        ----------
+        topn: int; optional
+            This limits the maximum number of items to show.
+            This function will show the ``topn`` most time-consuming passes.
+        indent: int; optional
+            Set the indentation level. Defaults to 0 for no indentation.
+
+        Returns
+        -------
+        res: str
+        """
+        buf = []
+        prefix = " " * indent
+
+        def ap(arg):
+            buf.append(f"{prefix}{arg}")
+
+        ap(f"Total {self.get_total_time():.4f}s")
+        ap("Top timings:")
+        for p in self.list_top(topn):
+            ap(f"  {p.wall_time:.4f}s ({p.wall_percent:5}%) {p.pass_name}")
+        return "\n".join(buf)
+
+    @cached_property
+    def _processed(self):
+        """A cached property for lazily processing the data and returning it.
+
+        See ``_process()`` for details.
+        """
+        return self._process()
+
+    def _process(self):
+        """Parses the raw string data from LLVM timing report and attempts
+        to improve the data by recomputing the times
+        (See `_adjust_timings()``).
+        """
+
+        def parse(raw_data):
+            """A generator that parses the raw_data line-by-line to extract
+            timing information for each pass.
+            """
+            lines = raw_data.splitlines()
+            colheader = r"[a-zA-Z+ ]+"
+            # Take at least one column header.
+            multicolheaders = fr"(?:\s*-+{colheader}-+)+"
+
+            line_iter = iter(lines)
+            # find column headers
+            header_map = {
+                "User Time": "user",
+                "System Time": "system",
+                "User+System": "user_system",
+                "Wall Time": "wall",
+                "Instr": "instruction",
+                "Name": "pass_name",
+            }
+            for ln in line_iter:
+                m = re.match(multicolheaders, ln)
+                if m:
+                    # Get all the column headers
+                    raw_headers = re.findall(r"[a-zA-Z][a-zA-Z+ ]+", ln)
+                    headers = [header_map[k.strip()] for k in raw_headers]
+                    break
+
+            assert headers[-1] == 'pass_name'
+            # compute the list of available attributes from the column headers
+            attrs = []
+            n = r"\s*((?:[0-9]+\.)?[0-9]+)"
+            pat = ""
+            for k in headers[:-1]:
+                if k == "instruction":
+                    pat += n
+                else:
+                    attrs.append(f"{k}_time")
+                    attrs.append(f"{k}_percent")
+                    pat += rf"\s+(?:{n}\s*\({n}%\)|-+)"
+
+            # put default value 0.0 to all missing attributes
+            missing = {}
+            for k in PassTimingRecord._fields:
+                if k not in attrs and k != 'pass_name':
+                    missing[k] = 0.0
+            # parse timings
+            pat += r"\s*(.*)"
+            for ln in line_iter:
+                m = re.match(pat, ln)
+                if m is not None:
+                    raw_data = list(m.groups())
+                    data = {k: float(v) if v is not None else 0.0
+                            for k, v in zip(attrs, raw_data)}
+                    data.update(missing)
+                    pass_name = raw_data[-1]
+                    rec = PassTimingRecord(
+                        pass_name=pass_name, **data,
+                    )
+                    yield rec
+                    if rec.pass_name == "Total":
+                        # "Total" means the report has ended
+                        break
+            # Check that we have reach the end of the report
+            remaining = '\n'.join(line_iter)
+            if remaining:
+                raise ValueError(
+                    f"unexpected text after parser finished:\n{remaining}"
+                )
+
+        # Parse raw data
+        records = list(parse(self._raw_data))
+        return _adjust_timings(records)
+
+
+NamedTimings = namedtuple("NamedTimings", ["name", "timings"])
+
+
+class PassTimingsCollection(Sequence):
+    """A collection of pass timings.
+
+    This class implements the ``Sequence`` protocol for accessing the
+    individual timing records.
+    """
+
+    def __init__(self, name):
+        self._name = name
+        self._records = []
+
+    @contextmanager
+    def record(self, name):
+        """Record new timings and append to this collection.
+
+        Note: this is mainly for internal use inside the compiler pipeline.
+
+        See also ``RecordLLVMPassTimings``
+
+        Parameters
+        ----------
+        name: str
+            Name for the records.
+        """
+        if config.LLVM_PASS_TIMINGS:
+            # Recording of pass timings is enabled
+            with RecordLLVMPassTimings() as timings:
+                yield
+            rec = timings.get()
+            # Only keep non-empty records
+            if rec:
+                self._append(name, rec)
+        else:
+            # Do nothing. Recording of pass timings is disabled.
+            yield
+
+    def _append(self, name, timings):
+        """Append timing records
+
+        Parameters
+        ----------
+        name: str
+            Name for the records.
+        timings: ProcessedPassTimings
+            the timing records.
+        """
+        self._records.append(NamedTimings(name, timings))
+
+    def get_total_time(self):
+        """Computes the sum of the total time across all contained timings.
+
+        Returns
+        -------
+        res: float or None
+            Returns the total number of seconds or None if no timings were
+            recorded
+        """
+        if self._records:
+            return sum(r.timings.get_total_time() for r in self._records)
+        else:
+            return None
+
+    def list_longest_first(self):
+        """Returns the timings in descending order of total time duration.
+
+        Returns
+        -------
+        res: List[ProcessedPassTimings]
+        """
+        return sorted(self._records,
+                      key=lambda x: x.timings.get_total_time(),
+                      reverse=True)
+
+    @property
+    def is_empty(self):
+        """
+        """
+        return not self._records
+
+    def summary(self, topn=5):
+        """Return a string representing the summary of the timings.
+
+        Parameters
+        ----------
+        topn: int; optional, default=5.
+            This limits the maximum number of items to show.
+            This function will show the ``topn`` most time-consuming passes.
+
+        Returns
+        -------
+        res: str
+
+        See also ``ProcessedPassTimings.summary()``
+        """
+        if self.is_empty:
+            return "No pass timings were recorded"
+        else:
+            buf = []
+            ap = buf.append
+            ap(f"Printing pass timings for {self._name}")
+            overall_time = self.get_total_time()
+            ap(f"Total time: {overall_time:.4f}")
+            for i, r in enumerate(self._records):
+                ap(f"== #{i} {r.name}")
+                percent = r.timings.get_total_time() / overall_time * 100
+                ap(f" Percent: {percent:.1f}%")
+                ap(r.timings.summary(topn=topn, indent=1))
+            return "\n".join(buf)
+
+    def __getitem__(self, i):
+        """Get the i-th timing record.
+
+        Returns
+        -------
+        res: (name, timings)
+            A named tuple with two fields:
+
+            - name: str
+            - timings: ProcessedPassTimings
+        """
+        return self._records[i]
+
+    def __len__(self):
+        """Length of this collection.
+        """
+        return len(self._records)
+
+    def __str__(self):
+        return self.summary()

venv/lib/python3.10/site-packages/numba/misc/mergesort.py

@@ -0,0 +1,126 @@
+"""
+The same algorithm as translated from numpy.
+See numpy/core/src/npysort/mergesort.c.src.
+The high-level numba code is adding a little overhead comparing to
+the pure-C implementation in numpy.
+"""
+import numpy as np
+from collections import namedtuple
+
+# Array size smaller than this will be sorted by insertion sort
+SMALL_MERGESORT = 20
+
+
+MergesortImplementation = namedtuple('MergesortImplementation', [
+    'run_mergesort',
+])
+
+
+def make_mergesort_impl(wrap, lt=None, is_argsort=False):
+    kwargs_lite = dict(no_cpython_wrapper=True, _nrt=False)
+
+    # The less than
+    if lt is None:
+        @wrap(**kwargs_lite)
+        def lt(a, b):
+            return a < b
+    else:
+        lt = wrap(**kwargs_lite)(lt)
+
+    if is_argsort:
+        @wrap(**kwargs_lite)
+        def lessthan(a, b, vals):
+            return lt(vals[a], vals[b])
+    else:
+        @wrap(**kwargs_lite)
+        def lessthan(a, b, vals):
+            return lt(a, b)
+
+    @wrap(**kwargs_lite)
+    def argmergesort_inner(arr, vals, ws):
+        """The actual mergesort function
+
+        Parameters
+        ----------
+        arr : array [read+write]
+            The values being sorted inplace.  For argsort, this is the
+            indices.
+        vals : array [readonly]
+            ``None`` for normal sort.  In argsort, this is the actual array values.
+        ws : array [write]
+            The workspace.  Must be of size ``arr.size // 2``
+        """
+        if arr.size > SMALL_MERGESORT:
+            # Merge sort
+            mid = arr.size // 2
+
+            argmergesort_inner(arr[:mid], vals, ws)
+            argmergesort_inner(arr[mid:], vals, ws)
+
+            # Copy left half into workspace so we don't overwrite it
+            for i in range(mid):
+                ws[i] = arr[i]
+
+            # Merge
+            left = ws[:mid]
+            right = arr[mid:]
+            out = arr
+
+            i = j = k = 0
+            while i < left.size and j < right.size:
+                if not lessthan(right[j], left[i], vals):
+                    out[k] = left[i]
+                    i += 1
+                else:
+                    out[k] = right[j]
+                    j += 1
+                k += 1
+
+            # Leftovers
+            while i < left.size:
+                out[k] = left[i]
+                i += 1
+                k += 1
+
+            while j < right.size:
+                out[k] = right[j]
+                j += 1
+                k += 1
+        else:
+            # Insertion sort
+            i = 1
+            while i < arr.size:
+                j = i
+                while j > 0 and lessthan(arr[j], arr[j - 1], vals):
+                    arr[j - 1], arr[j] = arr[j], arr[j - 1]
+                    j -= 1
+                i += 1
+
+    # The top-level entry points
+
+    @wrap(no_cpython_wrapper=True)
+    def mergesort(arr):
+        "Inplace"
+        ws = np.empty(arr.size // 2, dtype=arr.dtype)
+        argmergesort_inner(arr, None, ws)
+        return arr
+
+
+    @wrap(no_cpython_wrapper=True)
+    def argmergesort(arr):
+        "Out-of-place"
+        idxs = np.arange(arr.size)
+        ws = np.empty(arr.size // 2, dtype=idxs.dtype)
+        argmergesort_inner(idxs, arr, ws)
+        return idxs
+
+    return MergesortImplementation(
+        run_mergesort=(argmergesort if is_argsort else mergesort)
+        )
+
+
+def make_jit_mergesort(*args, **kwargs):
+    from numba import njit
+    # NOTE: wrap with njit to allow recursion
+    #       because @register_jitable => @overload doesn't support recursion
+    return make_mergesort_impl(njit, *args, **kwargs)

venv/lib/python3.10/site-packages/numba/misc/numba_entry.py

@@ -0,0 +1,72 @@
+import sys
+import argparse
+import os
+import subprocess
+import json
+
+from .numba_sysinfo import display_sysinfo, get_sysinfo
+from .numba_gdbinfo import display_gdbinfo
+
+
+def make_parser():
+    parser = argparse.ArgumentParser()
+    parser.add_argument('--annotate', help='Annotate source',
+                        action='store_true')
+    parser.add_argument('--dump-llvm', action="store_true",
+                        help='Print generated llvm assembly')
+    parser.add_argument('--dump-optimized', action='store_true',
+                        help='Dump the optimized llvm assembly')
+    parser.add_argument('--dump-assembly', action='store_true',
+                        help='Dump the LLVM generated assembly')
+    parser.add_argument('--annotate-html', nargs=1,
+                        help='Output source annotation as html')
+    parser.add_argument('-s', '--sysinfo', action="store_true",
+                        help='Output system information for bug reporting')
+    parser.add_argument('-g', '--gdbinfo', action="store_true",
+                        help='Output system information about gdb')
+    parser.add_argument('--sys-json', nargs=1,
+                        help='Saves the system info dict as a json file')
+    parser.add_argument('filename', nargs='?', help='Python source filename')
+    return parser
+
+
+def main():
+    parser = make_parser()
+    args = parser.parse_args()
+
+    if args.sysinfo:
+        print("System info:")
+        display_sysinfo()
+
+    if args.gdbinfo:
+        print("GDB info:")
+        display_gdbinfo()
+
+    if args.sysinfo or args.gdbinfo:
+        sys.exit(0)
+
+    if args.sys_json:
+        info = get_sysinfo()
+        info.update({'Start': info['Start'].isoformat()})
+        info.update({'Start UTC': info['Start UTC'].isoformat()})
+        with open(args.sys_json[0], 'w') as f:
+            json.dump(info, f, indent=4)
+        sys.exit(0)
+
+    os.environ['NUMBA_DUMP_ANNOTATION'] = str(int(args.annotate))
+    if args.annotate_html is not None:
+        try:
+            from jinja2 import Template
+        except ImportError:
+            raise ImportError("Please install the 'jinja2' package")
+        os.environ['NUMBA_DUMP_HTML'] = str(args.annotate_html[0])
+    os.environ['NUMBA_DUMP_LLVM'] = str(int(args.dump_llvm))
+    os.environ['NUMBA_DUMP_OPTIMIZED'] = str(int(args.dump_optimized))
+    os.environ['NUMBA_DUMP_ASSEMBLY'] = str(int(args.dump_assembly))
+
+    if args.filename:
+        cmd = [sys.executable, args.filename]
+        subprocess.call(cmd)
+    else:
+        print("numba: error: the following arguments are required: filename")
+        sys.exit(1)

venv/lib/python3.10/site-packages/numba/misc/numba_gdbinfo.py

@@ -0,0 +1,161 @@
+"""Module for displaying information about Numba's gdb set up"""
+from collections import namedtuple
+import os
+import re
+import subprocess
+from textwrap import dedent
+from numba import config
+
+# Container for the output of the gdb info data collection
+_fields = ('binary_loc, extension_loc, py_ver, np_ver, supported')
+_gdb_info = namedtuple('_gdb_info', _fields)
+
+
+class _GDBTestWrapper():
+    """Wraps the gdb binary and has methods for checking what the gdb binary
+    has support for (Python and NumPy)."""
+
+    def __init__(self,):
+        gdb_binary = config.GDB_BINARY
+        if gdb_binary is None:
+            msg = ("No valid binary could be found for gdb named: "
+                   f"{config.GDB_BINARY}")
+            raise ValueError(msg)
+        self._gdb_binary = gdb_binary
+
+    def _run_cmd(self, cmd=()):
+        gdb_call = [self.gdb_binary, '-q',]
+        for x in cmd:
+            gdb_call.append('-ex')
+            gdb_call.append(x)
+        gdb_call.extend(['-ex', 'q'])
+        return subprocess.run(gdb_call, capture_output=True, timeout=10,
+                              text=True)
+
+    @property
+    def gdb_binary(self):
+        return self._gdb_binary
+
+    @classmethod
+    def success(cls, status):
+        return status.returncode == 0
+
+    def check_launch(self):
+        """Checks that gdb will launch ok"""
+        return self._run_cmd()
+
+    def check_python(self):
+        cmd = ("python from __future__ import print_function; "
+               "import sys; print(sys.version_info[:2])")
+        return self._run_cmd((cmd,))
+
+    def check_numpy(self):
+        cmd = ("python from __future__ import print_function; "
+               "import types; import numpy; "
+               "print(isinstance(numpy, types.ModuleType))")
+        return self._run_cmd((cmd,))
+
+    def check_numpy_version(self):
+        cmd = ("python from __future__ import print_function; "
+               "import types; import numpy;"
+               "print(numpy.__version__)")
+        return self._run_cmd((cmd,))
+
+
+def collect_gdbinfo():
+    """Prints information to stdout about the gdb setup that Numba has found"""
+
+    # State flags:
+    gdb_state = None
+    gdb_has_python = False
+    gdb_has_numpy = False
+    gdb_python_version = 'No Python support'
+    gdb_python_numpy_version = "No NumPy support"
+
+    # There are so many ways for gdb to not be working as expected. Surround
+    # the "is it working" tests with try/except and if there's an exception
+    # store it for processing later.
+    try:
+        # Check gdb exists
+        gdb_wrapper = _GDBTestWrapper()
+
+        # Check gdb works
+        status = gdb_wrapper.check_launch()
+        if not gdb_wrapper.success(status):
+            msg = (f"gdb at '{gdb_wrapper.gdb_binary}' does not appear to work."
+                   f"\nstdout: {status.stdout}\nstderr: {status.stderr}")
+            raise ValueError(msg)
+        gdb_state = gdb_wrapper.gdb_binary
+    except Exception as e:
+        gdb_state = f"Testing gdb binary failed. Reported Error: {e}"
+    else:
+        # Got this far, so gdb works, start checking what it supports
+        status = gdb_wrapper.check_python()
+        if gdb_wrapper.success(status):
+            version_match = re.match(r'\((\d+),\s+(\d+)\)',
+                                     status.stdout.strip())
+            if version_match is not None:
+                pymajor, pyminor = version_match.groups()
+                gdb_python_version = f"{pymajor}.{pyminor}"
+                gdb_has_python = True
+
+                status = gdb_wrapper.check_numpy()
+                if gdb_wrapper.success(status):
+                    if "Traceback" not in status.stderr.strip():
+                        if status.stdout.strip() == 'True':
+                            gdb_has_numpy = True
+                            gdb_python_numpy_version = "Unknown"
+                            # NumPy is present find the version
+                            status = gdb_wrapper.check_numpy_version()
+                            if gdb_wrapper.success(status):
+                                if "Traceback" not in status.stderr.strip():
+                                    gdb_python_numpy_version = \
+                                        status.stdout.strip()
+
+    # Work out what level of print-extension support is present in this gdb
+    if gdb_has_python:
+        if gdb_has_numpy:
+            print_ext_supported = "Full (Python and NumPy supported)"
+        else:
+            print_ext_supported = "Partial (Python only, no NumPy support)"
+    else:
+        print_ext_supported = "None"
+
+    # Work out print ext location
+    print_ext_file = "gdb_print_extension.py"
+    print_ext_path = os.path.join(os.path.dirname(__file__), print_ext_file)
+
+    # return!
+    return _gdb_info(gdb_state, print_ext_path, gdb_python_version,
+                     gdb_python_numpy_version, print_ext_supported)
+
+
+def display_gdbinfo(sep_pos=45):
+    """Displays the information collected by collect_gdbinfo.
+    """
+    gdb_info = collect_gdbinfo()
+    print('-' * 80)
+    fmt = f'%-{sep_pos}s : %-s'
+    # Display the information
+    print(fmt % ("Binary location", gdb_info.binary_loc))
+    print(fmt % ("Print extension location", gdb_info.extension_loc))
+    print(fmt % ("Python version", gdb_info.py_ver))
+    print(fmt % ("NumPy version", gdb_info.np_ver))
+    print(fmt % ("Numba printing extension support", gdb_info.supported))
+
+    print("")
+    print("To load the Numba gdb printing extension, execute the following "
+          "from the gdb prompt:")
+    print(f"\nsource {gdb_info.extension_loc}\n")
+    print('-' * 80)
+    warn = """
+    =============================================================
+    IMPORTANT: Before sharing you should remove any information
+    in the above that you wish to keep private e.g. paths.
+    =============================================================
+    """
+    print(dedent(warn))
+
+
+if __name__ == '__main__':
+    display_gdbinfo()

venv/lib/python3.10/site-packages/numba/misc/numba_sysinfo.py

@@ -0,0 +1,698 @@
+import json
+import locale
+import multiprocessing
+import os
+import platform
+import textwrap
+import sys
+from contextlib import redirect_stdout
+from datetime import datetime
+from io import StringIO
+from subprocess import check_output, PIPE, CalledProcessError
+import numpy as np
+import llvmlite.binding as llvmbind
+from llvmlite import __version__ as llvmlite_version
+from numba import cuda as cu, __version__ as version_number
+from numba.cuda import cudadrv
+from numba.cuda.cudadrv.driver import driver as cudriver
+from numba.cuda.cudadrv.runtime import runtime as curuntime
+from numba.core import config
+
+_psutil_import = False
+try:
+    import psutil
+except ImportError:
+    pass
+else:
+    _psutil_import = True
+
+__all__ = ['get_sysinfo', 'display_sysinfo']
+
+# Keys of a `sysinfo` dictionary
+
+# Time info
+_start, _start_utc, _runtime = 'Start', 'Start UTC', 'Runtime'
+_numba_version = 'Numba Version'
+# Hardware info
+_machine = 'Machine'
+_cpu_name, _cpu_count = 'CPU Name', 'CPU Count'
+_cpus_allowed, _cpus_list = 'CPUs Allowed', 'List CPUs Allowed'
+_cpu_features = 'CPU Features'
+_cfs_quota, _cfs_period = 'CFS Quota', 'CFS Period',
+_cfs_restrict = 'CFS Restriction'
+_mem_total, _mem_available = 'Mem Total', 'Mem Available'
+# OS info
+_platform_name, _platform_release = 'Platform Name', 'Platform Release'
+_os_name, _os_version = 'OS Name', 'OS Version'
+_os_spec_version = 'OS Specific Version'
+_libc_version = 'Libc Version'
+# Python info
+_python_comp = 'Python Compiler'
+_python_impl = 'Python Implementation'
+_python_version = 'Python Version'
+_python_locale = 'Python Locale'
+# LLVM info
+_llvmlite_version = 'llvmlite Version'
+_llvm_version = 'LLVM Version'
+# CUDA info
+_cu_target_impl = 'CUDA Target Impl'
+_cu_dev_init = 'CUDA Device Init'
+_cu_drv_ver = 'CUDA Driver Version'
+_cu_rt_ver = 'CUDA Runtime Version'
+_cu_nvidia_bindings = 'NVIDIA CUDA Bindings'
+_cu_nvidia_bindings_used = 'NVIDIA CUDA Bindings In Use'
+_cu_detect_out, _cu_lib_test = 'CUDA Detect Output', 'CUDA Lib Test'
+_cu_mvc_available = 'NVIDIA CUDA Minor Version Compatibility Available'
+_cu_mvc_needed = 'NVIDIA CUDA Minor Version Compatibility Needed'
+_cu_mvc_in_use = 'NVIDIA CUDA Minor Version Compatibility In Use'
+# NumPy info
+_numpy_version = 'NumPy Version'
+_numpy_supported_simd_features = 'NumPy Supported SIMD features'
+_numpy_supported_simd_dispatch = 'NumPy Supported SIMD dispatch'
+_numpy_supported_simd_baseline = 'NumPy Supported SIMD baseline'
+_numpy_AVX512_SKX_detected = 'NumPy AVX512_SKX detected'
+# SVML info
+_svml_state, _svml_loaded = 'SVML State', 'SVML Lib Loaded'
+_llvm_svml_patched = 'LLVM SVML Patched'
+_svml_operational = 'SVML Operational'
+# Threading layer info
+_tbb_thread, _tbb_error = 'TBB Threading', 'TBB Threading Error'
+_openmp_thread, _openmp_error = 'OpenMP Threading', 'OpenMP Threading Error'
+_openmp_vendor = 'OpenMP vendor'
+_wkq_thread, _wkq_error = 'Workqueue Threading', 'Workqueue Threading Error'
+# Numba info
+_numba_env_vars = 'Numba Env Vars'
+# Conda info
+_conda_build_ver, _conda_env_ver = 'Conda Build', 'Conda Env'
+_conda_platform, _conda_python_ver = 'Conda Platform', 'Conda Python Version'
+_conda_root_writable = 'Conda Root Writable'
+# Packages info
+_inst_pkg = 'Installed Packages'
+# Psutil info
+_psutil = 'Psutil Available'
+# Errors and warnings
+_errors = 'Errors'
+_warnings = 'Warnings'
+
+# Error and warning log
+_error_log = []
+_warning_log = []
+
+
+def get_os_spec_info(os_name):
+    # Linux man page for `/proc`:
+    # http://man7.org/linux/man-pages/man5/proc.5.html
+
+    # Windows documentation for `wmic OS`:
+    # https://docs.microsoft.com/en-us/windows/win32/cimwin32prov/cim-operatingsystem
+
+    # MacOS man page for `sysctl`:
+    # https://www.unix.com/man-page/osx/3/sysctl/
+    # MacOS man page for `vm_stat`:
+    # https://www.unix.com/man-page/osx/1/vm_stat/
+
+    class CmdBufferOut(tuple):
+        buffer_output_flag = True
+
+    class CmdReadFile(tuple):
+        read_file_flag = True
+
+    shell_params = {
+        'Linux': {
+            'cmd': (
+                CmdReadFile(('/sys/fs/cgroup/cpuacct/cpu.cfs_quota_us',)),
+                CmdReadFile(('/sys/fs/cgroup/cpuacct/cpu.cfs_period_us',)),
+            ),
+            'cmd_optional': (
+                CmdReadFile(('/proc/meminfo',)),
+                CmdReadFile(('/proc/self/status',)),
+            ),
+            'kwds': {
+                # output string fragment -> result dict key
+                'MemTotal:': _mem_total,
+                'MemAvailable:': _mem_available,
+                'Cpus_allowed:': _cpus_allowed,
+                'Cpus_allowed_list:': _cpus_list,
+                '/sys/fs/cgroup/cpuacct/cpu.cfs_quota_us': _cfs_quota,
+                '/sys/fs/cgroup/cpuacct/cpu.cfs_period_us': _cfs_period,
+            },
+        },
+        'Windows': {
+            'cmd': (),
+            'cmd_optional': (
+                CmdBufferOut(('wmic', 'OS', 'get', 'TotalVirtualMemorySize')),
+                CmdBufferOut(('wmic', 'OS', 'get', 'FreeVirtualMemory')),
+            ),
+            'kwds': {
+                # output string fragment -> result dict key
+                'TotalVirtualMemorySize': _mem_total,
+                'FreeVirtualMemory': _mem_available,
+            },
+        },
+        'Darwin': {
+            'cmd': (),
+            'cmd_optional': (
+                ('sysctl', 'hw.memsize'),
+                ('vm_stat'),
+            ),
+            'kwds': {
+                # output string fragment -> result dict key
+                'hw.memsize:': _mem_total,
+                'free:': _mem_available,
+            },
+            'units': {
+                _mem_total: 1,  # Size is given in bytes.
+                _mem_available: 4096,  # Size is given in 4kB pages.
+            },
+        },
+    }
+
+    os_spec_info = {}
+    params = shell_params.get(os_name, {})
+    cmd_selected = params.get('cmd', ())
+
+    if _psutil_import:
+        vm = psutil.virtual_memory()
+        os_spec_info.update({
+            _mem_total: vm.total,
+            _mem_available: vm.available,
+        })
+        p = psutil.Process()
+        cpus_allowed = p.cpu_affinity() if hasattr(p, 'cpu_affinity') else []
+        if cpus_allowed:
+            os_spec_info[_cpus_allowed] = len(cpus_allowed)
+            os_spec_info[_cpus_list] = ' '.join(str(n) for n in cpus_allowed)
+
+    else:
+        _warning_log.append(
+            "Warning (psutil): psutil cannot be imported. "
+            "For more accuracy, consider installing it.")
+        # Fallback to internal heuristics
+        cmd_selected += params.get('cmd_optional', ())
+
+    # Assuming the shell cmd returns a unique (k, v) pair per line
+    # or a unique (k, v) pair spread over several lines:
+    # Gather output in a list of strings containing a keyword and some value.
+    output = []
+    for cmd in cmd_selected:
+        if hasattr(cmd, 'read_file_flag'):
+            # Open file within Python
+            if os.path.exists(cmd[0]):
+                try:
+                    with open(cmd[0], 'r') as f:
+                        out = f.readlines()
+                        if out:
+                            out[0] = ' '.join((cmd[0], out[0]))
+                            output.extend(out)
+                except OSError as e:
+                    _error_log.append(f'Error (file read): {e}')
+                    continue
+            else:
+                _warning_log.append('Warning (no file): {}'.format(cmd[0]))
+                continue
+        else:
+            # Spawn a subprocess
+            try:
+                out = check_output(cmd, stderr=PIPE)
+            except (OSError, CalledProcessError) as e:
+                _error_log.append(f'Error (subprocess): {e}')
+                continue
+            if hasattr(cmd, 'buffer_output_flag'):
+                out = b' '.join(line for line in out.splitlines()) + b'\n'
+            output.extend(out.decode().splitlines())
+
+    # Extract (k, output) pairs by searching for keywords in output
+    kwds = params.get('kwds', {})
+    for line in output:
+        match = kwds.keys() & line.split()
+        if match and len(match) == 1:
+            k = kwds[match.pop()]
+            os_spec_info[k] = line
+        elif len(match) > 1:
+            print(f'Ambiguous output: {line}')
+
+    # Try to extract something meaningful from output string
+    def format():
+        # CFS restrictions
+        split = os_spec_info.get(_cfs_quota, '').split()
+        if split:
+            os_spec_info[_cfs_quota] = float(split[-1])
+        split = os_spec_info.get(_cfs_period, '').split()
+        if split:
+            os_spec_info[_cfs_period] = float(split[-1])
+        if os_spec_info.get(_cfs_quota, -1) != -1:
+            cfs_quota = os_spec_info.get(_cfs_quota, '')
+            cfs_period = os_spec_info.get(_cfs_period, '')
+            runtime_amount = cfs_quota / cfs_period
+            os_spec_info[_cfs_restrict] = runtime_amount
+
+    def format_optional():
+        # Memory
+        units = {_mem_total: 1024, _mem_available: 1024}
+        units.update(params.get('units', {}))
+        for k in (_mem_total, _mem_available):
+            digits = ''.join(d for d in os_spec_info.get(k, '') if d.isdigit())
+            os_spec_info[k] = int(digits or 0) * units[k]
+        # Accessible CPUs
+        split = os_spec_info.get(_cpus_allowed, '').split()
+        if split:
+            n = split[-1]
+            n = n.split(',')[-1]
+            os_spec_info[_cpus_allowed] = str(bin(int(n or 0, 16))).count('1')
+        split = os_spec_info.get(_cpus_list, '').split()
+        if split:
+            os_spec_info[_cpus_list] = split[-1]
+
+    try:
+        format()
+        if not _psutil_import:
+            format_optional()
+    except Exception as e:
+        _error_log.append(f'Error (format shell output): {e}')
+
+    # Call OS specific functions
+    os_specific_funcs = {
+        'Linux': {
+            _libc_version: lambda: ' '.join(platform.libc_ver())
+        },
+        'Windows': {
+            _os_spec_version: lambda: ' '.join(
+                s for s in platform.win32_ver()),
+        },
+        'Darwin': {
+            _os_spec_version: lambda: ''.join(
+                i or ' ' for s in tuple(platform.mac_ver()) for i in s),
+        },
+    }
+    key_func = os_specific_funcs.get(os_name, {})
+    os_spec_info.update({k: f() for k, f in key_func.items()})
+    return os_spec_info
+
+
+def get_sysinfo():
+
+    # Gather the information that shouldn't raise exceptions
+    sys_info = {
+        _start: datetime.now(),
+        _start_utc: datetime.utcnow(),
+        _machine: platform.machine(),
+        _cpu_name: llvmbind.get_host_cpu_name(),
+        _cpu_count: multiprocessing.cpu_count(),
+        _platform_name: platform.platform(aliased=True),
+        _platform_release: platform.release(),
+        _os_name: platform.system(),
+        _os_version: platform.version(),
+        _python_comp: platform.python_compiler(),
+        _python_impl: platform.python_implementation(),
+        _python_version: platform.python_version(),
+        _numba_env_vars: {k: v for (k, v) in os.environ.items()
+                          if k.startswith('NUMBA_')},
+        _numba_version: version_number,
+        _llvm_version: '.'.join(str(i) for i in llvmbind.llvm_version_info),
+        _llvmlite_version: llvmlite_version,
+        _psutil: _psutil_import,
+    }
+
+    # CPU features
+    try:
+        feature_map = llvmbind.get_host_cpu_features()
+    except RuntimeError as e:
+        _error_log.append(f'Error (CPU features): {e}')
+    else:
+        features = sorted([key for key, value in feature_map.items() if value])
+        sys_info[_cpu_features] = ' '.join(features)
+
+    # Python locale
+    # On MacOSX, getdefaultlocale can raise. Check again if Py > 3.7.5
+    try:
+        # If $LANG is unset, getdefaultlocale() can return (None, None), make
+        # sure we can encode this as strings by casting explicitly.
+        sys_info[_python_locale] = '.'.join([str(i) for i in
+                                             locale.getdefaultlocale()])
+    except Exception as e:
+        _error_log.append(f'Error (locale): {e}')
+
+    # CUDA information
+    try:
+        sys_info[_cu_target_impl] = cu.implementation
+    except AttributeError:
+        # On the offchance an out-of-tree target did not set the
+        # implementation, we can try to continue
+        pass
+
+    try:
+        cu.list_devices()[0]  # will a device initialise?
+    except Exception as e:
+        sys_info[_cu_dev_init] = False
+        msg_not_found = "CUDA driver library cannot be found"
+        msg_disabled_by_user = "CUDA is disabled"
+        msg_end = " or no CUDA enabled devices are present."
+        msg_generic_problem = "CUDA device initialisation problem."
+        msg = getattr(e, 'msg', None)
+        if msg is not None:
+            if msg_not_found in msg:
+                err_msg = msg_not_found + msg_end
+            elif msg_disabled_by_user in msg:
+                err_msg = msg_disabled_by_user + msg_end
+            else:
+                err_msg = msg_generic_problem + " Message:" + msg
+        else:
+            err_msg = msg_generic_problem + " " + str(e)
+        # Best effort error report
+        _warning_log.append("Warning (cuda): %s\nException class: %s" %
+                            (err_msg, str(type(e))))
+    else:
+        try:
+            sys_info[_cu_dev_init] = True
+
+            output = StringIO()
+            with redirect_stdout(output):
+                cu.detect()
+            sys_info[_cu_detect_out] = output.getvalue()
+            output.close()
+
+            cu_drv_ver = cudriver.get_version()
+            cu_rt_ver = curuntime.get_version()
+            sys_info[_cu_drv_ver] = '%s.%s' % cu_drv_ver
+            sys_info[_cu_rt_ver] = '%s.%s' % cu_rt_ver
+
+            output = StringIO()
+            with redirect_stdout(output):
+                cudadrv.libs.test()
+            sys_info[_cu_lib_test] = output.getvalue()
+            output.close()
+
+            try:
+                from cuda import cuda  # noqa: F401
+                nvidia_bindings_available = True
+            except ImportError:
+                nvidia_bindings_available = False
+            sys_info[_cu_nvidia_bindings] = nvidia_bindings_available
+
+            nv_binding_used = bool(cudadrv.driver.USE_NV_BINDING)
+            sys_info[_cu_nvidia_bindings_used] = nv_binding_used
+
+            try:
+                from ptxcompiler import compile_ptx  # noqa: F401
+                from cubinlinker import CubinLinker  # noqa: F401
+                sys_info[_cu_mvc_available] = True
+            except ImportError:
+                sys_info[_cu_mvc_available] = False
+
+            sys_info[_cu_mvc_needed] = cu_rt_ver > cu_drv_ver
+            sys_info[_cu_mvc_in_use] = bool(
+                config.CUDA_ENABLE_MINOR_VERSION_COMPATIBILITY)
+        except Exception as e:
+            _warning_log.append(
+                "Warning (cuda): Probing CUDA failed "
+                "(device and driver present, runtime problem?)\n"
+                f"(cuda) {type(e)}: {e}")
+
+    # NumPy information
+    sys_info[_numpy_version] = np.version.full_version
+    try:
+        # NOTE: These consts were added in NumPy 1.20
+        from numpy.core._multiarray_umath import (__cpu_features__,
+                                                  __cpu_dispatch__,
+                                                  __cpu_baseline__,)
+    except ImportError:
+        sys_info[_numpy_AVX512_SKX_detected] = False
+    else:
+        feat_filtered = [k for k, v in __cpu_features__.items() if v]
+        sys_info[_numpy_supported_simd_features] = feat_filtered
+        sys_info[_numpy_supported_simd_dispatch] = __cpu_dispatch__
+        sys_info[_numpy_supported_simd_baseline] = __cpu_baseline__
+        sys_info[_numpy_AVX512_SKX_detected] = \
+            __cpu_features__.get("AVX512_SKX", False)
+
+    # SVML information
+    # Replicate some SVML detection logic from numba.__init__ here.
+    # If SVML load fails in numba.__init__ the splitting of the logic
+    # here will help diagnosing the underlying issue.
+    svml_lib_loaded = True
+    try:
+        if sys.platform.startswith('linux'):
+            llvmbind.load_library_permanently("libsvml.so")
+        elif sys.platform.startswith('darwin'):
+            llvmbind.load_library_permanently("libsvml.dylib")
+        elif sys.platform.startswith('win'):
+            llvmbind.load_library_permanently("svml_dispmd")
+        else:
+            svml_lib_loaded = False
+    except Exception:
+        svml_lib_loaded = False
+    func = getattr(llvmbind.targets, "has_svml", None)
+    sys_info[_llvm_svml_patched] = func() if func else False
+    sys_info[_svml_state] = config.USING_SVML
+    sys_info[_svml_loaded] = svml_lib_loaded
+    sys_info[_svml_operational] = all((
+        sys_info[_svml_state],
+        sys_info[_svml_loaded],
+        sys_info[_llvm_svml_patched],
+    ))
+
+    # Check which threading backends are available.
+    def parse_error(e, backend):
+        # parses a linux based error message, this is to provide feedback
+        # and hide user paths etc
+        try:
+            path, problem, symbol = [x.strip() for x in e.msg.split(':')]
+            extn_dso = os.path.split(path)[1]
+            if backend in extn_dso:
+                return "%s: %s" % (problem, symbol)
+        except Exception:
+            pass
+        return "Unknown import problem."
+
+    try:
+        # check import is ok, this means the DSO linkage is working
+        from numba.np.ufunc import tbbpool  # NOQA
+        # check that the version is compatible, this is a check performed at
+        # runtime (well, compile time), it will also ImportError if there's
+        # a problem.
+        from numba.np.ufunc.parallel import _check_tbb_version_compatible
+        _check_tbb_version_compatible()
+        sys_info[_tbb_thread] = True
+    except ImportError as e:
+        # might be a missing symbol due to e.g. tbb libraries missing
+        sys_info[_tbb_thread] = False
+        sys_info[_tbb_error] = parse_error(e, 'tbbpool')
+
+    try:
+        from numba.np.ufunc import omppool
+        sys_info[_openmp_thread] = True
+        sys_info[_openmp_vendor] = omppool.openmp_vendor
+    except ImportError as e:
+        sys_info[_openmp_thread] = False
+        sys_info[_openmp_error] = parse_error(e, 'omppool')
+
+    try:
+        from numba.np.ufunc import workqueue  # NOQA
+        sys_info[_wkq_thread] = True
+    except ImportError as e:
+        sys_info[_wkq_thread] = True
+        sys_info[_wkq_error] = parse_error(e, 'workqueue')
+
+    # Look for conda and installed packages information
+    cmd = ('conda', 'info', '--json')
+    try:
+        conda_out = check_output(cmd)
+    except Exception as e:
+        _warning_log.append(f'Warning: Conda not available.\n Error was {e}\n')
+        # Conda is not available, try pip list to list installed packages
+        cmd = (sys.executable, '-m', 'pip', 'list')
+        try:
+            reqs = check_output(cmd)
+        except Exception as e:
+            _error_log.append(f'Error (pip): {e}')
+        else:
+            sys_info[_inst_pkg] = reqs.decode().splitlines()
+
+    else:
+        jsond = json.loads(conda_out.decode())
+        keys = {
+            'conda_build_version': _conda_build_ver,
+            'conda_env_version': _conda_env_ver,
+            'platform': _conda_platform,
+            'python_version': _conda_python_ver,
+            'root_writable': _conda_root_writable,
+        }
+        for conda_k, sysinfo_k in keys.items():
+            sys_info[sysinfo_k] = jsond.get(conda_k, 'N/A')
+
+        # Get info about packages in current environment
+        cmd = ('conda', 'list')
+        try:
+            conda_out = check_output(cmd)
+        except CalledProcessError as e:
+            _error_log.append(f'Error (conda): {e}')
+        else:
+            data = conda_out.decode().splitlines()
+            sys_info[_inst_pkg] = [l for l in data if not l.startswith('#')]
+
+    sys_info.update(get_os_spec_info(sys_info[_os_name]))
+    sys_info[_errors] = _error_log
+    sys_info[_warnings] = _warning_log
+    sys_info[_runtime] = (datetime.now() - sys_info[_start]).total_seconds()
+    return sys_info
+
+
+def display_sysinfo(info=None, sep_pos=45):
+    class DisplayMap(dict):
+        display_map_flag = True
+
+    class DisplaySeq(tuple):
+        display_seq_flag = True
+
+    class DisplaySeqMaps(tuple):
+        display_seqmaps_flag = True
+
+    if info is None:
+        info = get_sysinfo()
+
+    fmt = f'%-{sep_pos}s : %-s'
+    MB = 1024**2
+    template = (
+        ("-" * 80,),
+        ("__Time Stamp__",),
+        ("Report started (local time)", info.get(_start, '?')),
+        ("UTC start time", info.get(_start_utc, '?')),
+        ("Running time (s)", info.get(_runtime, '?')),
+        ("",),
+        ("__Hardware Information__",),
+        ("Machine", info.get(_machine, '?')),
+        ("CPU Name", info.get(_cpu_name, '?')),
+        ("CPU Count", info.get(_cpu_count, '?')),
+        ("Number of accessible CPUs", info.get(_cpus_allowed, '?')),
+        ("List of accessible CPUs cores", info.get(_cpus_list, '?')),
+        ("CFS Restrictions (CPUs worth of runtime)",
+            info.get(_cfs_restrict, 'None')),
+        ("",),
+        ("CPU Features", '\n'.join(
+            ' ' * (sep_pos + 3) + l if i else l
+            for i, l in enumerate(
+                textwrap.wrap(
+                    info.get(_cpu_features, '?'),
+                    width=79 - sep_pos
+                )
+            )
+        )),
+        ("",),
+        ("Memory Total (MB)", info.get(_mem_total, 0) // MB or '?'),
+        ("Memory Available (MB)"
+            if info.get(_os_name, '') != 'Darwin' or info.get(_psutil, False)
+            else "Free Memory (MB)", info.get(_mem_available, 0) // MB or '?'),
+        ("",),
+        ("__OS Information__",),
+        ("Platform Name", info.get(_platform_name, '?')),
+        ("Platform Release", info.get(_platform_release, '?')),
+        ("OS Name", info.get(_os_name, '?')),
+        ("OS Version", info.get(_os_version, '?')),
+        ("OS Specific Version", info.get(_os_spec_version, '?')),
+        ("Libc Version", info.get(_libc_version, '?')),
+        ("",),
+        ("__Python Information__",),
+        DisplayMap({k: v for k, v in info.items() if k.startswith('Python')}),
+        ("",),
+        ("__Numba Toolchain Versions__",),
+        ("Numba Version", info.get(_numba_version, '?')),
+        ("llvmlite Version", info.get(_llvmlite_version, '?')),
+        ("",),
+        ("__LLVM Information__",),
+        ("LLVM Version", info.get(_llvm_version, '?')),
+        ("",),
+        ("__CUDA Information__",),
+        ("CUDA Target Implementation", info.get(_cu_target_impl, '?')),
+        ("CUDA Device Initialized", info.get(_cu_dev_init, '?')),
+        ("CUDA Driver Version", info.get(_cu_drv_ver, '?')),
+        ("CUDA Runtime Version", info.get(_cu_rt_ver, '?')),
+        ("CUDA NVIDIA Bindings Available", info.get(_cu_nvidia_bindings, '?')),
+        ("CUDA NVIDIA Bindings In Use",
+         info.get(_cu_nvidia_bindings_used, '?')),
+        ("CUDA Minor Version Compatibility Available",
+         info.get(_cu_mvc_available, '?')),
+        ("CUDA Minor Version Compatibility Needed",
+         info.get(_cu_mvc_needed, '?')),
+        ("CUDA Minor Version Compatibility In Use",
+         info.get(_cu_mvc_in_use, '?')),
+        ("CUDA Detect Output:",),
+        (info.get(_cu_detect_out, "None"),),
+        ("CUDA Libraries Test Output:",),
+        (info.get(_cu_lib_test, "None"),),
+        ("",),
+        ("__NumPy Information__",),
+        ("NumPy Version", info.get(_numpy_version, '?')),
+        ("NumPy Supported SIMD features",
+         DisplaySeq(info.get(_numpy_supported_simd_features, [])
+                    or ('None found.',))),
+        ("NumPy Supported SIMD dispatch",
+         DisplaySeq(info.get(_numpy_supported_simd_dispatch, [])
+                    or ('None found.',))),
+        ("NumPy Supported SIMD baseline",
+         DisplaySeq(info.get(_numpy_supported_simd_baseline, [])
+                    or ('None found.',))),
+        ("NumPy AVX512_SKX support detected",
+         info.get(_numpy_AVX512_SKX_detected, '?')),
+        ("",),
+        ("__SVML Information__",),
+        ("SVML State, config.USING_SVML", info.get(_svml_state, '?')),
+        ("SVML Library Loaded", info.get(_svml_loaded, '?')),
+        ("llvmlite Using SVML Patched LLVM", info.get(_llvm_svml_patched, '?')),
+        ("SVML Operational", info.get(_svml_operational, '?')),
+        ("",),
+        ("__Threading Layer Information__",),
+        ("TBB Threading Layer Available", info.get(_tbb_thread, '?')),
+        ("+-->TBB imported successfully." if info.get(_tbb_thread, '?')
+            else f"+--> Disabled due to {info.get(_tbb_error, '?')}",),
+        ("OpenMP Threading Layer Available", info.get(_openmp_thread, '?')),
+        (f"+-->Vendor: {info.get(_openmp_vendor, '?')}"
+            if info.get(_openmp_thread, False)
+            else f"+--> Disabled due to {info.get(_openmp_error, '?')}",),
+        ("Workqueue Threading Layer Available", info.get(_wkq_thread, '?')),
+        ("+-->Workqueue imported successfully." if info.get(_wkq_thread, False)
+            else f"+--> Disabled due to {info.get(_wkq_error, '?')}",),
+        ("",),
+        ("__Numba Environment Variable Information__",),
+        (DisplayMap(info.get(_numba_env_vars, {})) or ('None found.',)),
+        ("",),
+        ("__Conda Information__",),
+        (DisplayMap({k: v for k, v in info.items()
+                     if k.startswith('Conda')}) or ("Conda not available.",)),
+        ("",),
+        ("__Installed Packages__",),
+        DisplaySeq(info.get(_inst_pkg, ("Couldn't retrieve packages info.",))),
+        ("",),
+        ("__Error log__" if info.get(_errors, [])
+            else "No errors reported.",),
+        DisplaySeq(info.get(_errors, [])),
+        ("",),
+        ("__Warning log__" if info.get(_warnings, [])
+            else "No warnings reported.",),
+        DisplaySeq(info.get(_warnings, [])),
+        ("-" * 80,),
+        ("If requested, please copy and paste the information between\n"
+         "the dashed (----) lines, or from a given specific section as\n"
+         "appropriate.\n\n"
+         "=============================================================\n"
+         "IMPORTANT: Please ensure that you are happy with sharing the\n"
+         "contents of the information present, any information that you\n"
+         "wish to keep private you should remove before sharing.\n"
+         "=============================================================\n",),
+    )
+    for t in template:
+        if hasattr(t, 'display_seq_flag'):
+            print(*t, sep='\n')
+        elif hasattr(t, 'display_map_flag'):
+            print(*tuple(fmt % (k, v) for (k, v) in t.items()), sep='\n')
+        elif hasattr(t, 'display_seqmaps_flag'):
+            for d in t:
+                print(*tuple(fmt % ('\t' + k, v) for (k, v) in d.items()),
+                      sep='\n', end='\n')
+        elif len(t) == 2:
+            print(fmt % t)
+        else:
+            print(*t)
+
+
+if __name__ == '__main__':
+    display_sysinfo()

venv/lib/python3.10/site-packages/numba/misc/quicksort.py

@@ -0,0 +1,261 @@
+import collections
+
+import numpy as np
+
+from numba.core import types, config
+
+
+QuicksortImplementation = collections.namedtuple(
+    'QuicksortImplementation',
+    (# The compile function itself
+     'compile',
+     # All subroutines exercised by test_sort
+     'partition', 'partition3', 'insertion_sort',
+     # The top-level function
+     'run_quicksort',
+     ))
+
+
+Partition = collections.namedtuple('Partition', ('start', 'stop'))
+
+# Under this size, switch to a simple insertion sort
+SMALL_QUICKSORT = 15
+
+MAX_STACK = 100
+
+
+def make_quicksort_impl(wrap, lt=None, is_argsort=False, is_list=False, is_np_array=False):
+
+    if config.USE_LEGACY_TYPE_SYSTEM:
+        intp = types.intp
+    else:
+        intp = types.py_int
+    zero = intp(0)
+
+    # Two subroutines to make the core algorithm generic wrt. argsort
+    # or normal sorting.  Note the genericity may make basic sort()
+    # slightly slower (~5%)
+    if is_argsort:
+        if is_list:
+            @wrap
+            def make_res(A):
+                return [x for x in range(len(A))]
+        else:
+            @wrap
+            def make_res(A):
+                return np.arange(A.size)
+
+        @wrap
+        def GET(A, idx_or_val):
+            return A[idx_or_val]
+
+    else:
+        @wrap
+        def make_res(A):
+            return A
+
+        @wrap
+        def GET(A, idx_or_val):
+            return idx_or_val
+
+    def default_lt(a, b):
+        """
+        Trivial comparison function between two keys.
+        """
+        return a < b
+
+    LT = wrap(lt if lt is not None else default_lt)
+
+    @wrap
+    def insertion_sort(A, R, low, high):
+        """
+        Insertion sort A[low:high + 1]. Note the inclusive bounds.
+        """
+        assert low >= 0
+        if high <= low:
+            return
+
+        for i in range(low + 1, high + 1):
+            k = R[i]
+            v = GET(A, k)
+            # Insert v into A[low:i]
+            j = i
+            while j > low and LT(v, GET(A, R[j - 1])):
+                # Make place for moving A[i] downwards
+                R[j] = R[j - 1]
+                j -= 1
+            R[j] = k
+
+    @wrap
+    def partition(A, R, low, high):
+        """
+        Partition A[low:high + 1] around a chosen pivot.  The pivot's index
+        is returned.
+        """
+        assert low >= 0
+        assert high > low
+
+        mid = (low + high) >> 1
+        # NOTE: the pattern of swaps below for the pivot choice and the
+        # partitioning gives good results (i.e. regular O(n log n))
+        # on sorted, reverse-sorted, and uniform arrays.  Subtle changes
+        # risk breaking this property.
+
+        # median of three {low, middle, high}
+        if LT(GET(A, R[mid]), GET(A, R[low])):
+            R[low], R[mid] = R[mid], R[low]
+        if LT(GET(A, R[high]), GET(A, R[mid])):
+            R[high], R[mid] = R[mid], R[high]
+        if LT(GET(A, R[mid]), GET(A, R[low])):
+            R[low], R[mid] = R[mid], R[low]
+        pivot = GET(A, R[mid])
+
+        # Temporarily stash the pivot at the end
+        R[high], R[mid] = R[mid], R[high]
+        i = low
+        j = high - 1
+        while True:
+            while i < high and LT(GET(A, R[i]), pivot):
+                i += 1
+            while j >= low and LT(pivot, GET(A, R[j])):
+                j -= 1
+            if i >= j:
+                break
+            R[i], R[j] = R[j], R[i]
+            i += 1
+            j -= 1
+        # Put the pivot back in its final place (all items before `i`
+        # are smaller than the pivot, all items at/after `i` are larger)
+        R[i], R[high] = R[high], R[i]
+        return i
+
+    @wrap
+    def partition3(A, low, high):
+        """
+        Three-way partition [low, high) around a chosen pivot.
+        A tuple (lt, gt) is returned such that:
+            - all elements in [low, lt) are < pivot
+            - all elements in [lt, gt] are == pivot
+            - all elements in (gt, high] are > pivot
+        """
+        mid = (low + high) >> 1
+        # median of three {low, middle, high}
+        if LT(A[mid], A[low]):
+            A[low], A[mid] = A[mid], A[low]
+        if LT(A[high], A[mid]):
+            A[high], A[mid] = A[mid], A[high]
+        if LT(A[mid], A[low]):
+            A[low], A[mid] = A[mid], A[low]
+        pivot = A[mid]
+
+        A[low], A[mid] = A[mid], A[low]
+        lt = low
+        gt = high
+        i = low + 1
+        while i <= gt:
+            if LT(A[i], pivot):
+                A[lt], A[i] = A[i], A[lt]
+                lt += 1
+                i += 1
+            elif LT(pivot, A[i]):
+                A[gt], A[i] = A[i], A[gt]
+                gt -= 1
+            else:
+                i += 1
+        return lt, gt
+
+    @wrap
+    def run_quicksort1(A):
+        R = make_res(A)
+
+        if len(A) < 2:
+            return R
+
+        stack = [Partition(zero, zero)] * MAX_STACK
+        stack[0] = Partition(zero, len(A) - 1)
+        n = 1
+
+        while n > 0:
+            n -= 1
+            low, high = stack[n]
+            # Partition until it becomes more efficient to do an insertion sort
+            while high - low >= SMALL_QUICKSORT:
+                assert n < MAX_STACK
+                i = partition(A, R, low, high)
+                # Push largest partition on the stack
+                if high - i > i - low:
+                    # Right is larger
+                    if high > i:
+                        stack[n] = Partition(i + 1, high)
+                        n += 1
+                    high = i - 1
+                else:
+                    if i > low:
+                        stack[n] = Partition(low, i - 1)
+                        n += 1
+                    low = i + 1
+
+            insertion_sort(A, R, low, high)
+
+        return R
+
+    if is_np_array:
+        @wrap
+        def run_quicksort(A):
+            if A.ndim == 1:
+                return run_quicksort1(A)
+            else:
+                for idx in np.ndindex(A.shape[:-1]):
+                    run_quicksort1(A[idx])
+                return A
+    else:
+        @wrap
+        def run_quicksort(A):
+            return run_quicksort1(A)
+
+    # Unused quicksort implementation based on 3-way partitioning; the
+    # partitioning scheme turns out exhibiting bad behaviour on sorted arrays.
+    @wrap
+    def _run_quicksort(A):
+        stack = [Partition(zero, zero)] * 100
+        stack[0] = Partition(zero, len(A) - 1)
+        n = 1
+
+        while n > 0:
+            n -= 1
+            low, high = stack[n]
+            # Partition until it becomes more efficient to do an insertion sort
+            while high - low >= SMALL_QUICKSORT:
+                assert n < MAX_STACK
+                l, r = partition3(A, low, high)
+                # One trivial (empty) partition => iterate on the other
+                if r == high:
+                    high = l - 1
+                elif l == low:
+                    low = r + 1
+                # Push largest partition on the stack
+                elif high - r > l - low:
+                    # Right is larger
+                    stack[n] = Partition(r + 1, high)
+                    n += 1
+                    high = l - 1
+                else:
+                    stack[n] = Partition(low, l - 1)
+                    n += 1
+                    low = r + 1
+
+            insertion_sort(A, low, high)
+
+
+    return QuicksortImplementation(wrap,
+                                   partition, partition3, insertion_sort,
+                                   run_quicksort)
+
+
+def make_py_quicksort(*args, **kwargs):
+    return make_quicksort_impl((lambda f: f), *args, **kwargs)
+
+def make_jit_quicksort(*args, **kwargs):
+    from numba.core.extending import register_jitable
+    return make_quicksort_impl((lambda f: register_jitable(f)),
+                               *args, **kwargs)

venv/lib/python3.10/site-packages/numba/misc/special.py

@@ -0,0 +1,104 @@
+import numpy as np
+
+from numba.core.typing.typeof import typeof
+from numba.core.typing.asnumbatype import as_numba_type
+
+
+def pndindex(*args):
+    """ Provides an n-dimensional parallel iterator that generates index tuples
+    for each iteration point. Sequentially, pndindex is identical to np.ndindex.
+    """
+    return np.ndindex(*args)
+
+
+class prange(object):
+    """ Provides a 1D parallel iterator that generates a sequence of integers.
+    In non-parallel contexts, prange is identical to range.
+    """
+    def __new__(cls, *args):
+        return range(*args)
+
+
+def _gdb_python_call_gen(func_name, *args):
+    # generates a call to a function containing a compiled in gdb command,
+    # this is to make `numba.gdb*` work in the interpreter.
+    import numba
+    fn = getattr(numba, func_name)
+    argstr = ','.join(['"%s"' for _ in args]) % args
+    defn = """def _gdb_func_injection():\n\t%s(%s)\n
+    """ % (func_name, argstr)
+    l = {}
+    exec(defn, {func_name: fn}, l)
+    return numba.njit(l['_gdb_func_injection'])
+
+
+def gdb(*args):
+    """
+    Calling this function will invoke gdb and attach it to the current process
+    at the call site. Arguments are strings in the gdb command language syntax
+    which will be executed by gdb once initialisation has occurred.
+    """
+    _gdb_python_call_gen('gdb', *args)()
+
+
+def gdb_breakpoint():
+    """
+    Calling this function will inject a breakpoint at the call site that is
+    recognised by both `gdb` and `gdb_init`, this is to allow breaking at
+    multiple points. gdb will stop in the user defined code just after the frame
+    employed by the breakpoint returns.
+    """
+    _gdb_python_call_gen('gdb_breakpoint')()
+
+
+def gdb_init(*args):
+    """
+    Calling this function will invoke gdb and attach it to the current process
+    at the call site, then continue executing the process under gdb's control.
+    Arguments are strings in the gdb command language syntax which will be
+    executed by gdb once initialisation has occurred.
+    """
+    _gdb_python_call_gen('gdb_init', *args)()
+
+
+def literally(obj):
+    """Forces Numba to interpret *obj* as an Literal value.
+
+    *obj* must be either a literal or an argument of the caller function, where
+    the argument must be bound to a literal. The literal requirement
+    propagates up the call stack.
+
+    This function is intercepted by the compiler to alter the compilation
+    behavior to wrap the corresponding function parameters as ``Literal``.
+    It has **no effect** outside of nopython-mode (interpreter, and objectmode).
+
+    The current implementation detects literal arguments in two ways:
+
+    1. Scans for uses of ``literally`` via a compiler pass.
+    2. ``literally`` is overloaded to raise ``numba.errors.ForceLiteralArg``
+       to signal the dispatcher to treat the corresponding parameter
+       differently. This mode is to support indirect use (via a function call).
+
+    The execution semantic of this function is equivalent to an identity
+    function.
+
+    See :ghfile:`numba/tests/test_literal_dispatch.py` for examples.
+    """
+    return obj
+
+
+def literal_unroll(container):
+    return container
+
+
+__all__ = [
+    'typeof',
+    'as_numba_type',
+    'prange',
+    'pndindex',
+    'gdb',
+    'gdb_breakpoint',
+    'gdb_init',
+    'literally',
+    'literal_unroll',
+]

venv/lib/python3.10/site-packages/numba/misc/timsort.py

@@ -0,0 +1,943 @@
+"""
+Timsort implementation.  Mostly adapted from CPython's listobject.c.
+
+For more information, see listsort.txt in CPython's source tree.
+"""
+
+
+import collections
+
+from numba.core import types
+
+
+TimsortImplementation = collections.namedtuple(
+    'TimsortImplementation',
+    (# The compile function itself
+     'compile',
+     # All subroutines exercised by test_sort
+     'count_run', 'binarysort', 'gallop_left', 'gallop_right',
+     'merge_init', 'merge_append', 'merge_pop',
+     'merge_compute_minrun', 'merge_lo', 'merge_hi', 'merge_at',
+     'merge_force_collapse', 'merge_collapse',
+     # The top-level functions
+     'run_timsort', 'run_timsort_with_values'
+     ))
+
+
+# The maximum number of entries in a MergeState's pending-runs stack.
+# This is enough to sort arrays of size up to about
+#    32 * phi ** MAX_MERGE_PENDING
+# where phi ~= 1.618.  85 is ridiculously large enough, good for an array
+# with 2**64 elements.
+# NOTE this implementation doesn't depend on it (the stack is dynamically
+# allocated), but it's still good to check as an invariant.
+MAX_MERGE_PENDING  = 85
+
+# When we get into galloping mode, we stay there until both runs win less
+# often than MIN_GALLOP consecutive times.  See listsort.txt for more info.
+MIN_GALLOP = 7
+
+# Start size for temp arrays.
+MERGESTATE_TEMP_SIZE = 256
+
+# A mergestate is a named tuple with the following members:
+#  - *min_gallop* is an integer controlling when we get into galloping mode
+#  - *keys* is a temp list for merging keys
+#  - *values* is a temp list for merging values, if needed
+#  - *pending* is a stack of pending runs to be merged
+#  - *n* is the current stack length of *pending*
+
+MergeState = collections.namedtuple(
+    'MergeState', ('min_gallop', 'keys', 'values', 'pending', 'n'))
+
+
+MergeRun = collections.namedtuple('MergeRun', ('start', 'size'))
+
+
+def make_timsort_impl(wrap, make_temp_area):
+
+    make_temp_area = wrap(make_temp_area)
+    intp = types.intp
+    zero = intp(0)
+
+    @wrap
+    def has_values(keys, values):
+        return values is not keys
+
+    @wrap
+    def merge_init(keys):
+        """
+        Initialize a MergeState for a non-keyed sort.
+        """
+        temp_size = min(len(keys) // 2 + 1, MERGESTATE_TEMP_SIZE)
+        temp_keys = make_temp_area(keys, temp_size)
+        temp_values = temp_keys
+        pending = [MergeRun(zero, zero)] * MAX_MERGE_PENDING
+        return MergeState(intp(MIN_GALLOP), temp_keys, temp_values, pending, zero)
+
+    @wrap
+    def merge_init_with_values(keys, values):
+        """
+        Initialize a MergeState for a keyed sort.
+        """
+        temp_size = min(len(keys) // 2 + 1, MERGESTATE_TEMP_SIZE)
+        temp_keys = make_temp_area(keys, temp_size)
+        temp_values = make_temp_area(values, temp_size)
+        pending = [MergeRun(zero, zero)] * MAX_MERGE_PENDING
+        return MergeState(intp(MIN_GALLOP), temp_keys, temp_values, pending, zero)
+
+    @wrap
+    def merge_append(ms, run):
+        """
+        Append a run on the merge stack.
+        """
+        n = ms.n
+        assert n < MAX_MERGE_PENDING
+        ms.pending[n] = run
+        return MergeState(ms.min_gallop, ms.keys, ms.values, ms.pending, n + 1)
+
+    @wrap
+    def merge_pop(ms):
+        """
+        Pop the top run from the merge stack.
+        """
+        return MergeState(ms.min_gallop, ms.keys, ms.values, ms.pending, ms.n - 1)
+
+    @wrap
+    def merge_getmem(ms, need):
+        """
+        Ensure enough temp memory for 'need' items is available.
+        """
+        alloced = len(ms.keys)
+        if need <= alloced:
+            return ms
+        # Over-allocate
+        while alloced < need:
+            alloced = alloced << 1
+        # Don't realloc!  That can cost cycles to copy the old data, but
+        # we don't care what's in the block.
+        temp_keys = make_temp_area(ms.keys, alloced)
+        if has_values(ms.keys, ms.values):
+            temp_values = make_temp_area(ms.values, alloced)
+        else:
+            temp_values = temp_keys
+        return MergeState(ms.min_gallop, temp_keys, temp_values, ms.pending, ms.n)
+
+    @wrap
+    def merge_adjust_gallop(ms, new_gallop):
+        """
+        Modify the MergeState's min_gallop.
+        """
+        return MergeState(intp(new_gallop), ms.keys, ms.values, ms.pending, ms.n)
+
+
+    @wrap
+    def LT(a, b):
+        """
+        Trivial comparison function between two keys.  This is factored out to
+        make it clear where comparisons occur.
+        """
+        return a < b
+
+    @wrap
+    def binarysort(keys, values, lo, hi, start):
+        """
+        binarysort is the best method for sorting small arrays: it does
+        few compares, but can do data movement quadratic in the number of
+        elements.
+        [lo, hi) is a contiguous slice of a list, and is sorted via
+        binary insertion.  This sort is stable.
+        On entry, must have lo <= start <= hi, and that [lo, start) is already
+        sorted (pass start == lo if you don't know!).
+        """
+        assert lo <= start and start <= hi
+        _has_values = has_values(keys, values)
+        if lo == start:
+            start += 1
+        while start < hi:
+            pivot = keys[start]
+            # Bisect to find where to insert `pivot`
+            # NOTE: bisection only wins over linear search if the comparison
+            # function is much more expensive than simply moving data.
+            l = lo
+            r = start
+            # Invariants:
+            # pivot >= all in [lo, l).
+            # pivot  < all in [r, start).
+            # The second is vacuously true at the start.
+            while l < r:
+                p = l + ((r - l) >> 1)
+                if LT(pivot, keys[p]):
+                    r = p
+                else:
+                    l = p+1
+
+            # The invariants still hold, so pivot >= all in [lo, l) and
+            # pivot < all in [l, start), so pivot belongs at l.  Note
+            # that if there are elements equal to pivot, l points to the
+            # first slot after them -- that's why this sort is stable.
+            # Slide over to make room (aka memmove()).
+            for p in range(start, l, -1):
+                keys[p] = keys[p - 1]
+            keys[l] = pivot
+            if _has_values:
+                pivot_val = values[start]
+                for p in range(start, l, -1):
+                    values[p] = values[p - 1]
+                values[l] = pivot_val
+
+            start += 1
+
+
+    @wrap
+    def count_run(keys, lo, hi):
+        """
+        Return the length of the run beginning at lo, in the slice [lo, hi).
+        lo < hi is required on entry.  "A run" is the longest ascending sequence, with
+
+            lo[0] <= lo[1] <= lo[2] <= ...
+
+        or the longest descending sequence, with
+
+            lo[0] > lo[1] > lo[2] > ...
+
+        A tuple (length, descending) is returned, where boolean *descending*
+        is set to 0 in the former case, or to 1 in the latter.
+        For its intended use in a stable mergesort, the strictness of the defn of
+        "descending" is needed so that the caller can safely reverse a descending
+        sequence without violating stability (strict > ensures there are no equal
+        elements to get out of order).
+        """
+        assert lo < hi
+        if lo + 1 == hi:
+            # Trivial 1-long run
+            return 1, False
+        if LT(keys[lo + 1], keys[lo]):
+            # Descending run
+            for k in range(lo + 2, hi):
+                if not LT(keys[k], keys[k - 1]):
+                    return k - lo, True
+            return hi - lo, True
+        else:
+            # Ascending run
+            for k in range(lo + 2, hi):
+                if LT(keys[k], keys[k - 1]):
+                    return k - lo, False
+            return hi - lo, False
+
+
+    @wrap
+    def gallop_left(key, a, start, stop, hint):
+        """
+        Locate the proper position of key in a sorted vector; if the vector contains
+        an element equal to key, return the position immediately to the left of
+        the leftmost equal element.  [gallop_right() does the same except returns
+        the position to the right of the rightmost equal element (if any).]
+
+        "a" is a sorted vector with stop elements, starting at a[start].
+        stop must be > start.
+
+        "hint" is an index at which to begin the search, start <= hint < stop.
+        The closer hint is to the final result, the faster this runs.
+
+        The return value is the int k in start..stop such that
+
+            a[k-1] < key <= a[k]
+
+        pretending that a[start-1] is minus infinity and a[stop] is plus infinity.
+        IOW, key belongs at index k; or, IOW, the first k elements of a should
+        precede key, and the last stop-start-k should follow key.
+
+        See listsort.txt for info on the method.
+        """
+        assert stop > start
+        assert hint >= start and hint < stop
+        n = stop - start
+
+        # First, gallop from the hint to find a "good" subinterval for bisecting
+        lastofs = 0
+        ofs = 1
+        if LT(a[hint], key):
+            # a[hint] < key => gallop right, until
+            #                  a[hint + lastofs] < key <= a[hint + ofs]
+            maxofs = stop - hint
+            while ofs < maxofs:
+                if LT(a[hint + ofs], key):
+                    lastofs = ofs
+                    ofs = (ofs << 1) + 1
+                    if ofs <= 0:
+                        # Int overflow
+                        ofs = maxofs
+                else:
+                    # key <= a[hint + ofs]
+                    break
+            if ofs > maxofs:
+                ofs = maxofs
+            # Translate back to offsets relative to a[0]
+            lastofs += hint
+            ofs += hint
+        else:
+            # key <= a[hint] => gallop left, until
+            #                   a[hint - ofs] < key <= a[hint - lastofs]
+            maxofs = hint - start + 1
+            while ofs < maxofs:
+                if LT(a[hint - ofs], key):
+                    break
+                else:
+                    # key <= a[hint - ofs]
+                    lastofs = ofs
+                    ofs = (ofs << 1) + 1
+                    if ofs <= 0:
+                        # Int overflow
+                        ofs = maxofs
+            if ofs > maxofs:
+                ofs = maxofs
+            # Translate back to positive offsets relative to a[0]
+            lastofs, ofs = hint - ofs, hint - lastofs
+
+        assert start - 1 <= lastofs and lastofs < ofs and ofs <= stop
+        # Now a[lastofs] < key <= a[ofs], so key belongs somewhere to the
+        # right of lastofs but no farther right than ofs.  Do a binary
+        # search, with invariant a[lastofs-1] < key <= a[ofs].
+        lastofs += 1
+        while lastofs < ofs:
+            m = lastofs + ((ofs - lastofs) >> 1)
+            if LT(a[m], key):
+                # a[m] < key
+                lastofs = m + 1
+            else:
+                # key <= a[m]
+                ofs = m
+        # Now lastofs == ofs, so a[ofs - 1] < key <= a[ofs]
+        return ofs
+
+
+    @wrap
+    def gallop_right(key, a, start, stop, hint):
+        """
+        Exactly like gallop_left(), except that if key already exists in a[start:stop],
+        finds the position immediately to the right of the rightmost equal value.
+
+        The return value is the int k in start..stop such that
+
+            a[k-1] <= key < a[k]
+
+        The code duplication is massive, but this is enough different given that
+        we're sticking to "<" comparisons that it's much harder to follow if
+        written as one routine with yet another "left or right?" flag.
+        """
+        assert stop > start
+        assert hint >= start and hint < stop
+        n = stop - start
+
+        # First, gallop from the hint to find a "good" subinterval for bisecting
+        lastofs = 0
+        ofs = 1
+        if LT(key, a[hint]):
+            # key < a[hint] => gallop left, until
+            #                  a[hint - ofs] <= key < a[hint - lastofs]
+            maxofs = hint - start + 1
+            while ofs < maxofs:
+                if LT(key, a[hint - ofs]):
+                    lastofs = ofs
+                    ofs = (ofs << 1) + 1
+                    if ofs <= 0:
+                        # Int overflow
+                        ofs = maxofs
+                else:
+                    # a[hint - ofs] <= key
+                    break
+            if ofs > maxofs:
+                ofs = maxofs
+            # Translate back to positive offsets relative to a[0]
+            lastofs, ofs = hint - ofs, hint - lastofs
+        else:
+            # a[hint] <= key -- gallop right, until
+            # a[hint + lastofs] <= key < a[hint + ofs]
+            maxofs = stop - hint
+            while ofs < maxofs:
+                if LT(key, a[hint + ofs]):
+                    break
+                else:
+                    # a[hint + ofs] <= key
+                    lastofs = ofs
+                    ofs = (ofs << 1) + 1
+                    if ofs <= 0:
+                        # Int overflow
+                        ofs = maxofs
+            if ofs > maxofs:
+                ofs = maxofs
+            # Translate back to offsets relative to a[0]
+            lastofs += hint
+            ofs += hint
+
+        assert start - 1 <= lastofs and lastofs < ofs and ofs <= stop
+        # Now a[lastofs] <= key < a[ofs], so key belongs somewhere to the
+        # right of lastofs but no farther right than ofs.  Do a binary
+        # search, with invariant a[lastofs-1] <= key < a[ofs].
+        lastofs += 1
+        while lastofs < ofs:
+            m = lastofs + ((ofs - lastofs) >> 1)
+            if LT(key, a[m]):
+                # key < a[m]
+                ofs = m
+            else:
+                # a[m] <= key
+                lastofs = m + 1
+        # Now lastofs == ofs, so a[ofs - 1] <= key < a[ofs]
+        return ofs
+
+
+    @wrap
+    def merge_compute_minrun(n):
+        """
+        Compute a good value for the minimum run length; natural runs shorter
+        than this are boosted artificially via binary insertion.
+
+        If n < 64, return n (it's too small to bother with fancy stuff).
+        Else if n is an exact power of 2, return 32.
+        Else return an int k, 32 <= k <= 64, such that n/k is close to, but
+        strictly less than, an exact power of 2.
+
+        See listsort.txt for more info.
+        """
+        r = 0
+        assert n >= 0
+        while n >= 64:
+            r |= n & 1
+            n >>= 1
+        return n + r
+
+
+    @wrap
+    def sortslice_copy(dest_keys, dest_values, dest_start,
+                       src_keys, src_values, src_start,
+                       nitems):
+        """
+        Upwards memcpy().
+        """
+        assert src_start >= 0
+        assert dest_start >= 0
+        for i in range(nitems):
+            dest_keys[dest_start + i] = src_keys[src_start + i]
+        if has_values(src_keys, src_values):
+            for i in range(nitems):
+                dest_values[dest_start + i] = src_values[src_start + i]
+
+    @wrap
+    def sortslice_copy_down(dest_keys, dest_values, dest_start,
+                            src_keys, src_values, src_start,
+                            nitems):
+        """
+        Downwards memcpy().
+        """
+        assert src_start >= 0
+        assert dest_start >= 0
+        for i in range(nitems):
+            dest_keys[dest_start - i] = src_keys[src_start - i]
+        if has_values(src_keys, src_values):
+            for i in range(nitems):
+                dest_values[dest_start - i] = src_values[src_start - i]
+
+
+    # Disable this for debug or perf comparison
+    DO_GALLOP = 1
+
+    @wrap
+    def merge_lo(ms, keys, values, ssa, na, ssb, nb):
+        """
+        Merge the na elements starting at ssa with the nb elements starting at
+        ssb = ssa + na in a stable way, in-place.  na and nb must be > 0,
+        and should have na <= nb. See listsort.txt for more info.
+
+        An updated MergeState is returned (with possibly a different min_gallop
+        or larger temp arrays).
+
+        NOTE: compared to CPython's timsort, the requirement that
+            "Must also have that keys[ssa + na - 1] belongs at the end of the merge"
+
+        is removed. This makes the code a bit simpler and easier to reason about.
+        """
+        assert na > 0 and nb > 0 and na <= nb
+        assert ssb == ssa + na
+        # First copy [ssa, ssa + na) into the temp space
+        ms = merge_getmem(ms, na)
+        sortslice_copy(ms.keys, ms.values, 0,
+                       keys, values, ssa,
+                       na)
+        a_keys = ms.keys
+        a_values = ms.values
+        b_keys = keys
+        b_values = values
+        dest = ssa
+        ssa = 0
+
+        _has_values = has_values(a_keys, a_values)
+        min_gallop = ms.min_gallop
+
+        # Now start merging into the space left from [ssa, ...)
+
+        while nb > 0 and na > 0:
+            # Do the straightforward thing until (if ever) one run
+            # appears to win consistently.
+            acount = 0
+            bcount = 0
+
+            while True:
+                if LT(b_keys[ssb], a_keys[ssa]):
+                    keys[dest] = b_keys[ssb]
+                    if _has_values:
+                        values[dest] = b_values[ssb]
+                    dest += 1
+                    ssb += 1
+                    nb -= 1
+                    if nb == 0:
+                        break
+                    # It's a B run
+                    bcount += 1
+                    acount = 0
+                    if bcount >= min_gallop:
+                        break
+                else:
+                    keys[dest] = a_keys[ssa]
+                    if _has_values:
+                        values[dest] = a_values[ssa]
+                    dest += 1
+                    ssa += 1
+                    na -= 1
+                    if na == 0:
+                        break
+                    # It's a A run
+                    acount += 1
+                    bcount = 0
+                    if acount >= min_gallop:
+                        break
+
+            # One run is winning so consistently that galloping may
+            # be a huge win.  So try that, and continue galloping until
+            # (if ever) neither run appears to be winning consistently
+            # anymore.
+            if DO_GALLOP and na > 0 and nb > 0:
+                min_gallop += 1
+
+                while acount >= MIN_GALLOP or bcount >= MIN_GALLOP:
+                    # As long as we gallop without leaving this loop, make
+                    # the heuristic more likely
+                    min_gallop -= min_gallop > 1
+
+                    # Gallop in A to find where keys[ssb] should end up
+                    k = gallop_right(b_keys[ssb], a_keys, ssa, ssa + na, ssa)
+                    # k is an index, make it a size
+                    k -= ssa
+                    acount = k
+                    if k > 0:
+                        # Copy everything from A before k
+                        sortslice_copy(keys, values, dest,
+                                       a_keys, a_values, ssa,
+                                       k)
+                        dest += k
+                        ssa += k
+                        na -= k
+                        if na == 0:
+                            # Finished merging
+                            break
+                    # Copy keys[ssb]
+                    keys[dest] = b_keys[ssb]
+                    if _has_values:
+                        values[dest] = b_values[ssb]
+                    dest += 1
+                    ssb += 1
+                    nb -= 1
+                    if nb == 0:
+                        # Finished merging
+                        break
+
+                    # Gallop in B to find where keys[ssa] should end up
+                    k = gallop_left(a_keys[ssa], b_keys, ssb, ssb + nb, ssb)
+                    # k is an index, make it a size
+                    k -= ssb
+                    bcount = k
+                    if k > 0:
+                        # Copy everything from B before k
+                        # NOTE: source and dest are the same buffer, but the
+                        # destination index is below the source index
+                        sortslice_copy(keys, values, dest,
+                                       b_keys, b_values, ssb,
+                                       k)
+                        dest += k
+                        ssb += k
+                        nb -= k
+                        if nb == 0:
+                            # Finished merging
+                            break
+                    # Copy keys[ssa]
+                    keys[dest] = a_keys[ssa]
+                    if _has_values:
+                        values[dest] = a_values[ssa]
+                    dest += 1
+                    ssa += 1
+                    na -= 1
+                    if na == 0:
+                        # Finished merging
+                        break
+
+                # Penalize it for leaving galloping mode
+                min_gallop += 1
+
+        # Merge finished, now handle the remaining areas
+        if nb == 0:
+            # Only A remaining to copy at the end of the destination area
+            sortslice_copy(keys, values, dest,
+                           a_keys, a_values, ssa,
+                           na)
+        else:
+            assert na == 0
+            assert dest == ssb
+            # B's tail is already at the right place, do nothing
+
+        return merge_adjust_gallop(ms, min_gallop)
+
+
+    @wrap
+    def merge_hi(ms, keys, values, ssa, na, ssb, nb):
+        """
+        Merge the na elements starting at ssa with the nb elements starting at
+        ssb = ssa + na in a stable way, in-place.  na and nb must be > 0,
+        and should have na >= nb.  See listsort.txt for more info.
+
+        An updated MergeState is returned (with possibly a different min_gallop
+        or larger temp arrays).
+
+        NOTE: compared to CPython's timsort, the requirement that
+            "Must also have that keys[ssa + na - 1] belongs at the end of the merge"
+
+        is removed. This makes the code a bit simpler and easier to reason about.
+        """
+        assert na > 0 and nb > 0 and na >= nb
+        assert ssb == ssa + na
+        # First copy [ssb, ssb + nb) into the temp space
+        ms = merge_getmem(ms, nb)
+        sortslice_copy(ms.keys, ms.values, 0,
+                       keys, values, ssb,
+                       nb)
+        a_keys = keys
+        a_values = values
+        b_keys = ms.keys
+        b_values = ms.values
+
+        # Now start merging *in descending order* into the space left
+        # from [..., ssb + nb).
+        dest = ssb + nb - 1
+        ssb = nb - 1
+        ssa = ssa + na - 1
+
+        _has_values = has_values(b_keys, b_values)
+        min_gallop = ms.min_gallop
+
+        while nb > 0 and na > 0:
+            # Do the straightforward thing until (if ever) one run
+            # appears to win consistently.
+            acount = 0
+            bcount = 0
+
+            while True:
+                if LT(b_keys[ssb], a_keys[ssa]):
+                    # We merge in descending order, so copy the larger value
+                    keys[dest] = a_keys[ssa]
+                    if _has_values:
+                        values[dest] = a_values[ssa]
+                    dest -= 1
+                    ssa -= 1
+                    na -= 1
+                    if na == 0:
+                        break
+                    # It's a A run
+                    acount += 1
+                    bcount = 0
+                    if acount >= min_gallop:
+                        break
+                else:
+                    keys[dest] = b_keys[ssb]
+                    if _has_values:
+                        values[dest] = b_values[ssb]
+                    dest -= 1
+                    ssb -= 1
+                    nb -= 1
+                    if nb == 0:
+                        break
+                    # It's a B run
+                    bcount += 1
+                    acount = 0
+                    if bcount >= min_gallop:
+                        break
+
+            # One run is winning so consistently that galloping may
+            # be a huge win.  So try that, and continue galloping until
+            # (if ever) neither run appears to be winning consistently
+            # anymore.
+            if DO_GALLOP and na > 0 and nb > 0:
+                min_gallop += 1
+
+                while acount >= MIN_GALLOP or bcount >= MIN_GALLOP:
+                    # As long as we gallop without leaving this loop, make
+                    # the heuristic more likely
+                    min_gallop -= min_gallop > 1
+
+                    # Gallop in A to find where keys[ssb] should end up
+                    k = gallop_right(b_keys[ssb], a_keys, ssa - na + 1, ssa + 1, ssa)
+                    # k is an index, make it a size from the end
+                    k = ssa + 1 - k
+                    acount = k
+                    if k > 0:
+                        # Copy everything from A after k.
+                        # Destination and source are the same buffer, and destination
+                        # index is greater, so copy from the end to the start.
+                        sortslice_copy_down(keys, values, dest,
+                                            a_keys, a_values, ssa,
+                                            k)
+                        dest -= k
+                        ssa -= k
+                        na -= k
+                        if na == 0:
+                            # Finished merging
+                            break
+                    # Copy keys[ssb]
+                    keys[dest] = b_keys[ssb]
+                    if _has_values:
+                        values[dest] = b_values[ssb]
+                    dest -= 1
+                    ssb -= 1
+                    nb -= 1
+                    if nb == 0:
+                        # Finished merging
+                        break
+
+                    # Gallop in B to find where keys[ssa] should end up
+                    k = gallop_left(a_keys[ssa], b_keys, ssb - nb + 1, ssb + 1, ssb)
+                    # k is an index, make it a size from the end
+                    k = ssb + 1 - k
+                    bcount = k
+                    if k > 0:
+                        # Copy everything from B before k
+                        sortslice_copy_down(keys, values, dest,
+                                            b_keys, b_values, ssb,
+                                            k)
+                        dest -= k
+                        ssb -= k
+                        nb -= k
+                        if nb == 0:
+                            # Finished merging
+                            break
+                    # Copy keys[ssa]
+                    keys[dest] = a_keys[ssa]
+                    if _has_values:
+                        values[dest] = a_values[ssa]
+                    dest -= 1
+                    ssa -= 1
+                    na -= 1
+                    if na == 0:
+                        # Finished merging
+                        break
+
+                # Penalize it for leaving galloping mode
+                min_gallop += 1
+
+        # Merge finished, now handle the remaining areas
+        if na == 0:
+            # Only B remaining to copy at the front of the destination area
+            sortslice_copy(keys, values, dest - nb + 1,
+                           b_keys, b_values, ssb - nb + 1,
+                           nb)
+        else:
+            assert nb == 0
+            assert dest == ssa
+            # A's front is already at the right place, do nothing
+
+        return merge_adjust_gallop(ms, min_gallop)
+
+
+    @wrap
+    def merge_at(ms, keys, values, i):
+        """
+        Merge the two runs at stack indices i and i+1.
+
+        An updated MergeState is returned.
+        """
+        n = ms.n
+        assert n >= 2
+        assert i >= 0
+        assert i == n - 2 or i == n - 3
+
+        ssa, na = ms.pending[i]
+        ssb, nb = ms.pending[i + 1]
+        assert na > 0 and nb > 0
+        assert ssa + na == ssb
+
+        # Record the length of the combined runs; if i is the 3rd-last
+        # run now, also slide over the last run (which isn't involved
+        # in this merge).  The current run i+1 goes away in any case.
+        ms.pending[i] = MergeRun(ssa, na + nb)
+        if i == n - 3:
+            ms.pending[i + 1] = ms.pending[i + 2]
+        ms = merge_pop(ms)
+
+        # Where does b start in a?  Elements in a before that can be
+        # ignored (already in place).
+        k = gallop_right(keys[ssb], keys, ssa, ssa + na, ssa)
+        # [k, ssa + na) remains to be merged
+        na -= k - ssa
+        ssa = k
+        if na == 0:
+            return ms
+
+        # Where does a end in b?  Elements in b after that can be
+        # ignored (already in place).
+        k = gallop_left(keys[ssa + na - 1], keys, ssb, ssb + nb, ssb + nb - 1)
+        # [ssb, k) remains to be merged
+        nb = k - ssb
+
+        # Merge what remains of the runs, using a temp array with
+        # min(na, nb) elements.
+        if na <= nb:
+            return merge_lo(ms, keys, values, ssa, na, ssb, nb)
+        else:
+            return merge_hi(ms, keys, values, ssa, na, ssb, nb)
+
+
+    @wrap
+    def merge_collapse(ms, keys, values):
+        """
+        Examine the stack of runs waiting to be merged, merging adjacent runs
+        until the stack invariants are re-established:
+
+        1. len[-3] > len[-2] + len[-1]
+        2. len[-2] > len[-1]
+
+        An updated MergeState is returned.
+
+        See listsort.txt for more info.
+        """
+        while ms.n > 1:
+            pending = ms.pending
+            n = ms.n - 2
+            if ((n > 0 and pending[n-1].size <= pending[n].size + pending[n+1].size) or
+                (n > 1 and pending[n-2].size <= pending[n-1].size + pending[n].size)):
+                if pending[n - 1].size < pending[n + 1].size:
+                    # Merge smaller one first
+                    n -= 1
+                ms = merge_at(ms, keys, values, n)
+            elif pending[n].size < pending[n + 1].size:
+                ms = merge_at(ms, keys, values, n)
+            else:
+                break
+        return ms
+
+    @wrap
+    def merge_force_collapse(ms, keys, values):
+        """
+        Regardless of invariants, merge all runs on the stack until only one
+        remains.  This is used at the end of the mergesort.
+
+        An updated MergeState is returned.
+        """
+        while ms.n > 1:
+            pending = ms.pending
+            n = ms.n - 2
+            if n > 0:
+                if pending[n - 1].size < pending[n + 1].size:
+                    # Merge the smaller one first
+                    n -= 1
+            ms = merge_at(ms, keys, values, n)
+        return ms
+
+
+    @wrap
+    def reverse_slice(keys, values, start, stop):
+        """
+        Reverse a slice, in-place.
+        """
+        i = start
+        j = stop - 1
+        while i < j:
+            keys[i], keys[j] = keys[j], keys[i]
+            i += 1
+            j -= 1
+        if has_values(keys, values):
+            i = start
+            j = stop - 1
+            while i < j:
+                values[i], values[j] = values[j], values[i]
+                i += 1
+                j -= 1
+
+
+    @wrap
+    def run_timsort_with_mergestate(ms, keys, values):
+        """
+        Run timsort with the mergestate.
+        """
+        nremaining = len(keys)
+        if nremaining < 2:
+            return
+
+        # March over the array once, left to right, finding natural runs,
+        # and extending short natural runs to minrun elements.
+        minrun = merge_compute_minrun(nremaining)
+
+        lo = zero
+        while nremaining > 0:
+            n, desc = count_run(keys, lo, lo + nremaining)
+            if desc:
+                # Descending run => reverse
+                reverse_slice(keys, values, lo, lo + n)
+            # If short, extend to min(minrun, nremaining)
+            if n < minrun:
+                force = min(minrun, nremaining)
+                binarysort(keys, values, lo, lo + force, lo + n)
+                n = force
+            # Push run onto stack, and maybe merge.
+            ms = merge_append(ms, MergeRun(lo, n))
+            ms = merge_collapse(ms, keys, values)
+            # Advance to find next run.
+            lo += n
+            nremaining -= n
+
+        # All initial runs have been discovered, now finish merging.
+        ms = merge_force_collapse(ms, keys, values)
+        assert ms.n == 1
+        assert ms.pending[0] == (0, len(keys))
+
+
+    @wrap
+    def run_timsort(keys):
+        """
+        Run timsort over the given keys.
+        """
+        values = keys
+        run_timsort_with_mergestate(merge_init(keys), keys, values)
+
+
+    @wrap
+    def run_timsort_with_values(keys, values):
+        """
+        Run timsort over the given keys and values.
+        """
+        run_timsort_with_mergestate(merge_init_with_values(keys, values),
+                                    keys, values)
+
+    return TimsortImplementation(
+        wrap,
+        count_run, binarysort, gallop_left, gallop_right,
+        merge_init, merge_append, merge_pop,
+        merge_compute_minrun, merge_lo, merge_hi, merge_at,
+        merge_force_collapse, merge_collapse,
+        run_timsort, run_timsort_with_values)
+
+
+def make_py_timsort(*args):
+    return make_timsort_impl((lambda f: f), *args)
+
+def make_jit_timsort(*args):
+    from numba import jit
+    return make_timsort_impl((lambda f: jit(nopython=True)(f)),
+                              *args)